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" |
29 |
|
|
#include "libavutil/channel_layout.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; |
43 |
|
|
int in_channel_idx; |
44 |
|
|
int out_channel_idx; |
45 |
|
|
}; |
46 |
|
|
|
47 |
|
|
enum MappingMode { |
48 |
|
|
MAP_NONE, |
49 |
|
|
MAP_ONE_INT, |
50 |
|
|
MAP_ONE_STR, |
51 |
|
|
MAP_PAIR_INT_INT, |
52 |
|
|
MAP_PAIR_INT_STR, |
53 |
|
|
MAP_PAIR_STR_INT, |
54 |
|
|
MAP_PAIR_STR_STR |
55 |
|
|
}; |
56 |
|
|
|
57 |
|
|
#define MAX_CH 64 |
58 |
|
|
typedef struct ChannelMapContext { |
59 |
|
|
const AVClass *class; |
60 |
|
|
char *mapping_str; |
61 |
|
|
char *channel_layout_str; |
62 |
|
|
uint64_t output_layout; |
63 |
|
|
struct ChannelMap map[MAX_CH]; |
64 |
|
|
int nch; |
65 |
|
|
enum MappingMode mode; |
66 |
|
|
} ChannelMapContext; |
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 |
|
16 |
static char* split(char *message, char delim) { |
82 |
|
16 |
char *next = strchr(message, delim); |
83 |
✓✓ |
16 |
if (next) |
84 |
|
12 |
*next++ = '\0'; |
85 |
|
16 |
return next; |
86 |
|
|
} |
87 |
|
|
|
88 |
|
12 |
static int get_channel_idx(char **map, int *ch, char delim, int max_ch) |
89 |
|
|
{ |
90 |
|
|
char *next; |
91 |
|
|
int len; |
92 |
|
12 |
int n = 0; |
93 |
✗✓ |
12 |
if (!*map) |
94 |
|
|
return AVERROR(EINVAL); |
95 |
|
12 |
next = split(*map, delim); |
96 |
✓✓✗✓
|
12 |
if (!next && delim == '-') |
97 |
|
|
return AVERROR(EINVAL); |
98 |
|
12 |
len = strlen(*map); |
99 |
|
12 |
sscanf(*map, "%d%n", ch, &n); |
100 |
✗✓ |
12 |
if (n != len) |
101 |
|
|
return AVERROR(EINVAL); |
102 |
✓✗✗✓
|
12 |
if (*ch < 0 || *ch > max_ch) |
103 |
|
|
return AVERROR(EINVAL); |
104 |
|
12 |
*map = next; |
105 |
|
12 |
return 0; |
106 |
|
|
} |
107 |
|
|
|
108 |
|
4 |
static int get_channel(char **map, uint64_t *ch, char delim) |
109 |
|
|
{ |
110 |
|
4 |
char *next = split(*map, delim); |
111 |
✓✓✗✓
|
4 |
if (!next && delim == '-') |
112 |
|
|
return AVERROR(EINVAL); |
113 |
|
4 |
*ch = av_get_channel_layout(*map); |
114 |
✗✓ |
4 |
if (av_get_channel_layout_nb_channels(*ch) != 1) |
115 |
|
|
return AVERROR(EINVAL); |
116 |
|
4 |
*map = next; |
117 |
|
4 |
return 0; |
118 |
|
|
} |
119 |
|
|
|
120 |
|
4 |
static av_cold int channelmap_init(AVFilterContext *ctx) |
121 |
|
|
{ |
122 |
|
4 |
ChannelMapContext *s = ctx->priv; |
123 |
|
4 |
char *mapping, separator = '|'; |
124 |
|
4 |
int map_entries = 0; |
125 |
|
|
char buf[256]; |
126 |
|
|
enum MappingMode mode; |
127 |
|
4 |
uint64_t out_ch_mask = 0; |
128 |
|
|
int i; |
129 |
|
|
|
130 |
|
4 |
mapping = s->mapping_str; |
131 |
|
|
|
132 |
✗✓ |
4 |
if (!mapping) { |
133 |
|
|
mode = MAP_NONE; |
134 |
|
|
} else { |
135 |
|
4 |
char *dash = strchr(mapping, '-'); |
136 |
✓✗ |
4 |
if (!dash) { // short mapping |
137 |
✓✓ |
4 |
if (av_isdigit(*mapping)) |
138 |
|
2 |
mode = MAP_ONE_INT; |
139 |
|
|
else |
140 |
|
2 |
mode = MAP_ONE_STR; |
141 |
|
|
} else if (av_isdigit(*mapping)) { |
142 |
|
|
if (av_isdigit(*(dash+1))) |
143 |
|
|
mode = MAP_PAIR_INT_INT; |
144 |
|
|
else |
145 |
|
|
mode = MAP_PAIR_INT_STR; |
146 |
|
|
} else { |
147 |
|
|
if (av_isdigit(*(dash+1))) |
148 |
|
|
mode = MAP_PAIR_STR_INT; |
149 |
|
|
else |
150 |
|
|
mode = MAP_PAIR_STR_STR; |
151 |
|
|
} |
152 |
|
|
} |
153 |
|
|
|
154 |
✓✗ |
4 |
if (mode != MAP_NONE) { |
155 |
|
4 |
char *sep = mapping; |
156 |
|
4 |
map_entries = 1; |
157 |
✓✓ |
16 |
while ((sep = strchr(sep, separator))) { |
158 |
✓✗ |
12 |
if (*++sep) // Allow trailing comma |
159 |
|
12 |
map_entries++; |
160 |
|
|
} |
161 |
|
|
} |
162 |
|
|
|
163 |
✗✓ |
4 |
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 |
✓✓ |
20 |
for (i = 0; i < map_entries; i++) { |
169 |
|
16 |
int in_ch_idx = -1, out_ch_idx = -1; |
170 |
|
16 |
uint64_t in_ch = 0, out_ch = 0; |
171 |
|
|
static const char err[] = "Failed to parse channel map\n"; |
172 |
✓✓✗✗ ✗✗✗ |
16 |
switch (mode) { |
173 |
|
12 |
case MAP_ONE_INT: |
174 |
✗✓ |
12 |
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 |
|
12 |
s->map[i].in_channel_idx = in_ch_idx; |
179 |
|
12 |
s->map[i].out_channel_idx = i; |
180 |
|
12 |
break; |
181 |
|
4 |
case MAP_ONE_STR: |
182 |
✗✓ |
4 |
if (get_channel(&mapping, &in_ch, separator) < 0) { |
183 |
|
|
av_log(ctx, AV_LOG_ERROR, err); |
184 |
|
|
return AVERROR(EINVAL); |
185 |
|
|
} |
186 |
|
4 |
s->map[i].in_channel = in_ch; |
187 |
|
4 |
s->map[i].out_channel_idx = i; |
188 |
|
4 |
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 |
|
16 |
} |
231 |
|
4 |
s->mode = mode; |
232 |
|
4 |
s->nch = map_entries; |
233 |
✓✗ |
8 |
s->output_layout = out_ch_mask ? out_ch_mask : |
234 |
|
4 |
av_get_default_channel_layout(map_entries); |
235 |
|
|
|
236 |
✓✗ |
4 |
if (s->channel_layout_str) { |
237 |
|
|
uint64_t fmt; |
238 |
✗✓ |
4 |
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 |
✗✓ |
4 |
if (mode == MAP_NONE) { |
244 |
|
|
int i; |
245 |
|
|
s->nch = av_get_channel_layout_nb_channels(fmt); |
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 |
✗✓✗✗
|
4 |
} else if (out_ch_mask && out_ch_mask != fmt) { |
251 |
|
|
av_get_channel_layout_string(buf, sizeof(buf), 0, out_ch_mask); |
252 |
|
|
av_log(ctx, AV_LOG_ERROR, |
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 |
✗✓ |
4 |
} else if (s->nch != av_get_channel_layout_nb_channels(fmt)) { |
257 |
|
|
av_log(ctx, AV_LOG_ERROR, |
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 |
|
4 |
s->output_layout = fmt; |
263 |
|
|
} |
264 |
✗✓ |
4 |
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 |
|
|
|
270 |
✓✗✗✓
|
4 |
if (mode == MAP_PAIR_INT_STR || mode == MAP_PAIR_STR_STR) { |
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 |
|
4 |
return 0; |
278 |
|
|
} |
279 |
|
|
|
280 |
|
2 |
static int channelmap_query_formats(AVFilterContext *ctx) |
281 |
|
|
{ |
282 |
|
2 |
ChannelMapContext *s = ctx->priv; |
283 |
|
2 |
AVFilterChannelLayouts *channel_layouts = NULL; |
284 |
|
|
int ret; |
285 |
|
|
|
286 |
✓✗✓✗
|
4 |
if ((ret = ff_set_common_formats (ctx, ff_planar_sample_fmts())) < 0 || |
287 |
✓✗ |
4 |
(ret = ff_set_common_samplerates (ctx , ff_all_samplerates() )) < 0 || |
288 |
✗✓ |
4 |
(ret = ff_add_channel_layout(&channel_layouts, s->output_layout)) < 0 || |
289 |
|
2 |
(ret = ff_channel_layouts_ref(channel_layouts, |
290 |
|
2 |
&ctx->outputs[0]->incfg.channel_layouts)) < 0) |
291 |
|
|
return ret; |
292 |
|
|
|
293 |
|
2 |
return ff_channel_layouts_ref(ff_all_channel_counts(), |
294 |
|
2 |
&ctx->inputs[0]->outcfg.channel_layouts); |
295 |
|
|
} |
296 |
|
|
|
297 |
|
1035 |
static int channelmap_filter_frame(AVFilterLink *inlink, AVFrame *buf) |
298 |
|
|
{ |
299 |
|
1035 |
AVFilterContext *ctx = inlink->dst; |
300 |
|
1035 |
AVFilterLink *outlink = ctx->outputs[0]; |
301 |
|
1035 |
const ChannelMapContext *s = ctx->priv; |
302 |
|
1035 |
const int nch_in = inlink->channels; |
303 |
|
1035 |
const int nch_out = s->nch; |
304 |
|
|
int ch; |
305 |
|
|
uint8_t *source_planes[MAX_CH]; |
306 |
|
|
|
307 |
|
1035 |
memcpy(source_planes, buf->extended_data, |
308 |
|
|
nch_in * sizeof(source_planes[0])); |
309 |
|
|
|
310 |
✗✓ |
1035 |
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 |
✓✓ |
6209 |
for (ch = 0; ch < nch_out; ch++) { |
331 |
|
5174 |
buf->extended_data[s->map[ch].out_channel_idx] = |
332 |
|
5174 |
source_planes[s->map[ch].in_channel_idx]; |
333 |
|
|
} |
334 |
|
|
|
335 |
✗✓ |
1035 |
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 |
|
1035 |
buf->channel_layout = outlink->channel_layout; |
340 |
|
1035 |
buf->channels = outlink->channels; |
341 |
|
|
|
342 |
|
1035 |
return ff_filter_frame(outlink, buf); |
343 |
|
|
} |
344 |
|
|
|
345 |
|
2 |
static int channelmap_config_input(AVFilterLink *inlink) |
346 |
|
|
{ |
347 |
|
2 |
AVFilterContext *ctx = inlink->dst; |
348 |
|
2 |
ChannelMapContext *s = ctx->priv; |
349 |
|
2 |
int nb_channels = inlink->channels; |
350 |
|
2 |
int i, err = 0; |
351 |
|
|
const char *channel_name; |
352 |
|
|
char layout_name[256]; |
353 |
|
|
|
354 |
✓✓ |
10 |
for (i = 0; i < s->nch; i++) { |
355 |
|
8 |
struct ChannelMap *m = &s->map[i]; |
356 |
|
|
|
357 |
✓✗✗✓
|
8 |
if (s->mode == MAP_PAIR_STR_INT || s->mode == MAP_PAIR_STR_STR) { |
358 |
|
|
m->in_channel_idx = av_get_channel_layout_channel_index( |
359 |
|
|
inlink->channel_layout, m->in_channel); |
360 |
|
|
} |
361 |
|
|
|
362 |
✓✗✗✓
|
8 |
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) { |
366 |
|
|
channel_name = av_get_channel_name(m->in_channel); |
367 |
|
|
av_log(ctx, AV_LOG_ERROR, |
368 |
|
|
"input channel '%s' not available from input layout '%s'\n", |
369 |
|
|
channel_name, layout_name); |
370 |
|
|
} else { |
371 |
|
|
av_log(ctx, AV_LOG_ERROR, |
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 |
|
2 |
return err; |
380 |
|
|
} |
381 |
|
|
|
382 |
|
|
static const AVFilterPad avfilter_af_channelmap_inputs[] = { |
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 |
|
|
|
393 |
|
|
static const AVFilterPad avfilter_af_channelmap_outputs[] = { |
394 |
|
|
{ |
395 |
|
|
.name = "default", |
396 |
|
|
.type = AVMEDIA_TYPE_AUDIO |
397 |
|
|
}, |
398 |
|
|
{ NULL } |
399 |
|
|
}; |
400 |
|
|
|
401 |
|
|
AVFilter ff_af_channelmap = { |
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, |
408 |
|
|
.inputs = avfilter_af_channelmap_inputs, |
409 |
|
|
.outputs = avfilter_af_channelmap_outputs, |
410 |
|
|
}; |