FFmpeg
af_channelmap.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012 Google, Inc.
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * audio channel mapping filter
24  */
25 
26 #include <ctype.h>
27 
28 #include "libavutil/avstring.h"
30 #include "libavutil/common.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/samplefmt.h"
34 
35 #include "audio.h"
36 #include "avfilter.h"
37 #include "formats.h"
38 #include "internal.h"
39 
40 struct ChannelMap {
45 };
46 
55 };
56 
57 #define MAX_CH 64
58 typedef struct ChannelMapContext {
59  const AVClass *class;
60  char *mapping_str;
64  int nch;
67 
68 #define OFFSET(x) offsetof(ChannelMapContext, x)
69 #define A AV_OPT_FLAG_AUDIO_PARAM
70 #define F AV_OPT_FLAG_FILTERING_PARAM
71 static const AVOption channelmap_options[] = {
72  { "map", "A comma-separated list of input channel numbers in output order.",
73  OFFSET(mapping_str), AV_OPT_TYPE_STRING, .flags = A|F },
74  { "channel_layout", "Output channel layout.",
75  OFFSET(channel_layout_str), AV_OPT_TYPE_STRING, .flags = A|F },
76  { NULL }
77 };
78 
79 AVFILTER_DEFINE_CLASS(channelmap);
80 
81 static char* split(char *message, char delim) {
82  char *next = strchr(message, delim);
83  if (next)
84  *next++ = '\0';
85  return next;
86 }
87 
88 static int get_channel_idx(char **map, int *ch, char delim, int max_ch)
89 {
90  char *next;
91  int len;
92  int n = 0;
93  if (!*map)
94  return AVERROR(EINVAL);
95  next = split(*map, delim);
96  if (!next && delim == '-')
97  return AVERROR(EINVAL);
98  len = strlen(*map);
99  sscanf(*map, "%d%n", ch, &n);
100  if (n != len)
101  return AVERROR(EINVAL);
102  if (*ch < 0 || *ch > max_ch)
103  return AVERROR(EINVAL);
104  *map = next;
105  return 0;
106 }
107 
108 static int get_channel(char **map, int *ch, char delim)
109 {
110  char *next = split(*map, delim);
111  if (!next && delim == '-')
112  return AVERROR(EINVAL);
113  *ch = av_channel_from_string(*map);
114  if (*ch < 0)
115  return AVERROR(EINVAL);
116  *map = next;
117  return 0;
118 }
119 
121 {
122  ChannelMapContext *s = ctx->priv;
123  char *mapping, separator = '|';
124  int map_entries = 0;
125  char buf[256];
126  enum MappingMode mode;
127  uint64_t out_ch_mask = 0;
128  int i;
129 
130  mapping = s->mapping_str;
131 
132  if (!mapping) {
133  mode = MAP_NONE;
134  } else {
135  char *dash = strchr(mapping, '-');
136  if (!dash) { // short mapping
137  if (av_isdigit(*mapping))
138  mode = MAP_ONE_INT;
139  else
140  mode = MAP_ONE_STR;
141  } else if (av_isdigit(*mapping)) {
142  if (av_isdigit(*(dash+1)))
144  else
146  } else {
147  if (av_isdigit(*(dash+1)))
149  else
151  }
152  }
153 
154  if (mode != MAP_NONE) {
155  char *sep = mapping;
156  map_entries = 1;
157  while ((sep = strchr(sep, separator))) {
158  if (*++sep) // Allow trailing comma
159  map_entries++;
160  }
161  }
162 
163  if (map_entries > MAX_CH) {
164  av_log(ctx, AV_LOG_ERROR, "Too many channels mapped: '%d'.\n", map_entries);
165  return AVERROR(EINVAL);
166  }
167 
168  for (i = 0; i < map_entries; i++) {
169  int in_ch_idx = -1, out_ch_idx = -1;
170  int in_ch = 0, out_ch = 0;
171  static const char err[] = "Failed to parse channel map\n";
172  switch (mode) {
173  case MAP_ONE_INT:
174  if (get_channel_idx(&mapping, &in_ch_idx, separator, MAX_CH) < 0) {
175  av_log(ctx, AV_LOG_ERROR, err);
176  return AVERROR(EINVAL);
177  }
178  s->map[i].in_channel_idx = in_ch_idx;
179  s->map[i].out_channel_idx = i;
180  break;
181  case MAP_ONE_STR:
182  if (get_channel(&mapping, &in_ch, separator) < 0) {
183  av_log(ctx, AV_LOG_ERROR, err);
184  return AVERROR(EINVAL);
185  }
186  s->map[i].in_channel = in_ch;
187  s->map[i].out_channel_idx = i;
188  break;
189  case MAP_PAIR_INT_INT:
190  if (get_channel_idx(&mapping, &in_ch_idx, '-', MAX_CH) < 0 ||
191  get_channel_idx(&mapping, &out_ch_idx, separator, MAX_CH) < 0) {
192  av_log(ctx, AV_LOG_ERROR, err);
193  return AVERROR(EINVAL);
194  }
195  s->map[i].in_channel_idx = in_ch_idx;
196  s->map[i].out_channel_idx = out_ch_idx;
197  break;
198  case MAP_PAIR_INT_STR:
199  if (get_channel_idx(&mapping, &in_ch_idx, '-', MAX_CH) < 0 ||
200  get_channel(&mapping, &out_ch, separator) < 0 ||
201  (1ULL << out_ch) & out_ch_mask) {
202  av_log(ctx, AV_LOG_ERROR, err);
203  return AVERROR(EINVAL);
204  }
205  s->map[i].in_channel_idx = in_ch_idx;
206  s->map[i].out_channel = out_ch;
207  out_ch_mask |= 1ULL << out_ch;
208  break;
209  case MAP_PAIR_STR_INT:
210  if (get_channel(&mapping, &in_ch, '-') < 0 ||
211  get_channel_idx(&mapping, &out_ch_idx, separator, MAX_CH) < 0) {
212  av_log(ctx, AV_LOG_ERROR, err);
213  return AVERROR(EINVAL);
214  }
215  s->map[i].in_channel = in_ch;
216  s->map[i].out_channel_idx = out_ch_idx;
217  break;
218  case MAP_PAIR_STR_STR:
219  if (get_channel(&mapping, &in_ch, '-') < 0 ||
220  get_channel(&mapping, &out_ch, separator) < 0 ||
221  (1ULL << out_ch) & out_ch_mask) {
222  av_log(ctx, AV_LOG_ERROR, err);
223  return AVERROR(EINVAL);
224  }
225  s->map[i].in_channel = in_ch;
226  s->map[i].out_channel = out_ch;
227  out_ch_mask |= 1ULL << out_ch;
228  break;
229  }
230  }
231  s->mode = mode;
232  s->nch = map_entries;
233  if (out_ch_mask)
234  av_channel_layout_from_mask(&s->output_layout, out_ch_mask);
235  else
236  av_channel_layout_default(&s->output_layout, map_entries);
237 
238  if (s->channel_layout_str) {
239  AVChannelLayout fmt = { 0 };
240  int ret;
241  if ((ret = av_channel_layout_from_string(&fmt, s->channel_layout_str)) < 0) {
242 #if FF_API_OLD_CHANNEL_LAYOUT
243  uint64_t mask;
245  if ((mask = av_get_channel_layout(s->channel_layout_str)) == 0) {
246 #endif
247  av_log(ctx, AV_LOG_ERROR, "Error parsing channel layout: '%s'.\n",
248  s->channel_layout_str);
249  return AVERROR(EINVAL);
250 #if FF_API_OLD_CHANNEL_LAYOUT
251  }
253  av_log(ctx, AV_LOG_WARNING, "Channel layout '%s' uses a deprecated syntax.\n",
254  s->channel_layout_str);
256 #endif
257  }
258  if (mode == MAP_NONE) {
259  int i;
260  s->nch = fmt.nb_channels;
261  for (i = 0; i < s->nch; i++) {
262  s->map[i].in_channel_idx = i;
263  s->map[i].out_channel_idx = i;
264  }
265  } else if (out_ch_mask && av_channel_layout_compare(&s->output_layout, &fmt)) {
266  av_channel_layout_describe(&s->output_layout, buf, sizeof(buf));
268  "Output channel layout '%s' does not match the list of channel mapped: '%s'.\n",
269  s->channel_layout_str, buf);
270  return AVERROR(EINVAL);
271  } else if (s->nch != fmt.nb_channels) {
273  "Output channel layout %s does not match the number of channels mapped %d.\n",
274  s->channel_layout_str, s->nch);
275  return AVERROR(EINVAL);
276  }
277  s->output_layout = fmt;
278  }
279  if (!s->output_layout.nb_channels) {
280  av_log(ctx, AV_LOG_ERROR, "Output channel layout is not set and "
281  "cannot be guessed from the maps.\n");
282  return AVERROR(EINVAL);
283  }
284 
286  for (i = 0; i < s->nch; i++) {
287  s->map[i].out_channel_idx = av_channel_layout_index_from_channel(
288  &s->output_layout, s->map[i].out_channel);
289  }
290  }
291 
292  return 0;
293 }
294 
296 {
297  ChannelMapContext *s = ctx->priv;
299  int ret;
300 
303  (ret = ff_add_channel_layout(&channel_layouts, &s->output_layout)) < 0 ||
305  &ctx->outputs[0]->incfg.channel_layouts)) < 0)
306  return ret;
307 
309  &ctx->inputs[0]->outcfg.channel_layouts);
310 }
311 
313 {
314  AVFilterContext *ctx = inlink->dst;
315  AVFilterLink *outlink = ctx->outputs[0];
316  const ChannelMapContext *s = ctx->priv;
317  const int nch_in = inlink->ch_layout.nb_channels;
318  const int nch_out = s->nch;
319  int ch, ret;
320  uint8_t *source_planes[MAX_CH];
321 
322  memcpy(source_planes, buf->extended_data,
323  nch_in * sizeof(source_planes[0]));
324 
325  if (nch_out > nch_in) {
326  if (nch_out > FF_ARRAY_ELEMS(buf->data)) {
327  uint8_t **new_extended_data =
328  av_calloc(nch_out, sizeof(*buf->extended_data));
329  if (!new_extended_data) {
330  av_frame_free(&buf);
331  return AVERROR(ENOMEM);
332  }
333  if (buf->extended_data == buf->data) {
334  buf->extended_data = new_extended_data;
335  } else {
336  av_free(buf->extended_data);
337  buf->extended_data = new_extended_data;
338  }
339  } else if (buf->extended_data != buf->data) {
340  av_free(buf->extended_data);
341  buf->extended_data = buf->data;
342  }
343  }
344 
345  for (ch = 0; ch < nch_out; ch++) {
346  buf->extended_data[s->map[ch].out_channel_idx] =
347  source_planes[s->map[ch].in_channel_idx];
348  }
349 
350  if (buf->data != buf->extended_data)
351  memcpy(buf->data, buf->extended_data,
352  FFMIN(FF_ARRAY_ELEMS(buf->data), nch_out) * sizeof(buf->data[0]));
353 
354 #if FF_API_OLD_CHANNEL_LAYOUT
356  buf->channels = outlink->ch_layout.nb_channels;
357  buf->channel_layout = outlink->channel_layout;
359 #endif
360  if ((ret = av_channel_layout_copy(&buf->ch_layout, &outlink->ch_layout)) < 0)
361  return ret;
362 
363  return ff_filter_frame(outlink, buf);
364 }
365 
367 {
368  AVFilterContext *ctx = inlink->dst;
369  ChannelMapContext *s = ctx->priv;
370  int nb_channels = inlink->ch_layout.nb_channels;
371  int i, err = 0;
372  char channel_name[64];
373  char layout_name[256];
374 
375  for (i = 0; i < s->nch; i++) {
376  struct ChannelMap *m = &s->map[i];
377 
378  if (s->mode == MAP_PAIR_STR_INT || s->mode == MAP_PAIR_STR_STR) {
380  &inlink->ch_layout, m->in_channel);
381  }
382 
383  if (m->in_channel_idx < 0 || m->in_channel_idx >= nb_channels) {
384  av_channel_layout_describe(&inlink->ch_layout, layout_name, sizeof(layout_name));
385  if (m->in_channel) {
388  "input channel '%s' not available from input layout '%s'\n",
389  channel_name, layout_name);
390  } else {
392  "input channel #%d not available from input layout '%s'\n",
393  m->in_channel_idx, layout_name);
394  }
395  err = AVERROR(EINVAL);
396  }
397  }
398 
399  return err;
400 }
401 
403  {
404  .name = "default",
405  .type = AVMEDIA_TYPE_AUDIO,
407  .filter_frame = channelmap_filter_frame,
408  .config_props = channelmap_config_input,
409  },
410 };
411 
413  {
414  .name = "default",
415  .type = AVMEDIA_TYPE_AUDIO
416  },
417 };
418 
420  .name = "channelmap",
421  .description = NULL_IF_CONFIG_SMALL("Remap audio channels."),
422  .init = channelmap_init,
423  .priv_size = sizeof(ChannelMapContext),
424  .priv_class = &channelmap_class,
428 };
MAX_CH
#define MAX_CH
Definition: af_channelmap.c:57
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
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
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
MAP_PAIR_STR_STR
@ MAP_PAIR_STR_STR
Definition: af_channelmap.c:54
message
Definition: api-threadmessage-test.c:46
ChannelMapContext::mode
enum MappingMode mode
Definition: af_channelmap.c:65
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:999
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:591
channelmap_filter_frame
static int channelmap_filter_frame(AVFilterLink *inlink, AVFrame *buf)
Definition: af_channelmap.c:312
F
#define F
Definition: af_channelmap.c:70
channelmap_init
static av_cold int channelmap_init(AVFilterContext *ctx)
Definition: af_channelmap.c:120
av_get_channel_layout
uint64_t av_get_channel_layout(const char *name)
Return a channel layout id that matches name, or 0 if no match is found.
Definition: channel_layout.c:237
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:111
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:566
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
AVOption
AVOption.
Definition: opt.h:251
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:167
avfilter_af_channelmap_outputs
static const AVFilterPad avfilter_af_channelmap_outputs[]
Definition: af_channelmap.c:412
get_channel
static int get_channel(char **map, int *ch, char delim)
Definition: af_channelmap.c:108
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:739
mathematics.h
channel_name
Definition: channel_layout.c:41
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:175
MAP_NONE
@ MAP_NONE
Definition: af_channelmap.c:48
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
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:637
formats.h
A
#define A
Definition: af_channelmap.c:69
samplefmt.h
ChannelMapContext::channel_layout_str
char * channel_layout_str
Definition: af_channelmap.c:61
ff_af_channelmap
const AVFilter ff_af_channelmap
Definition: af_channelmap.c:419
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:704
AVFrame::channels
attribute_deprecated int channels
number of audio channels, only used for audio.
Definition: frame.h:643
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:49
MappingMode
MappingMode
Definition: af_channelmap.c:47
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AVFrame::channel_layout
attribute_deprecated uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:510
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:749
mask
static const uint16_t mask[17]
Definition: lzw.c:38
channelmap_options
static const AVOption channelmap_options[]
Definition: af_channelmap.c:71
s
#define s(width, name)
Definition: cbs_vp9.c:256
MAP_PAIR_STR_INT
@ MAP_PAIR_STR_INT
Definition: af_channelmap.c:53
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ChannelMapContext::nch
int nch
Definition: af_channelmap.c:64
ctx
AVFormatContext * ctx
Definition: movenc.c:48
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:190
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
ChannelMapContext::output_layout
AVChannelLayout output_layout
Definition: af_channelmap.c:62
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:930
av_channel_layout_default
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
Get the default channel layout for a given number of channels.
Definition: channel_layout.c:960
ChannelMap::in_channel
int in_channel
Definition: af_channelmap.c:41
ff_add_channel_layout
int ff_add_channel_layout(AVFilterChannelLayouts **l, const AVChannelLayout *channel_layout)
Definition: formats.c:466
channelmap_query_formats
static int channelmap_query_formats(AVFilterContext *ctx)
Definition: af_channelmap.c:295
MAP_PAIR_INT_INT
@ MAP_PAIR_INT_INT
Definition: af_channelmap.c:51
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:116
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:290
ChannelMapContext
Definition: af_channelmap.c:58
avfilter_af_channelmap_inputs
static const AVFilterPad avfilter_af_channelmap_inputs[]
Definition: af_channelmap.c:402
MAP_ONE_STR
@ MAP_ONE_STR
Definition: af_channelmap.c:50
MAP_ONE_INT
@ MAP_ONE_INT
Definition: af_channelmap.c:49
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:141
MAP_PAIR_INT_STR
@ MAP_PAIR_INT_STR
Definition: af_channelmap.c:52
channelmap_config_input
static int channelmap_config_input(AVFilterLink *inlink)
Definition: af_channelmap.c:366
split
static char * split(char *message, char delim)
Definition: af_channelmap.c:81
av_isdigit
static av_const int av_isdigit(int c)
Locale-independent conversion of ASCII isdigit.
Definition: avstring.h:211
get_channel_idx
static int get_channel_idx(char **map, int *ch, char delim, int max_ch)
Definition: af_channelmap.c:88
ChannelMap::in_channel_idx
int in_channel_idx
index of in_channel in the input stream data
Definition: af_channelmap.c:43
ChannelMapContext::mapping_str
char * mapping_str
Definition: af_channelmap.c:60
ChannelMapContext::map
struct ChannelMap map[MAX_CH]
Definition: af_channelmap.c:63
internal.h
av_channel_name
int av_channel_name(char *buf, size_t buf_size, enum AVChannel channel_id)
Get a human readable string in an abbreviated form describing a given channel.
Definition: channel_layout.c:101
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:386
common.h
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ff_planar_sample_fmts
AVFilterFormats * ff_planar_sample_fmts(void)
Construct a formats list containing all planar sample formats.
Definition: formats.c:538
len
int len
Definition: vorbis_enc_data.h:426
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:55
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:834
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
ChannelMap::out_channel
int out_channel
Definition: af_channelmap.c:42
AVFilter
Filter definition.
Definition: avfilter.h:171
av_channel_layout_from_mask
FF_ENABLE_DEPRECATION_WARNINGS int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
Definition: channel_layout.c:389
ret
ret
Definition: filter_design.txt:187
ChannelMap::out_channel_idx
int out_channel_idx
Definition: af_channelmap.c:44
channel_layout.h
av_channel_layout_from_string
int av_channel_layout_from_string(AVChannelLayout *channel_layout, const char *str)
Initialize a channel layout from a given string description.
Definition: channel_layout.c:402
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(channelmap)
mode
mode
Definition: ebur128.h:83
avfilter.h
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:776
ChannelMap
Definition: opus.h:147
AVFilterContext
An instance of a filter.
Definition: avfilter.h:408
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
OFFSET
#define OFFSET(x)
Definition: af_channelmap.c:68
audio.h
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
channel_layouts
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:111
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:191
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
AVFILTERPAD_FLAG_NEEDS_WRITABLE
#define AVFILTERPAD_FLAG_NEEDS_WRITABLE
The filter expects writable frames from its input link, duplicating data buffers if needed.
Definition: internal.h:68