Line | Branch | Exec | Source |
---|---|---|---|
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/mem.h" | ||
33 | #include "libavutil/opt.h" | ||
34 | #include "libavutil/samplefmt.h" | ||
35 | |||
36 | #include "audio.h" | ||
37 | #include "avfilter.h" | ||
38 | #include "formats.h" | ||
39 | #include "internal.h" | ||
40 | |||
41 | struct ChannelMap { | ||
42 | int in_channel; | ||
43 | int out_channel; | ||
44 | int in_channel_idx; | ||
45 | int out_channel_idx; | ||
46 | }; | ||
47 | |||
48 | enum MappingMode { | ||
49 | MAP_NONE, | ||
50 | MAP_ONE_INT, | ||
51 | MAP_ONE_STR, | ||
52 | MAP_PAIR_INT_INT, | ||
53 | MAP_PAIR_INT_STR, | ||
54 | MAP_PAIR_STR_INT, | ||
55 | MAP_PAIR_STR_STR | ||
56 | }; | ||
57 | |||
58 | #define MAX_CH 64 | ||
59 | typedef struct ChannelMapContext { | ||
60 | const AVClass *class; | ||
61 | char *mapping_str; | ||
62 | AVChannelLayout 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(output_layout), AV_OPT_TYPE_CHLAYOUT, .flags = A|F }, | ||
76 | { NULL } | ||
77 | }; | ||
78 | |||
79 | AVFILTER_DEFINE_CLASS(channelmap); | ||
80 | |||
81 | 120 | static char* split(char *message, char delim) { | |
82 | 120 | char *next = strchr(message, delim); | |
83 |
2/2✓ Branch 0 taken 48 times.
✓ Branch 1 taken 72 times.
|
120 | if (next) |
84 | 48 | *next++ = '\0'; | |
85 | 120 | return next; | |
86 | } | ||
87 | |||
88 | 116 | static int get_channel_idx(char **map, int *ch, char delim, int max_nb_channels) | |
89 | { | ||
90 | char *next; | ||
91 | int len; | ||
92 | 116 | int n = 0; | |
93 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 116 times.
|
116 | if (!*map) |
94 | ✗ | return AVERROR(EINVAL); | |
95 | 116 | next = split(*map, delim); | |
96 |
3/4✓ Branch 0 taken 70 times.
✓ Branch 1 taken 46 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 70 times.
|
116 | if (!next && delim == '-') |
97 | ✗ | return AVERROR(EINVAL); | |
98 | 116 | len = strlen(*map); | |
99 | 116 | sscanf(*map, "%d%n", ch, &n); | |
100 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 116 times.
|
116 | if (n != len) |
101 | ✗ | return AVERROR(EINVAL); | |
102 |
2/4✓ Branch 0 taken 116 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 116 times.
|
116 | if (*ch < 0 || *ch >= max_nb_channels) |
103 | ✗ | return AVERROR(EINVAL); | |
104 | 116 | *map = next; | |
105 | 116 | return 0; | |
106 | } | ||
107 | |||
108 | 4 | static int get_channel(char **map, int *ch, char delim) | |
109 | { | ||
110 | 4 | char *next = split(*map, delim); | |
111 |
3/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
|
4 | if (!next && delim == '-') |
112 | ✗ | return AVERROR(EINVAL); | |
113 | 4 | *ch = av_channel_from_string(*map); | |
114 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (*ch < 0) |
115 | ✗ | return AVERROR(EINVAL); | |
116 | 4 | *map = next; | |
117 | 4 | return 0; | |
118 | } | ||
119 | |||
120 | 204 | static int check_idx_and_id(AVFilterContext *ctx, int channel_idx, int channel, AVChannelLayout *ch_layout, const char *io) | |
121 | { | ||
122 | char channel_name[64]; | ||
123 | char layout_name[256]; | ||
124 | 204 | int nb_channels = ch_layout->nb_channels; | |
125 | |||
126 |
2/4✓ Branch 0 taken 204 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 204 times.
|
204 | if (channel_idx < 0 || channel_idx >= nb_channels) { |
127 | ✗ | av_channel_layout_describe(ch_layout, layout_name, sizeof(layout_name)); | |
128 | ✗ | if (channel >= 0) { | |
129 | ✗ | av_channel_name(channel_name, sizeof(channel_name), channel); | |
130 | ✗ | av_log(ctx, AV_LOG_ERROR, | |
131 | "%sput channel '%s' not available from %sput layout '%s'\n", | ||
132 | io, channel_name, io, layout_name); | ||
133 | } else { | ||
134 | ✗ | av_log(ctx, AV_LOG_ERROR, | |
135 | "%sput channel #%d not available from %sput layout '%s'\n", | ||
136 | io, channel_idx, io, layout_name); | ||
137 | } | ||
138 | ✗ | return AVERROR(EINVAL); | |
139 | } | ||
140 | |||
141 | 204 | return 0; | |
142 | } | ||
143 | |||
144 | 76 | static av_cold int channelmap_init(AVFilterContext *ctx) | |
145 | { | ||
146 | 76 | ChannelMapContext *s = ctx->priv; | |
147 | 76 | char *mapping, separator = '|'; | |
148 | 76 | int map_entries = 0; | |
149 | enum MappingMode mode; | ||
150 | 76 | int64_t out_ch_mask = 0; | |
151 | uint64_t presence_mask; | ||
152 | int i; | ||
153 | |||
154 | 76 | mapping = s->mapping_str; | |
155 | |||
156 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 72 times.
|
76 | if (!mapping) { |
157 | 4 | mode = MAP_NONE; | |
158 | } else { | ||
159 | 72 | char *dash = strchr(mapping, '-'); | |
160 |
1/2✓ Branch 0 taken 72 times.
✗ Branch 1 not taken.
|
72 | if (!dash) { // short mapping |
161 |
2/2✓ Branch 0 taken 70 times.
✓ Branch 1 taken 2 times.
|
72 | if (av_isdigit(*mapping)) |
162 | 70 | mode = MAP_ONE_INT; | |
163 | else | ||
164 | 2 | mode = MAP_ONE_STR; | |
165 | ✗ | } else if (av_isdigit(*mapping)) { | |
166 | ✗ | if (av_isdigit(*(dash+1))) | |
167 | ✗ | mode = MAP_PAIR_INT_INT; | |
168 | else | ||
169 | ✗ | mode = MAP_PAIR_INT_STR; | |
170 | } else { | ||
171 | ✗ | if (av_isdigit(*(dash+1))) | |
172 | ✗ | mode = MAP_PAIR_STR_INT; | |
173 | else | ||
174 | ✗ | mode = MAP_PAIR_STR_STR; | |
175 | } | ||
176 | } | ||
177 | |||
178 |
2/2✓ Branch 0 taken 72 times.
✓ Branch 1 taken 4 times.
|
76 | if (mode != MAP_NONE) { |
179 | 72 | char *sep = mapping; | |
180 | 72 | map_entries = 1; | |
181 |
2/2✓ Branch 0 taken 48 times.
✓ Branch 1 taken 72 times.
|
120 | while ((sep = strchr(sep, separator))) { |
182 |
1/2✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
|
48 | if (*++sep) // Allow trailing comma |
183 | 48 | map_entries++; | |
184 | } | ||
185 | } | ||
186 | |||
187 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 76 times.
|
76 | if (map_entries > MAX_CH) { |
188 | ✗ | av_log(ctx, AV_LOG_ERROR, "Too many channels mapped: '%d'.\n", map_entries); | |
189 | ✗ | return AVERROR(EINVAL); | |
190 | } | ||
191 | |||
192 |
2/2✓ Branch 0 taken 4864 times.
✓ Branch 1 taken 76 times.
|
4940 | for (i = 0; i < MAX_CH; i++) { |
193 | 4864 | s->map[i].in_channel_idx = -1; | |
194 | 4864 | s->map[i].out_channel_idx = -1; | |
195 | 4864 | s->map[i].in_channel = -1; | |
196 | 4864 | s->map[i].out_channel = -1; | |
197 | } | ||
198 | |||
199 |
2/2✓ Branch 0 taken 120 times.
✓ Branch 1 taken 76 times.
|
196 | for (i = 0; i < map_entries; i++) { |
200 | 120 | int in_ch_idx = -1, out_ch_idx = -1; | |
201 | 120 | int in_ch = -1, out_ch = -1; | |
202 | static const char err[] = "Failed to parse channel map\n"; | ||
203 |
2/7✓ Branch 0 taken 116 times.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
|
120 | switch (mode) { |
204 | 116 | case MAP_ONE_INT: | |
205 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 116 times.
|
116 | if (get_channel_idx(&mapping, &in_ch_idx, separator, MAX_CH) < 0) { |
206 | ✗ | av_log(ctx, AV_LOG_ERROR, err); | |
207 | ✗ | return AVERROR(EINVAL); | |
208 | } | ||
209 | 116 | s->map[i].in_channel_idx = in_ch_idx; | |
210 | 116 | s->map[i].out_channel_idx = i; | |
211 | 116 | break; | |
212 | 4 | case MAP_ONE_STR: | |
213 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
|
4 | if (get_channel(&mapping, &in_ch, separator) < 0) { |
214 | ✗ | av_log(ctx, AV_LOG_ERROR, err); | |
215 | ✗ | return AVERROR(EINVAL); | |
216 | } | ||
217 | 4 | s->map[i].in_channel = in_ch; | |
218 | 4 | s->map[i].out_channel_idx = i; | |
219 | 4 | break; | |
220 | ✗ | case MAP_PAIR_INT_INT: | |
221 | ✗ | if (get_channel_idx(&mapping, &in_ch_idx, '-', MAX_CH) < 0 || | |
222 | ✗ | get_channel_idx(&mapping, &out_ch_idx, separator, MAX_CH) < 0) { | |
223 | ✗ | av_log(ctx, AV_LOG_ERROR, err); | |
224 | ✗ | return AVERROR(EINVAL); | |
225 | } | ||
226 | ✗ | s->map[i].in_channel_idx = in_ch_idx; | |
227 | ✗ | s->map[i].out_channel_idx = out_ch_idx; | |
228 | ✗ | break; | |
229 | ✗ | case MAP_PAIR_INT_STR: | |
230 | ✗ | if (get_channel_idx(&mapping, &in_ch_idx, '-', MAX_CH) < 0 || | |
231 | ✗ | get_channel(&mapping, &out_ch, separator) < 0) { | |
232 | ✗ | av_log(ctx, AV_LOG_ERROR, err); | |
233 | ✗ | return AVERROR(EINVAL); | |
234 | } | ||
235 | ✗ | s->map[i].in_channel_idx = in_ch_idx; | |
236 | ✗ | s->map[i].out_channel = out_ch; | |
237 | ✗ | if (out_ch < 63) | |
238 | ✗ | out_ch_mask |= 1ULL << out_ch; | |
239 | else | ||
240 | ✗ | out_ch_mask = -1; | |
241 | ✗ | break; | |
242 | ✗ | case MAP_PAIR_STR_INT: | |
243 | ✗ | if (get_channel(&mapping, &in_ch, '-') < 0 || | |
244 | ✗ | get_channel_idx(&mapping, &out_ch_idx, separator, MAX_CH) < 0) { | |
245 | ✗ | av_log(ctx, AV_LOG_ERROR, err); | |
246 | ✗ | return AVERROR(EINVAL); | |
247 | } | ||
248 | ✗ | s->map[i].in_channel = in_ch; | |
249 | ✗ | s->map[i].out_channel_idx = out_ch_idx; | |
250 | ✗ | break; | |
251 | ✗ | case MAP_PAIR_STR_STR: | |
252 | ✗ | if (get_channel(&mapping, &in_ch, '-') < 0 || | |
253 | ✗ | get_channel(&mapping, &out_ch, separator) < 0) { | |
254 | ✗ | av_log(ctx, AV_LOG_ERROR, err); | |
255 | ✗ | return AVERROR(EINVAL); | |
256 | } | ||
257 | ✗ | s->map[i].in_channel = in_ch; | |
258 | ✗ | s->map[i].out_channel = out_ch; | |
259 | ✗ | if (out_ch < 63) | |
260 | ✗ | out_ch_mask |= 1ULL << out_ch; | |
261 | else | ||
262 | ✗ | out_ch_mask = -1; | |
263 | ✗ | break; | |
264 | } | ||
265 | } | ||
266 | 76 | s->mode = mode; | |
267 | 76 | s->nch = map_entries; | |
268 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 76 times.
|
76 | if (s->output_layout.nb_channels == 0) { |
269 | ✗ | if (out_ch_mask > 0) | |
270 | ✗ | av_channel_layout_from_mask(&s->output_layout, out_ch_mask); | |
271 | ✗ | else if (map_entries) | |
272 | ✗ | av_channel_layout_default(&s->output_layout, map_entries); | |
273 | } | ||
274 | |||
275 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 72 times.
|
76 | if (mode == MAP_NONE) { |
276 | int i; | ||
277 | 4 | s->nch = s->output_layout.nb_channels; | |
278 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 4 times.
|
20 | for (i = 0; i < s->nch; i++) { |
279 | 16 | s->map[i].in_channel_idx = i; | |
280 | 16 | s->map[i].out_channel_idx = i; | |
281 | } | ||
282 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 72 times.
|
72 | } else if (s->nch != s->output_layout.nb_channels) { |
283 | char buf[256]; | ||
284 | ✗ | av_channel_layout_describe(&s->output_layout, buf, sizeof(buf)); | |
285 | ✗ | av_log(ctx, AV_LOG_ERROR, | |
286 | "Output channel layout %s does not match the number of channels mapped %d.\n", | ||
287 | buf, s->nch); | ||
288 | ✗ | return AVERROR(EINVAL); | |
289 | } | ||
290 | |||
291 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 76 times.
|
76 | if (!s->output_layout.nb_channels) { |
292 | ✗ | av_log(ctx, AV_LOG_ERROR, "Output channel layout is not set and " | |
293 | "cannot be guessed from the maps.\n"); | ||
294 | ✗ | return AVERROR(EINVAL); | |
295 | } | ||
296 | |||
297 |
2/4✓ Branch 0 taken 76 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 76 times.
|
76 | if (mode == MAP_PAIR_INT_STR || mode == MAP_PAIR_STR_STR) { |
298 | ✗ | for (i = 0; i < s->nch; i++) { | |
299 | ✗ | s->map[i].out_channel_idx = av_channel_layout_index_from_channel( | |
300 | ✗ | &s->output_layout, s->map[i].out_channel); | |
301 | } | ||
302 | } | ||
303 | |||
304 | 76 | presence_mask = 0; | |
305 |
2/2✓ Branch 0 taken 136 times.
✓ Branch 1 taken 76 times.
|
212 | for (i = 0; i < s->nch; i++) { |
306 | uint64_t idx_mask; | ||
307 | 136 | int ret = check_idx_and_id(ctx, s->map[i].out_channel_idx, s->map[i].out_channel, &s->output_layout, "out"); | |
308 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 136 times.
|
136 | if (ret < 0) |
309 | ✗ | return ret; | |
310 | 136 | idx_mask = (1ULL << s->map[i].out_channel_idx); | |
311 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 136 times.
|
136 | if (presence_mask & idx_mask) { |
312 | char layout_name[256]; | ||
313 | ✗ | av_channel_layout_describe(&s->output_layout, layout_name, sizeof(layout_name)); | |
314 | ✗ | av_log(ctx, AV_LOG_ERROR, "Mapping %d assigns channel #%d twice in output layout '%s'.\n", | |
315 | i + 1, s->map[i].out_channel_idx, layout_name); | ||
316 | ✗ | return AVERROR(EINVAL); | |
317 | } | ||
318 | 136 | presence_mask |= idx_mask; | |
319 | } | ||
320 | |||
321 | 76 | return 0; | |
322 | } | ||
323 | |||
324 | 38 | static int channelmap_query_formats(AVFilterContext *ctx) | |
325 | { | ||
326 | 38 | ChannelMapContext *s = ctx->priv; | |
327 | 38 | AVFilterChannelLayouts *channel_layouts = NULL; | |
328 | int ret; | ||
329 | |||
330 |
2/4✓ Branch 2 taken 38 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 38 times.
✗ Branch 5 not taken.
|
76 | if ((ret = ff_set_common_formats (ctx, ff_planar_sample_fmts())) < 0 || |
331 |
1/2✓ Branch 1 taken 38 times.
✗ Branch 2 not taken.
|
76 | (ret = ff_set_common_all_samplerates(ctx )) < 0 || |
332 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 38 times.
|
76 | (ret = ff_add_channel_layout(&channel_layouts, &s->output_layout)) < 0 || |
333 | 38 | (ret = ff_channel_layouts_ref(channel_layouts, | |
334 | 38 | &ctx->outputs[0]->incfg.channel_layouts)) < 0) | |
335 | ✗ | return ret; | |
336 | |||
337 | 38 | return ff_channel_layouts_ref(ff_all_channel_counts(), | |
338 | 38 | &ctx->inputs[0]->outcfg.channel_layouts); | |
339 | } | ||
340 | |||
341 | 556 | static int channelmap_filter_frame(AVFilterLink *inlink, AVFrame *buf) | |
342 | { | ||
343 | 556 | AVFilterContext *ctx = inlink->dst; | |
344 | 556 | AVFilterLink *outlink = ctx->outputs[0]; | |
345 | 556 | const ChannelMapContext *s = ctx->priv; | |
346 | 556 | const int nch_in = inlink->ch_layout.nb_channels; | |
347 | 556 | const int nch_out = s->nch; | |
348 | int ch, ret; | ||
349 | uint8_t *source_planes[MAX_CH]; | ||
350 | |||
351 | 556 | memcpy(source_planes, buf->extended_data, | |
352 | nch_in * sizeof(source_planes[0])); | ||
353 | |||
354 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 556 times.
|
556 | if (nch_out > nch_in) { |
355 | ✗ | if (nch_out > FF_ARRAY_ELEMS(buf->data)) { | |
356 | uint8_t **new_extended_data = | ||
357 | ✗ | av_calloc(nch_out, sizeof(*buf->extended_data)); | |
358 | ✗ | if (!new_extended_data) { | |
359 | ✗ | av_frame_free(&buf); | |
360 | ✗ | return AVERROR(ENOMEM); | |
361 | } | ||
362 | ✗ | if (buf->extended_data == buf->data) { | |
363 | ✗ | buf->extended_data = new_extended_data; | |
364 | } else { | ||
365 | ✗ | av_free(buf->extended_data); | |
366 | ✗ | buf->extended_data = new_extended_data; | |
367 | } | ||
368 | ✗ | } else if (buf->extended_data != buf->data) { | |
369 | ✗ | av_free(buf->extended_data); | |
370 | ✗ | buf->extended_data = buf->data; | |
371 | } | ||
372 | } | ||
373 | |||
374 |
2/2✓ Branch 0 taken 1228 times.
✓ Branch 1 taken 556 times.
|
1784 | for (ch = 0; ch < nch_out; ch++) { |
375 | 1228 | buf->extended_data[s->map[ch].out_channel_idx] = | |
376 | 1228 | source_planes[s->map[ch].in_channel_idx]; | |
377 | } | ||
378 | |||
379 |
2/2✓ Branch 0 taken 312 times.
✓ Branch 1 taken 244 times.
|
556 | if (buf->data != buf->extended_data) |
380 | 312 | memcpy(buf->data, buf->extended_data, | |
381 |
1/2✓ Branch 0 taken 312 times.
✗ Branch 1 not taken.
|
312 | FFMIN(FF_ARRAY_ELEMS(buf->data), nch_out) * sizeof(buf->data[0])); |
382 | |||
383 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 556 times.
|
556 | if ((ret = av_channel_layout_copy(&buf->ch_layout, &outlink->ch_layout)) < 0) |
384 | ✗ | return ret; | |
385 | |||
386 | 556 | return ff_filter_frame(outlink, buf); | |
387 | } | ||
388 | |||
389 | 38 | static int channelmap_config_input(AVFilterLink *inlink) | |
390 | { | ||
391 | 38 | AVFilterContext *ctx = inlink->dst; | |
392 | 38 | ChannelMapContext *s = ctx->priv; | |
393 | 38 | int i, err = 0; | |
394 | |||
395 |
2/2✓ Branch 0 taken 68 times.
✓ Branch 1 taken 38 times.
|
106 | for (i = 0; i < s->nch; i++) { |
396 | 68 | struct ChannelMap *m = &s->map[i]; | |
397 | |||
398 |
4/6✓ Branch 0 taken 68 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 68 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 66 times.
|
68 | if (s->mode == MAP_PAIR_STR_INT || s->mode == MAP_PAIR_STR_STR || s->mode == MAP_ONE_STR) { |
399 | 2 | m->in_channel_idx = av_channel_layout_index_from_channel( | |
400 | 2 | &inlink->ch_layout, m->in_channel); | |
401 | } | ||
402 | |||
403 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 68 times.
|
68 | if (check_idx_and_id(ctx, m->in_channel_idx, m->in_channel, &inlink->ch_layout, "in") < 0) |
404 | ✗ | err = AVERROR(EINVAL); | |
405 | } | ||
406 | |||
407 | 38 | return err; | |
408 | } | ||
409 | |||
410 | static const AVFilterPad avfilter_af_channelmap_inputs[] = { | ||
411 | { | ||
412 | .name = "default", | ||
413 | .type = AVMEDIA_TYPE_AUDIO, | ||
414 | .flags = AVFILTERPAD_FLAG_NEEDS_WRITABLE, | ||
415 | .filter_frame = channelmap_filter_frame, | ||
416 | .config_props = channelmap_config_input, | ||
417 | }, | ||
418 | }; | ||
419 | |||
420 | const AVFilter ff_af_channelmap = { | ||
421 | .name = "channelmap", | ||
422 | .description = NULL_IF_CONFIG_SMALL("Remap audio channels."), | ||
423 | .init = channelmap_init, | ||
424 | .priv_size = sizeof(ChannelMapContext), | ||
425 | .priv_class = &channelmap_class, | ||
426 | FILTER_INPUTS(avfilter_af_channelmap_inputs), | ||
427 | FILTER_OUTPUTS(ff_audio_default_filterpad), | ||
428 | FILTER_QUERY_FUNC(channelmap_query_formats), | ||
429 | }; | ||
430 |