FFmpeg
af_pan.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2002 Anders Johansson <ajh@atri.curtin.edu.au>
3  * Copyright (c) 2011 Clément Bœsch <u pkh me>
4  * Copyright (c) 2011 Nicolas George <nicolas.george@normalesup.org>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * Audio panning filter (channels mixing)
26  * Original code written by Anders Johansson for MPlayer,
27  * reimplemented for FFmpeg.
28  */
29 
30 #include <stdio.h>
31 #include "libavutil/avstring.h"
33 #include "libavutil/mem.h"
34 #include "libavutil/opt.h"
36 #include "audio.h"
37 #include "avfilter.h"
38 #include "formats.h"
39 #include "internal.h"
40 
41 #define MAX_CHANNELS 64
42 
43 typedef struct PanContext {
44  const AVClass *class;
45  char *args;
48  int64_t need_renorm;
51 
53  /* channel mapping specific */
55  struct SwrContext *swr;
56 } PanContext;
57 
58 static void skip_spaces(char **arg)
59 {
60  int len = 0;
61 
62  sscanf(*arg, " %n", &len);
63  *arg += len;
64 }
65 
66 static int parse_channel_name(char **arg, int *rchannel, int *rnamed)
67 {
68  char buf[8];
69  int len, channel_id = 0;
70 
72  /* try to parse a channel name, e.g. "FL" */
73  if (sscanf(*arg, "%7[A-Z]%n", buf, &len)) {
74  channel_id = av_channel_from_string(buf);
75  if (channel_id < 0)
76  return channel_id;
77 
78  *rchannel = channel_id;
79  *rnamed = 1;
80  *arg += len;
81  return 0;
82  }
83  /* try to parse a channel number, e.g. "c2" */
84  if (sscanf(*arg, "c%d%n", &channel_id, &len) &&
85  channel_id >= 0 && channel_id < MAX_CHANNELS) {
86  *rchannel = channel_id;
87  *rnamed = 0;
88  *arg += len;
89  return 0;
90  }
91  return AVERROR(EINVAL);
92 }
93 
95 {
96  PanContext *const pan = ctx->priv;
97  char *arg, *arg0, *tokenizer, *args = av_strdup(pan->args);
98  int out_ch_id, in_ch_id, len, named, ret, sign = 1;
99  int nb_in_channels[2] = { 0, 0 }; // number of unnamed and named input channels
100  int used_out_ch[MAX_CHANNELS] = {0};
101  double gain;
102 
103  if (!pan->args) {
105  "pan filter needs a channel layout and a set "
106  "of channel definitions as parameter\n");
107  return AVERROR(EINVAL);
108  }
109  if (!args)
110  return AVERROR(ENOMEM);
111  arg = av_strtok(args, "|", &tokenizer);
112  if (!arg) {
113  av_log(ctx, AV_LOG_ERROR, "Channel layout not specified\n");
114  ret = AVERROR(EINVAL);
115  goto fail;
116  }
118  &pan->nb_output_channels, arg, ctx);
119  if (ret < 0)
120  goto fail;
121 
122  /* parse channel specifications */
123  while ((arg = arg0 = av_strtok(NULL, "|", &tokenizer))) {
124  int used_in_ch[MAX_CHANNELS] = {0};
125  /* channel name */
126  if (parse_channel_name(&arg, &out_ch_id, &named)) {
128  "Expected out channel name, got \"%.8s\"\n", arg);
129  ret = AVERROR(EINVAL);
130  goto fail;
131  }
132  if (named) {
133  if ((out_ch_id = av_channel_layout_index_from_channel(&pan->out_channel_layout, out_ch_id)) < 0) {
135  "Channel \"%.8s\" does not exist in the chosen layout\n", arg0);
136  ret = AVERROR(EINVAL);
137  goto fail;
138  }
139  }
140  if (out_ch_id < 0 || out_ch_id >= pan->nb_output_channels) {
142  "Invalid out channel name \"%.8s\"\n", arg0);
143  ret = AVERROR(EINVAL);
144  goto fail;
145  }
146  if (used_out_ch[out_ch_id]) {
148  "Can not reference out channel %d twice\n", out_ch_id);
149  ret = AVERROR(EINVAL);
150  goto fail;
151  }
152  used_out_ch[out_ch_id] = 1;
153  skip_spaces(&arg);
154  if (*arg == '=') {
155  arg++;
156  } else if (*arg == '<') {
157  pan->need_renorm |= (int64_t)1 << out_ch_id;
158  arg++;
159  } else {
161  "Syntax error after channel name in \"%.8s\"\n", arg0);
162  ret = AVERROR(EINVAL);
163  goto fail;
164  }
165  /* gains */
166  sign = 1;
167  while (1) {
168  gain = 1;
169  if (sscanf(arg, "%lf%n *%n", &gain, &len, &len))
170  arg += len;
171  if (parse_channel_name(&arg, &in_ch_id, &named)){
173  "Expected in channel name, got \"%.8s\"\n", arg);
174  ret = AVERROR(EINVAL);
175  goto fail;
176  }
177  nb_in_channels[named]++;
178  if (nb_in_channels[!named]) {
180  "Can not mix named and numbered channels\n");
181  ret = AVERROR(EINVAL);
182  goto fail;
183  }
184  if (used_in_ch[in_ch_id]) {
186  "Can not reference in channel %d twice\n", in_ch_id);
187  ret = AVERROR(EINVAL);
188  goto fail;
189  }
190  used_in_ch[in_ch_id] = 1;
191  pan->gain[out_ch_id][in_ch_id] = sign * gain;
192  skip_spaces(&arg);
193  if (!*arg)
194  break;
195  if (*arg == '-') {
196  sign = -1;
197  } else if (*arg != '+') {
198  av_log(ctx, AV_LOG_ERROR, "Syntax error near \"%.8s\"\n", arg);
199  ret = AVERROR(EINVAL);
200  goto fail;
201  } else {
202  sign = 1;
203  }
204  arg++;
205  }
206  }
207  pan->need_renumber = !!nb_in_channels[1];
208 
209  ret = 0;
210 fail:
211  av_free(args);
212  return ret;
213 }
214 
215 static int are_gains_pure(const PanContext *pan)
216 {
217  int i, j;
218 
219  for (i = 0; i < MAX_CHANNELS; i++) {
220  int nb_gain = 0;
221 
222  for (j = 0; j < MAX_CHANNELS; j++) {
223  double gain = pan->gain[i][j];
224 
225  /* channel mapping is effective only if 0% or 100% of a channel is
226  * selected... */
227  if (gain != 0. && gain != 1.)
228  return 0;
229  /* ...and if the output channel is only composed of one input */
230  if (gain && nb_gain++)
231  return 0;
232  }
233  }
234  return 1;
235 }
236 
238 {
239  PanContext *pan = ctx->priv;
240  AVFilterLink *inlink = ctx->inputs[0];
241  AVFilterLink *outlink = ctx->outputs[0];
243  int ret;
244 
245  pan->pure_gains = are_gains_pure(pan);
246  /* libswr supports any sample and packing formats */
248  return ret;
249 
251  return ret;
252 
253  // inlink supports any channel layout
255  if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0)
256  return ret;
257 
258  // outlink supports only requested output channel layout
259  layouts = NULL;
261  return ret;
263 }
264 
266 {
267  AVFilterContext *ctx = link->dst;
268  PanContext *pan = ctx->priv;
269  char buf[1024], *cur;
270  int i, j, k, r, ret;
271  double t;
272 
273  if (pan->need_renumber) {
274  // input channels were given by their name: renumber them
275  for (i = j = 0; i < MAX_CHANNELS; i++) {
277  for (k = 0; k < pan->nb_output_channels; k++)
278  pan->gain[k][j] = pan->gain[k][i];
279  j++;
280  }
281  }
282  }
283 
284  // sanity check; can't be done in query_formats since the inlink
285  // channel layout is unknown at that time
289  "af_pan supports a maximum of %d channels. "
290  "Feel free to ask for a higher limit.\n", MAX_CHANNELS);
291  return AVERROR_PATCHWELCOME;
292  }
293 
294  // init libswresample context
295  ret = swr_alloc_set_opts2(&pan->swr,
298  0, ctx);
299  if (ret < 0)
300  return AVERROR(ENOMEM);
301 
302  // gains are pure, init the channel mapping
303  if (pan->pure_gains) {
304 
305  // get channel map from the pure gains
306  for (i = 0; i < pan->nb_output_channels; i++) {
307  int ch_id = -1;
308  for (j = 0; j < link->ch_layout.nb_channels; j++) {
309  if (pan->gain[i][j]) {
310  ch_id = j;
311  break;
312  }
313  }
314  pan->channel_map[i] = ch_id;
315  }
316 
317  av_opt_set_chlayout(pan->swr, "uchl", &pan->out_channel_layout, 0);
319  } else {
320  // renormalize
321  for (i = 0; i < pan->nb_output_channels; i++) {
322  if (!((pan->need_renorm >> i) & 1))
323  continue;
324  t = 0;
325  for (j = 0; j < link->ch_layout.nb_channels; j++)
326  t += fabs(pan->gain[i][j]);
327  if (t > -1E-5 && t < 1E-5) {
328  // t is almost 0 but not exactly, this is probably a mistake
329  if (t)
331  "Degenerate coefficients while renormalizing\n");
332  continue;
333  }
334  for (j = 0; j < link->ch_layout.nb_channels; j++)
335  pan->gain[i][j] /= t;
336  }
337  swr_set_matrix(pan->swr, pan->gain[0], pan->gain[1] - pan->gain[0]);
338  }
339 
340  r = swr_init(pan->swr);
341  if (r < 0)
342  return r;
343 
344  // summary
345  for (i = 0; i < pan->nb_output_channels; i++) {
346  cur = buf;
347  for (j = 0; j < link->ch_layout.nb_channels; j++) {
348  r = snprintf(cur, buf + sizeof(buf) - cur, "%s%.3g i%d",
349  j ? " + " : "", pan->gain[i][j], j);
350  cur += FFMIN(buf + sizeof(buf) - cur, r);
351  }
352  av_log(ctx, AV_LOG_VERBOSE, "o%d = %s\n", i, buf);
353  }
354  // add channel mapping summary if possible
355  if (pan->pure_gains) {
356  av_log(ctx, AV_LOG_INFO, "Pure channel mapping detected:");
357  for (i = 0; i < pan->nb_output_channels; i++)
358  if (pan->channel_map[i] < 0)
359  av_log(ctx, AV_LOG_INFO, " M");
360  else
361  av_log(ctx, AV_LOG_INFO, " %d", pan->channel_map[i]);
362  av_log(ctx, AV_LOG_INFO, "\n");
363  return 0;
364  }
365  return 0;
366 }
367 
368 static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
369 {
370  int ret;
371  int n = insamples->nb_samples;
372  AVFilterLink *const outlink = inlink->dst->outputs[0];
373  AVFrame *outsamples = ff_get_audio_buffer(outlink, n);
374  PanContext *pan = inlink->dst->priv;
375 
376  if (!outsamples) {
377  av_frame_free(&insamples);
378  return AVERROR(ENOMEM);
379  }
380  swr_convert(pan->swr, outsamples->extended_data, n,
381  (void *)insamples->extended_data, n);
382  av_frame_copy_props(outsamples, insamples);
383  if ((ret = av_channel_layout_copy(&outsamples->ch_layout, &outlink->ch_layout)) < 0) {
384  av_frame_free(&outsamples);
385  av_frame_free(&insamples);
386  return ret;
387  }
388 
389  av_frame_free(&insamples);
390  return ff_filter_frame(outlink, outsamples);
391 }
392 
394 {
395  PanContext *pan = ctx->priv;
396  swr_free(&pan->swr);
398 }
399 
400 #define OFFSET(x) offsetof(PanContext, x)
401 
402 static const AVOption pan_options[] = {
404  { NULL }
405 };
406 
408 
409 static const AVFilterPad pan_inputs[] = {
410  {
411  .name = "default",
412  .type = AVMEDIA_TYPE_AUDIO,
413  .config_props = config_props,
414  .filter_frame = filter_frame,
415  },
416 };
417 
419  .name = "pan",
420  .description = NULL_IF_CONFIG_SMALL("Remix channels with coefficients (panning)."),
421  .priv_size = sizeof(PanContext),
422  .priv_class = &pan_class,
423  .init = init,
424  .uninit = uninit,
428 };
ff_get_audio_buffer
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:97
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
PanContext::out_channel_layout
AVChannelLayout out_channel_layout
Definition: af_pan.c:46
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AVFilterFormatsConfig::channel_layouts
AVFilterChannelLayouts * channel_layouts
Lists of supported channel layouts, only for audio.
Definition: avfilter.h:520
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1015
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:674
layouts
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:337
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
ff_all_channel_counts
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition.
Definition: formats.c:622
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
AVOption
AVOption.
Definition: opt.h:357
config_props
static int config_props(AVFilterLink *link)
Definition: af_pan.c:265
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:159
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
ff_set_common_all_samplerates
int ff_set_common_all_samplerates(AVFilterContext *ctx)
Equivalent to ff_set_common_samplerates(ctx, ff_all_samplerates())
Definition: formats.c:822
swr_set_channel_mapping
int swr_set_channel_mapping(struct SwrContext *s, const int *channel_map)
Set a customized input channel mapping.
Definition: swresample.c:33
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
swr_set_matrix
int swr_set_matrix(struct SwrContext *s, const double *matrix, int stride)
Set a customized remix matrix.
Definition: rematrix.c:65
ff_af_pan
const AVFilter ff_af_pan
Definition: af_pan.c:418
formats.h
fail
#define fail()
Definition: checkasm.h:182
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:775
ff_all_formats
AVFilterFormats * ff_all_formats(enum AVMediaType type)
Return a list of all formats supported by FFmpeg for the given media type.
Definition: formats.c:536
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
swr_convert
int attribute_align_arg swr_convert(struct SwrContext *s, uint8_t *const *out_arg, int out_count, const uint8_t *const *in_arg, int in_count)
Convert audio.
Definition: swresample.c:719
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:285
PanContext::pure_gains
int pure_gains
Definition: af_pan.c:52
PanContext::swr
struct SwrContext * swr
Definition: af_pan.c:55
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
ff_set_common_formats
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:868
swr_init
av_cold int swr_init(struct SwrContext *s)
Initialize context after user parameters have been set.
Definition: swresample.c:140
PanContext::args
char * args
Definition: af_pan.c:45
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
Definition: af_pan.c:368
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: af_pan.c:237
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:178
skip_spaces
static void skip_spaces(char **arg)
Definition: af_pan.c:58
ctx
AVFormatContext * ctx
Definition: movenc.c:49
SwrContext
The libswresample context.
Definition: swresample_internal.h:95
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:182
E
#define E
Definition: avdct.c:33
link
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a link
Definition: filter_design.txt:23
arg
const char * arg
Definition: jacosubdec.c:67
PanContext::need_renorm
int64_t need_renorm
Definition: af_pan.c:48
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:709
ff_audio_default_filterpad
const AVFilterPad ff_audio_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_AUDIO.
Definition: audio.c:33
pan_inputs
static const AVFilterPad pan_inputs[]
Definition: af_pan.c:409
are_gains_pure
static int are_gains_pure(const PanContext *pan)
Definition: af_pan.c:215
pan_options
static const AVOption pan_options[]
Definition: af_pan.c:402
ff_add_channel_layout
int ff_add_channel_layout(AVFilterChannelLayouts **l, const AVChannelLayout *channel_layout)
Definition: formats.c:522
PanContext::nb_output_channels
int nb_output_channels
Definition: af_pan.c:50
swresample.h
OFFSET
#define OFFSET(x)
Definition: af_pan.c:400
AV_OPT_FLAG_FILTERING_PARAM
#define AV_OPT_FLAG_FILTERING_PARAM
A generic parameter which can be set by the user for filtering.
Definition: opt.h:309
swr_alloc_set_opts2
int swr_alloc_set_opts2(struct SwrContext **ps, const AVChannelLayout *out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate, const AVChannelLayout *in_ch_layout, enum AVSampleFormat in_sample_fmt, int in_sample_rate, int log_offset, void *log_ctx)
Allocate SwrContext if needed and set/reset common parameters.
Definition: swresample.c:40
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:303
ff_parse_channel_layout
int ff_parse_channel_layout(AVChannelLayout *ret, int *nret, const char *arg, void *log_ctx)
Parse a channel layout or a corresponding integer representation.
Definition: formats.c:967
av_opt_set_chlayout
int av_opt_set_chlayout(void *obj, const char *name, const AVChannelLayout *channel_layout, int search_flags)
Definition: opt.c:941
AVFrame::sample_rate
int sample_rate
Sample rate of the audio data.
Definition: frame.h:573
PanContext::need_renumber
int need_renumber
Definition: af_pan.c:49
swr_free
av_cold void swr_free(SwrContext **ss)
Free the given SwrContext and set the pointer to NULL.
Definition: swresample.c:121
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:461
PanContext::channel_map
int channel_map[MAX_CHANNELS]
Definition: af_pan.c:54
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
internal.h
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:454
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:435
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
len
int len
Definition: vorbis_enc_data.h:426
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
AVFilter
Filter definition.
Definition: avfilter.h:166
ret
ret
Definition: filter_design.txt:187
av_channel_from_string
enum AVChannel av_channel_from_string(const char *str)
This is the inverse function of av_channel_name().
Definition: channel_layout.c:146
channel_layout.h
av_channel_layout_index_from_channel
int av_channel_layout_index_from_channel(const AVChannelLayout *channel_layout, enum AVChannel channel)
Get the index of a given channel in a channel layout.
Definition: channel_layout.c:705
avfilter.h
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:433
init
static av_cold int init(AVFilterContext *ctx)
Definition: af_pan.c:94
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:440
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
MAX_CHANNELS
#define MAX_CHANNELS
Definition: af_pan.c:41
mem.h
audio.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
PanContext
Definition: af_pan.c:43
parse_channel_name
static int parse_channel_name(char **arg, int *rchannel, int *rnamed)
Definition: af_pan.c:66
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
PanContext::gain
double gain[MAX_CHANNELS][MAX_CHANNELS]
Definition: af_pan.c:47
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(pan)
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_pan.c:393
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:249
snprintf
#define snprintf
Definition: snprintf.h:34