52 #define DURATION_LONGEST 0
53 #define DURATION_SHORTEST 1
54 #define DURATION_FIRST 2
81 while (frame_list->
list) {
94 if (!frame_list->
list)
101 if (!frame_list->
list)
111 int samples = nb_samples;
112 while (samples > 0) {
118 if (!frame_list->
list)
125 info->
pts += samples;
142 if (!frame_list->
list) {
143 frame_list->
list = info;
144 frame_list->
end = info;
148 frame_list->
end = info;
182 #define OFFSET(x) offsetof(MixContext, x)
183 #define A AV_OPT_FLAG_AUDIO_PARAM
184 #define F AV_OPT_FLAG_FILTERING_PARAM
185 #define T AV_OPT_FLAG_RUNTIME_PARAM
187 {
"inputs",
"Number of inputs.",
189 {
"duration",
"How to determine the end-of-stream.",
194 {
"dropout_transition",
"Transition time, in seconds, for volume "
195 "renormalization when an input stream ends.",
197 {
"weights",
"Set weight for each input.",
199 {
"normalize",
"Scale inputs",
215 float weight_sum = 0.f;
218 for (
i = 0;
i <
s->nb_inputs;
i++)
220 weight_sum +=
FFABS(
s->weights[
i]);
222 for (
i = 0;
i <
s->nb_inputs;
i++) {
224 if (
s->scale_norm[
i] > weight_sum /
FFABS(
s->weights[
i])) {
225 s->scale_norm[
i] -= ((
s->weight_sum /
FFABS(
s->weights[
i])) /
s->nb_inputs) *
226 nb_samples / (
s->dropout_transition *
s->sample_rate);
227 s->scale_norm[
i] =
FFMAX(
s->scale_norm[
i], weight_sum /
FFABS(
s->weights[
i]));
232 for (
i = 0;
i <
s->nb_inputs;
i++) {
235 s->input_scale[
i] =
FFABS(
s->weights[
i]);
237 s->input_scale[
i] = 1.0f /
s->scale_norm[
i] *
FFSIGN(
s->weights[
i]);
239 s->input_scale[
i] = 0.0f;
265 for (
i = 0;
i <
s->nb_inputs;
i++) {
274 memset(
s->input_state,
INPUT_ON,
s->nb_inputs);
275 s->active_inputs =
s->nb_inputs;
279 if (!
s->input_scale || !
s->scale_norm)
281 for (
i = 0;
i <
s->nb_inputs;
i++)
282 s->scale_norm[
i] =
s->weight_sum /
FFABS(
s->weights[
i]);
288 "inputs:%d fmt:%s srate:%d cl:%s\n",
s->nb_inputs,
302 int nb_samples,
ns,
i;
307 for (
i = 1;
i <
s->nb_inputs;
i++) {
310 if (
ns < nb_samples) {
323 nb_samples = INT_MAX;
324 for (
i = 1;
i <
s->nb_inputs;
i++) {
327 nb_samples =
FFMIN(nb_samples,
ns);
330 if (nb_samples == INT_MAX) {
353 for (
i = 0;
i <
s->nb_inputs;
i++) {
355 int planes, plane_size, p;
360 planes =
s->planar ?
s->nb_channels : 1;
361 plane_size = nb_samples * (
s->planar ? 1 :
s->nb_channels);
362 plane_size =
FFALIGN(plane_size, 16);
366 for (p = 0; p <
planes; p++) {
369 s->input_scale[
i], plane_size);
372 for (p = 0; p <
planes; p++) {
375 s->input_scale[
i], plane_size);
382 out_buf->
pts =
s->next_pts;
384 s->next_pts += nb_samples;
399 for (
i = 1;
i <
s->nb_inputs;
i++) {
419 int active_inputs = 0;
420 for (
i = 0;
i <
s->nb_inputs;
i++)
421 active_inputs += !!(
s->input_state[
i] &
INPUT_ON);
422 s->active_inputs = active_inputs;
424 if (!active_inputs ||
440 for (
i = 0;
i <
s->nb_inputs;
i++) {
469 for (
i = 0;
i <
s->nb_inputs;
i++) {
476 s->input_state[
i] = 0;
477 if (
s->nb_inputs == 1) {
484 s->input_state[
i] = 0;
502 if (
s->frame_list->nb_frames == 0) {
519 float last_weight = 1.f;
525 for (
i = 0;
i <
s->nb_inputs;
i++) {
527 s->weights[
i] = last_weight;
528 s->weight_sum +=
FFABS(last_weight);
537 for (;
i <
s->nb_inputs;
i++) {
538 s->weights[
i] = last_weight;
539 s->weight_sum +=
FFABS(last_weight);
548 for (
i = 0;
i <
s->nb_inputs;
i++) {
581 for (
i = 0;
i <
s->nb_inputs;
i++)
593 for (
i = 0;
i <
ctx->nb_inputs;
i++)
614 char *res,
int res_len,
int flags)
624 for (
int i = 0;
i <
s->nb_inputs;
i++)
625 s->scale_norm[
i] =
s->weight_sum /
FFABS(
s->weights[
i]);
644 .priv_class = &amix_class,
static enum AVSampleFormat sample_fmts[]
static const AVFilterPad inputs[]
static const AVFilterPad outputs[]
static int output_frame(AVFilterLink *outlink)
Read samples from the input FIFOs, mix, and write to the output link.
static int frame_list_add_frame(FrameList *frame_list, int nb_samples, int64_t pts)
static void calculate_scales(MixContext *s, int nb_samples)
Update the scaling factors to apply to each input during mixing.
static int64_t frame_list_next_pts(FrameList *frame_list)
static void parse_weights(AVFilterContext *ctx)
static int query_formats(AVFilterContext *ctx)
#define DURATION_SHORTEST
static int calc_active_inputs(MixContext *s)
Calculates the number of active inputs and determines EOF based on the duration option.
static void frame_list_remove_samples(FrameList *frame_list, int nb_samples)
#define INPUT_EOF
input has reached EOF (may still be active)
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
static int activate(AVFilterContext *ctx)
static av_cold int init(AVFilterContext *ctx)
static av_cold void uninit(AVFilterContext *ctx)
static const AVFilterPad avfilter_af_amix_outputs[]
static int frame_list_next_frame_size(FrameList *frame_list)
static void frame_list_clear(FrameList *frame_list)
static int config_output(AVFilterLink *outlink)
AVFILTER_DEFINE_CLASS(amix)
static int request_samples(AVFilterContext *ctx, int min_samples)
Requests a frame, if needed, from each input link other than the first.
static const AVOption amix_options[]
#define INPUT_ON
input is active
Macro definitions for various function/variable attributes.
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Main libavfilter public API header.
char * av_asprintf(const char *fmt,...)
#define flags(name, subs,...)
#define ns(max_value, name, subs,...)
audio channel layout utility functions
common internal and external API header
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
simple arithmetic expression evaluator
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
#define FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, filter)
Forward the status on an output link to all input links.
static int ff_outlink_frame_wanted(AVFilterLink *link)
Test if a frame is wanted on an output link.
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples)
Write data to an AVAudioFifo.
void av_audio_fifo_free(AVAudioFifo *af)
Free an AVAudioFifo.
AVAudioFifo * av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, int nb_samples)
Allocate an AVAudioFifo.
int av_audio_fifo_size(AVAudioFifo *af)
Get the current number of samples in the AVAudioFifo available for reading.
int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples)
Read data from an AVAudioFifo.
#define AVERROR_EOF
End of file.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define AV_LOG_VERBOSE
Detailed information.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
AVSampleFormat
Audio sample formats.
@ AV_SAMPLE_FMT_FLTP
float, planar
@ AV_SAMPLE_FMT_DBLP
double, planar
@ AV_SAMPLE_FMT_DBL
double
#define AV_NOPTS_VALUE
Undefined timestamp value.
static int ff_insert_inpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new input pad for the filter.
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static const struct @322 planes[]
Context for an Audio FIFO Buffer.
Describe the class of an AVClass context structure.
A link between two filters.
int channels
Number of channels.
AVFilterContext * src
source filter
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link.
int sample_rate
samples per second
uint64_t channel_layout
channel layout of current buffer (see libavutil/channel_layout.h)
int format
agreed upon media format
A filter pad used for either input or output.
enum AVMediaType type
AVFilterPad type.
const char * name
Pad name.
const char * name
Filter name.
This structure describes decoded (raw) audio or video data.
int nb_samples
number of audio samples (per channel) described by this frame
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
uint8_t ** extended_data
pointers to the data planes/channels.
Rational number (pair of numerator and denominator).
Linked list used to store timestamps and frame sizes of all frames in the FIFO for the first input.
int nb_inputs
number of inputs
int64_t next_pts
calculated pts for next output frame
int active_inputs
number of input currently active
int nb_channels
number of channels
int normalize
if inputs are scaled
uint8_t * input_state
current state of each input
AVAudioFifo ** fifos
audio fifo for each input
float * scale_norm
normalization factor for every input
int duration_mode
mode for determining duration
char * weights_str
string for custom weights for every input
float * weights
custom weights for every input
float * input_scale
mixing scale factor for each input
FrameList * frame_list
list of frame info for the first input
int sample_rate
sample rate
float weight_sum
sum of custom weights for every input
float dropout_transition
transition time when an input drops out