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 {
41  uint64_t in_channel;
42  uint64_t out_channel;
45 };
46 
55 };
56 
57 #define MAX_CH 64
58 typedef struct ChannelMapContext {
59  const AVClass *class;
60  char *mapping_str;
62  uint64_t output_layout;
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, uint64_t *ch, char delim)
109 {
110  char *next = split(*map, delim);
111  if (!next && delim == '-')
112  return AVERROR(EINVAL);
113  *ch = av_get_channel_layout(*map);
114  if (av_get_channel_layout_nb_channels(*ch) != 1)
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  uint64_t 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  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 |= 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  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 |= out_ch;
228  break;
229  }
230  }
231  s->mode = mode;
232  s->nch = map_entries;
233  s->output_layout = out_ch_mask ? out_ch_mask :
234  av_get_default_channel_layout(map_entries);
235 
236  if (s->channel_layout_str) {
237  uint64_t fmt;
238  if ((fmt = av_get_channel_layout(s->channel_layout_str)) == 0) {
239  av_log(ctx, AV_LOG_ERROR, "Error parsing channel layout: '%s'.\n",
240  s->channel_layout_str);
241  return AVERROR(EINVAL);
242  }
243  if (mode == MAP_NONE) {
244  int i;
246  for (i = 0; i < s->nch; i++) {
247  s->map[i].in_channel_idx = i;
248  s->map[i].out_channel_idx = i;
249  }
250  } else if (out_ch_mask && out_ch_mask != fmt) {
251  av_get_channel_layout_string(buf, sizeof(buf), 0, out_ch_mask);
253  "Output channel layout '%s' does not match the list of channel mapped: '%s'.\n",
254  s->channel_layout_str, buf);
255  return AVERROR(EINVAL);
256  } else if (s->nch != av_get_channel_layout_nb_channels(fmt)) {
258  "Output channel layout %s does not match the number of channels mapped %d.\n",
259  s->channel_layout_str, s->nch);
260  return AVERROR(EINVAL);
261  }
262  s->output_layout = fmt;
263  }
264  if (!s->output_layout) {
265  av_log(ctx, AV_LOG_ERROR, "Output channel layout is not set and "
266  "cannot be guessed from the maps.\n");
267  return AVERROR(EINVAL);
268  }
269 
271  for (i = 0; i < s->nch; i++) {
272  s->map[i].out_channel_idx = av_get_channel_layout_channel_index(
273  s->output_layout, s->map[i].out_channel);
274  }
275  }
276 
277  return 0;
278 }
279 
281 {
282  ChannelMapContext *s = ctx->priv;
284  int ret;
285 
288  (ret = ff_add_channel_layout(&channel_layouts, s->output_layout)) < 0 ||
290  &ctx->outputs[0]->incfg.channel_layouts)) < 0)
291  return ret;
292 
294  &ctx->inputs[0]->outcfg.channel_layouts);
295 }
296 
298 {
299  AVFilterContext *ctx = inlink->dst;
300  AVFilterLink *outlink = ctx->outputs[0];
301  const ChannelMapContext *s = ctx->priv;
302  const int nch_in = inlink->channels;
303  const int nch_out = s->nch;
304  int ch;
305  uint8_t *source_planes[MAX_CH];
306 
307  memcpy(source_planes, buf->extended_data,
308  nch_in * sizeof(source_planes[0]));
309 
310  if (nch_out > nch_in) {
311  if (nch_out > FF_ARRAY_ELEMS(buf->data)) {
312  uint8_t **new_extended_data =
313  av_mallocz_array(nch_out, sizeof(*buf->extended_data));
314  if (!new_extended_data) {
315  av_frame_free(&buf);
316  return AVERROR(ENOMEM);
317  }
318  if (buf->extended_data == buf->data) {
319  buf->extended_data = new_extended_data;
320  } else {
321  av_free(buf->extended_data);
322  buf->extended_data = new_extended_data;
323  }
324  } else if (buf->extended_data != buf->data) {
325  av_free(buf->extended_data);
326  buf->extended_data = buf->data;
327  }
328  }
329 
330  for (ch = 0; ch < nch_out; ch++) {
331  buf->extended_data[s->map[ch].out_channel_idx] =
332  source_planes[s->map[ch].in_channel_idx];
333  }
334 
335  if (buf->data != buf->extended_data)
336  memcpy(buf->data, buf->extended_data,
337  FFMIN(FF_ARRAY_ELEMS(buf->data), nch_out) * sizeof(buf->data[0]));
338 
339  buf->channel_layout = outlink->channel_layout;
340  buf->channels = outlink->channels;
341 
342  return ff_filter_frame(outlink, buf);
343 }
344 
346 {
347  AVFilterContext *ctx = inlink->dst;
348  ChannelMapContext *s = ctx->priv;
349  int nb_channels = inlink->channels;
350  int i, err = 0;
351  const char *channel_name;
352  char layout_name[256];
353 
354  for (i = 0; i < s->nch; i++) {
355  struct ChannelMap *m = &s->map[i];
356 
357  if (s->mode == MAP_PAIR_STR_INT || s->mode == MAP_PAIR_STR_STR) {
359  inlink->channel_layout, m->in_channel);
360  }
361 
362  if (m->in_channel_idx < 0 || m->in_channel_idx >= nb_channels) {
363  av_get_channel_layout_string(layout_name, sizeof(layout_name),
364  nb_channels, inlink->channel_layout);
365  if (m->in_channel) {
368  "input channel '%s' not available from input layout '%s'\n",
369  channel_name, layout_name);
370  } else {
372  "input channel #%d not available from input layout '%s'\n",
373  m->in_channel_idx, layout_name);
374  }
375  err = AVERROR(EINVAL);
376  }
377  }
378 
379  return err;
380 }
381 
383  {
384  .name = "default",
385  .type = AVMEDIA_TYPE_AUDIO,
386  .filter_frame = channelmap_filter_frame,
387  .config_props = channelmap_config_input,
388  .needs_writable = 1,
389  },
390  { NULL }
391 };
392 
394  {
395  .name = "default",
396  .type = AVMEDIA_TYPE_AUDIO
397  },
398  { NULL }
399 };
400 
402  .name = "channelmap",
403  .description = NULL_IF_CONFIG_SMALL("Remap audio channels."),
404  .init = channelmap_init,
405  .query_formats = channelmap_query_formats,
406  .priv_size = sizeof(ChannelMapContext),
407  .priv_class = &channelmap_class,
410 };
ChannelMap::in_channel
uint64_t in_channel
layout describing the input channel
Definition: af_channelmap.c:41
MAX_CH
#define MAX_CH
Definition: af_channelmap.c:57
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:86
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:1094
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:461
channelmap_filter_frame
static int channelmap_filter_frame(AVFilterLink *inlink, AVFrame *buf)
Definition: af_channelmap.c:297
F
#define F
Definition: af_channelmap.c:70
channelmap_init
static av_cold int channelmap_init(AVFilterContext *ctx)
Definition: af_channelmap.c:120
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:204
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:436
av_get_channel_layout_string
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.
Definition: channel_layout.c:217
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:324
AVOption
AVOption.
Definition: opt.h:248
avfilter_af_channelmap_outputs
static const AVFilterPad avfilter_af_channelmap_outputs[]
Definition: af_channelmap.c:393
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
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:145
mathematics.h
channel_name
Definition: channel_layout.c:34
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:149
MAP_NONE
@ MAP_NONE
Definition: af_channelmap.c:48
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:338
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
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
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:194
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
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:587
ff_af_channelmap
AVFilter ff_af_channelmap
Definition: af_channelmap.c:401
ff_add_channel_layout
int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
Definition: formats.c:338
channelmap_options
static const AVOption channelmap_options[]
Definition: af_channelmap.c:71
s
#define s(width, name)
Definition: cbs_vp9.c:257
MAP_PAIR_STR_INT
@ MAP_PAIR_STR_INT
Definition: af_channelmap.c:53
AVFrame::channels
int channels
number of audio channels, only used for audio.
Definition: frame.h:630
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ChannelMapContext::nch
int nch
Definition: af_channelmap.c:64
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
av_get_channel_name
const char * av_get_channel_name(uint64_t channel)
Get the name of a given channel.
Definition: channel_layout.c:249
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
ChannelMapContext::output_layout
uint64_t output_layout
Definition: af_channelmap.c:62
channelmap_query_formats
static int channelmap_query_formats(AVFilterContext *ctx)
Definition: af_channelmap.c:280
av_get_channel_layout_nb_channels
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
Definition: channel_layout.c:226
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:117
ChannelMap::out_channel
uint64_t out_channel
layout describing the output channel
Definition: af_channelmap.c:42
ChannelMapContext
Definition: af_channelmap.c:58
avfilter_af_channelmap_inputs
static const AVFilterPad avfilter_af_channelmap_inputs[]
Definition: af_channelmap.c:382
MAP_ONE_STR
@ MAP_ONE_STR
Definition: af_channelmap.c:50
MAP_ONE_INT
@ MAP_ONE_INT
Definition: af_channelmap.c:49
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:345
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
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
AVFrame::channel_layout
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:501
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
i
int i
Definition: input.c:407
get_channel
static int get_channel(char **map, uint64_t *ch, char delim)
Definition: af_channelmap.c:108
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:371
common.h
av_get_channel_layout_channel_index
int av_get_channel_layout_channel_index(uint64_t channel_layout, uint64_t channel)
Get the index of a channel in channel_layout.
Definition: channel_layout.c:239
uint8_t
uint8_t
Definition: audio_convert.c:194
ff_planar_sample_fmts
AVFilterFormats * ff_planar_sample_fmts(void)
Construct a formats list containing all planar sample formats.
Definition: formats.c:408
len
int len
Definition: vorbis_enc_data.h:452
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
AVFilter
Filter definition.
Definition: avfilter.h:145
ret
ret
Definition: filter_design.txt:187
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:421
ChannelMap::out_channel_idx
int out_channel_idx
Definition: af_channelmap.c:44
channel_layout.h
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(channelmap)
mode
mode
Definition: ebur128.h:83
avfilter.h
ChannelMap
Definition: opus.h:147
AVFilterContext
An instance of a filter.
Definition: avfilter.h:341
OFFSET
#define OFFSET(x)
Definition: af_channelmap.c:68
audio.h
av_get_default_channel_layout
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
Definition: channel_layout.c:231
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
channel_layouts
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:114
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_set_common_samplerates
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:575
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
nb_channels
int nb_channels
Definition: channel_layout.c:81