FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavutil/channel_layout.c
Date: 2026-04-28 04:29:18
Exec Total Coverage
Lines: 482 531 90.8%
Functions: 28 28 100.0%
Branches: 354 434 81.6%
Line Branch Exec Source
1 /*
2 * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
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 layout utility functions
24 */
25
26 #include <stdint.h>
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include "avassert.h"
31 #include "channel_layout.h"
32 #include "bprint.h"
33 #include "common.h"
34 #include "error.h"
35 #include "macros.h"
36 #include "mem.h"
37 #include "opt.h"
38
39 #define CHAN_IS_AMBI(x) ((x) >= AV_CHAN_AMBISONIC_BASE &&\
40 (x) <= AV_CHAN_AMBISONIC_END)
41
42 struct channel_name {
43 const char *name;
44 const char *description;
45 };
46
47 static const struct channel_name channel_names[] = {
48 [AV_CHAN_FRONT_LEFT ] = { "FL", "front left" },
49 [AV_CHAN_FRONT_RIGHT ] = { "FR", "front right" },
50 [AV_CHAN_FRONT_CENTER ] = { "FC", "front center" },
51 [AV_CHAN_LOW_FREQUENCY ] = { "LFE", "low frequency" },
52 [AV_CHAN_BACK_LEFT ] = { "BL", "back left" },
53 [AV_CHAN_BACK_RIGHT ] = { "BR", "back right" },
54 [AV_CHAN_FRONT_LEFT_OF_CENTER ] = { "FLC", "front left-of-center" },
55 [AV_CHAN_FRONT_RIGHT_OF_CENTER] = { "FRC", "front right-of-center" },
56 [AV_CHAN_BACK_CENTER ] = { "BC", "back center" },
57 [AV_CHAN_SIDE_LEFT ] = { "SL", "side left" },
58 [AV_CHAN_SIDE_RIGHT ] = { "SR", "side right" },
59 [AV_CHAN_TOP_CENTER ] = { "TC", "top center" },
60 [AV_CHAN_TOP_FRONT_LEFT ] = { "TFL", "top front left" },
61 [AV_CHAN_TOP_FRONT_CENTER ] = { "TFC", "top front center" },
62 [AV_CHAN_TOP_FRONT_RIGHT ] = { "TFR", "top front right" },
63 [AV_CHAN_TOP_BACK_LEFT ] = { "TBL", "top back left" },
64 [AV_CHAN_TOP_BACK_CENTER ] = { "TBC", "top back center" },
65 [AV_CHAN_TOP_BACK_RIGHT ] = { "TBR", "top back right" },
66 [AV_CHAN_STEREO_LEFT ] = { "DL", "downmix left" },
67 [AV_CHAN_STEREO_RIGHT ] = { "DR", "downmix right" },
68 [AV_CHAN_WIDE_LEFT ] = { "WL", "wide left" },
69 [AV_CHAN_WIDE_RIGHT ] = { "WR", "wide right" },
70 [AV_CHAN_SURROUND_DIRECT_LEFT ] = { "SDL", "surround direct left" },
71 [AV_CHAN_SURROUND_DIRECT_RIGHT] = { "SDR", "surround direct right" },
72 [AV_CHAN_LOW_FREQUENCY_2 ] = { "LFE2", "low frequency 2" },
73 [AV_CHAN_TOP_SIDE_LEFT ] = { "TSL", "top side left" },
74 [AV_CHAN_TOP_SIDE_RIGHT ] = { "TSR", "top side right" },
75 [AV_CHAN_BOTTOM_FRONT_CENTER ] = { "BFC", "bottom front center" },
76 [AV_CHAN_BOTTOM_FRONT_LEFT ] = { "BFL", "bottom front left" },
77 [AV_CHAN_BOTTOM_FRONT_RIGHT ] = { "BFR", "bottom front right" },
78 [AV_CHAN_SIDE_SURROUND_LEFT ] = { "SSL", "side surround left" },
79 [AV_CHAN_SIDE_SURROUND_RIGHT ] = { "SSR", "side surround right" },
80 [AV_CHAN_TOP_SURROUND_LEFT ] = { "TTL", "top surround left" },
81 [AV_CHAN_TOP_SURROUND_RIGHT ] = { "TTR", "top surround right" },
82 [AV_CHAN_BINAURAL_LEFT ] = { "BIL", "binaural left" },
83 [AV_CHAN_BINAURAL_RIGHT ] = { "BIR", "binaural right" },
84 };
85
86 2468 void av_channel_name_bprint(AVBPrint *bp, enum AVChannel channel_id)
87 {
88
3/4
✓ Branch 0 taken 579 times.
✓ Branch 1 taken 1889 times.
✓ Branch 2 taken 579 times.
✗ Branch 3 not taken.
 2468 if (channel_id >= AV_CHAN_AMBISONIC_BASE &&
89 channel_id <= AV_CHAN_AMBISONIC_END)
90 579 av_bprintf(bp, "AMBI%d", channel_id - AV_CHAN_AMBISONIC_BASE);
91
2/2
✓ Branch 0 taken 1866 times.
✓ Branch 1 taken 23 times.
 1889 else if ((unsigned)channel_id < FF_ARRAY_ELEMS(channel_names) &&
92
1/2
✓ Branch 0 taken 1866 times.
✗ Branch 1 not taken.
 1866 channel_names[channel_id].name)
93 1866 av_bprintf(bp, "%s", channel_names[channel_id].name);
94
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23 times.
 23 else if (channel_id == AV_CHAN_NONE)
95 ✗ av_bprintf(bp, "NONE");
96
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 12 times.
 23 else if (channel_id == AV_CHAN_UNKNOWN)
97 11 av_bprintf(bp, "UNK");
98
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 9 times.
 12 else if (channel_id == AV_CHAN_UNUSED)
99 3 av_bprintf(bp, "UNSD");
100 else
101 9 av_bprintf(bp, "USR%d", channel_id);
102 2468 }
103
104 479 int av_channel_name(char *buf, size_t buf_size, enum AVChannel channel_id)
105 {
106 AVBPrint bp;
107
108
3/4
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 474 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
 479 if (!buf && buf_size)
109 ✗ return AVERROR(EINVAL);
110
111 479 av_bprint_init_for_buffer(&bp, buf, buf_size);
112 479 av_channel_name_bprint(&bp, channel_id);
113
114
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 479 times.
 479 if (bp.len >= INT_MAX)
115 ✗ return AVERROR(ERANGE);
116 479 return bp.len + 1;
117 }
118
119 15 void av_channel_description_bprint(AVBPrint *bp, enum AVChannel channel_id)
120 {
121
3/4
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
 15 if (channel_id >= AV_CHAN_AMBISONIC_BASE &&
122 channel_id <= AV_CHAN_AMBISONIC_END)
123 6 av_bprintf(bp, "ambisonic ACN %d", channel_id - AV_CHAN_AMBISONIC_BASE);
124
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 3 times.
 9 else if ((unsigned)channel_id < FF_ARRAY_ELEMS(channel_names) &&
125
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 channel_names[channel_id].description)
126 6 av_bprintf(bp, "%s", channel_names[channel_id].description);
127
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 else if (channel_id == AV_CHAN_NONE)
128 ✗ av_bprintf(bp, "none");
129
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 else if (channel_id == AV_CHAN_UNKNOWN)
130 ✗ av_bprintf(bp, "unknown");
131
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 else if (channel_id == AV_CHAN_UNUSED)
132 ✗ av_bprintf(bp, "unused");
133 else
134 3 av_bprintf(bp, "user %d", channel_id);
135 15 }
136
137 10 int av_channel_description(char *buf, size_t buf_size, enum AVChannel channel_id)
138 {
139 AVBPrint bp;
140
141
3/4
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
 10 if (!buf && buf_size)
142 ✗ return AVERROR(EINVAL);
143
144 10 av_bprint_init_for_buffer(&bp, buf, buf_size);
145 10 av_channel_description_bprint(&bp, channel_id);
146
147
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (bp.len >= INT_MAX)
148 ✗ return AVERROR(ERANGE);
149 10 return bp.len + 1;
150 }
151
152 728 enum AVChannel av_channel_from_string(const char *str)
153 {
154 int i;
155 728 char *endptr = (char *)str;
156 728 enum AVChannel id = AV_CHAN_NONE;
157
158
2/2
✓ Branch 0 taken 260 times.
✓ Branch 1 taken 468 times.
 728 if (!strncmp(str, "AMBI", 4)) {
159 260 i = strtol(str + 4, NULL, 0);
160
3/4
✓ Branch 0 taken 260 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 259 times.
 260 if (i < 0 || i > AV_CHAN_AMBISONIC_END - AV_CHAN_AMBISONIC_BASE)
161 1 return AV_CHAN_NONE;
162 259 return AV_CHAN_AMBISONIC_BASE + i;
163 }
164
165
2/2
✓ Branch 0 taken 9190 times.
✓ Branch 1 taken 124 times.
 9314 for (i = 0; i < FF_ARRAY_ELEMS(channel_names); i++) {
166
4/4
✓ Branch 0 taken 5798 times.
✓ Branch 1 taken 3392 times.
✓ Branch 2 taken 344 times.
✓ Branch 3 taken 5454 times.
 9190 if (channel_names[i].name && !strcmp(str, channel_names[i].name))
167 344 return i;
168 }
169
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 123 times.
 124 if (!strcmp(str, "UNK"))
170 1 return AV_CHAN_UNKNOWN;
171
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 122 times.
 123 if (!strcmp(str, "UNSD"))
172 1 return AV_CHAN_UNUSED;
173
174
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 115 times.
 122 if (!strncmp(str, "USR", 3)) {
175 7 const char *p = str + 3;
176 7 id = strtol(p, &endptr, 0);
177 }
178
3/4
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 115 times.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
 122 if (id >= 0 && !*endptr)
179 7 return id;
180
181 115 return AV_CHAN_NONE;
182 }
183
184 struct channel_layout_name {
185 const char *name;
186 AVChannelLayout layout;
187 };
188
189 static const struct channel_layout_name channel_layout_map[] = {
190 { "mono", AV_CHANNEL_LAYOUT_MONO },
191 { "stereo", AV_CHANNEL_LAYOUT_STEREO },
192 { "2.1", AV_CHANNEL_LAYOUT_2POINT1 },
193 { "3.0", AV_CHANNEL_LAYOUT_SURROUND },
194 { "3.0(back)", AV_CHANNEL_LAYOUT_2_1 },
195 { "4.0", AV_CHANNEL_LAYOUT_4POINT0 },
196 { "quad", AV_CHANNEL_LAYOUT_QUAD },
197 { "quad(side)", AV_CHANNEL_LAYOUT_2_2 },
198 { "3.1", AV_CHANNEL_LAYOUT_3POINT1 },
199 { "5.0", AV_CHANNEL_LAYOUT_5POINT0_BACK },
200 { "5.0(side)", AV_CHANNEL_LAYOUT_5POINT0 },
201 { "4.1", AV_CHANNEL_LAYOUT_4POINT1 },
202 { "5.1", AV_CHANNEL_LAYOUT_5POINT1_BACK },
203 { "5.1(side)", AV_CHANNEL_LAYOUT_5POINT1 },
204 { "6.0", AV_CHANNEL_LAYOUT_6POINT0 },
205 { "6.0(front)", AV_CHANNEL_LAYOUT_6POINT0_FRONT },
206 { "3.1.2", AV_CHANNEL_LAYOUT_3POINT1POINT2 },
207 { "hexagonal", AV_CHANNEL_LAYOUT_HEXAGONAL },
208 { "6.1", AV_CHANNEL_LAYOUT_6POINT1 },
209 { "6.1(back)", AV_CHANNEL_LAYOUT_6POINT1_BACK },
210 { "6.1(front)", AV_CHANNEL_LAYOUT_6POINT1_FRONT },
211 { "7.0", AV_CHANNEL_LAYOUT_7POINT0 },
212 { "7.0(front)", AV_CHANNEL_LAYOUT_7POINT0_FRONT },
213 { "7.1", AV_CHANNEL_LAYOUT_7POINT1 },
214 { "7.1(wide)", AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK },
215 { "7.1(wide-side)", AV_CHANNEL_LAYOUT_7POINT1_WIDE },
216 { "5.1.2", AV_CHANNEL_LAYOUT_5POINT1POINT2 },
217 { "5.1.2(back)", AV_CHANNEL_LAYOUT_5POINT1POINT2_BACK },
218 { "octagonal", AV_CHANNEL_LAYOUT_OCTAGONAL },
219 { "cube", AV_CHANNEL_LAYOUT_CUBE },
220 { "5.1.4", AV_CHANNEL_LAYOUT_5POINT1POINT4_BACK },
221 { "7.1.2", AV_CHANNEL_LAYOUT_7POINT1POINT2 },
222 { "7.1.4", AV_CHANNEL_LAYOUT_7POINT1POINT4_BACK },
223 { "7.2.3", AV_CHANNEL_LAYOUT_7POINT2POINT3 },
224 { "9.1.4", AV_CHANNEL_LAYOUT_9POINT1POINT4_BACK },
225 { "9.1.6", AV_CHANNEL_LAYOUT_9POINT1POINT6 },
226 { "hexadecagonal", AV_CHANNEL_LAYOUT_HEXADECAGONAL },
227 { "binaural", AV_CHANNEL_LAYOUT_BINAURAL },
228 { "downmix", AV_CHANNEL_LAYOUT_STEREO_DOWNMIX, },
229 { "22.2", AV_CHANNEL_LAYOUT_22POINT2, },
230 };
231
232 131 int av_channel_layout_custom_init(AVChannelLayout *channel_layout, int nb_channels)
233 {
234 AVChannelCustom *map;
235
236
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 131 times.
 131 if (nb_channels <= 0)
237 ✗ return AVERROR(EINVAL);
238
239 131 map = av_calloc(nb_channels, sizeof(*channel_layout->u.map));
240
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 131 times.
 131 if (!map)
241 ✗ return AVERROR(ENOMEM);
242
2/2
✓ Branch 0 taken 578 times.
✓ Branch 1 taken 131 times.
 709 for (int i = 0; i < nb_channels; i++)
243 578 map[i].id = AV_CHAN_UNKNOWN;
244
245 131 channel_layout->order = AV_CHANNEL_ORDER_CUSTOM;
246 131 channel_layout->nb_channels = nb_channels;
247 131 channel_layout->u.map = map;
248
249 131 return 0;
250 }
251
252 24052 int av_channel_layout_from_mask(AVChannelLayout *channel_layout,
253 uint64_t mask)
254 {
255
2/2
✓ Branch 0 taken 41 times.
✓ Branch 1 taken 24011 times.
 24052 if (!mask)
256 41 return AVERROR(EINVAL);
257
258 24011 channel_layout->order = AV_CHANNEL_ORDER_NATIVE;
259 24011 channel_layout->nb_channels = av_popcount64(mask);
260 24011 channel_layout->u.mask = mask;
261
262 24011 return 0;
263 }
264
265 183 static int parse_channel_list(AVChannelLayout *ch_layout, const char *str)
266 {
267 int ret;
268 183 int nb_channels = 0;
269 183 AVChannelCustom *map = NULL;
270 183 AVChannelCustom custom = {0};
271
272
2/2
✓ Branch 0 taken 325 times.
✓ Branch 1 taken 81 times.
 406 while (*str) {
273 char *channel, *chname;
274 325 ret = av_opt_get_key_value(&str, "@", "+", AV_OPT_FLAG_IMPLICIT_KEY, &channel, &chname);
275
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 325 times.
 325 if (ret < 0) {
276 ✗ av_freep(&map);
277 102 return ret;
278 }
279
2/2
✓ Branch 0 taken 144 times.
✓ Branch 1 taken 181 times.
 325 if (*str)
280 144 str++; // skip separator
281
2/2
✓ Branch 0 taken 311 times.
✓ Branch 1 taken 14 times.
 325 if (!channel) {
282 311 channel = chname;
283 311 chname = NULL;
284 }
285
2/2
✓ Branch 0 taken 14 times.
✓ Branch 1 taken 311 times.
 325 av_strlcpy(custom.name, chname ? chname : "", sizeof(custom.name));
286 325 custom.id = av_channel_from_string(channel);
287 325 av_free(channel);
288 325 av_free(chname);
289
2/2
✓ Branch 0 taken 102 times.
✓ Branch 1 taken 223 times.
 325 if (custom.id == AV_CHAN_NONE) {
290 102 av_freep(&map);
291 102 return AVERROR(EINVAL);
292 }
293
294 223 av_dynarray2_add((void **)&map, &nb_channels, sizeof(custom), (void *)&custom);
295
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 223 times.
 223 if (!map)
296 ✗ return AVERROR(ENOMEM);
297 }
298
299
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 80 times.
 81 if (!nb_channels)
300 1 return AVERROR(EINVAL);
301
302 80 ch_layout->order = AV_CHANNEL_ORDER_CUSTOM;
303 80 ch_layout->u.map = map;
304 80 ch_layout->nb_channels = nb_channels;
305
306 80 ret = av_channel_layout_retype(ch_layout, 0, AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL);
307
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 80 times.
 80 av_assert0(ret == 0);
308
309 80 return 0;
310 }
311
312 2248 int av_channel_layout_from_string(AVChannelLayout *channel_layout,
313 const char *str)
314 {
315 int i, matches, ret;
316 2248 int channels = 0, nb_channels = 0;
317 char *chlist, *end;
318 2248 uint64_t mask = 0;
319
320 /* channel layout names */
321
2/2
✓ Branch 0 taken 17322 times.
✓ Branch 1 taken 198 times.
 17520 for (i = 0; i < FF_ARRAY_ELEMS(channel_layout_map); i++) {
322
3/4
✓ Branch 0 taken 17322 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2050 times.
✓ Branch 3 taken 15272 times.
 17322 if (channel_layout_map[i].name && !strcmp(str, channel_layout_map[i].name)) {
323 2050 *channel_layout = channel_layout_map[i].layout;
324 2050 return 0;
325 }
326 }
327
328 /* This function is a channel layout initializer, so we have to
329 * zero-initialize before we start setting fields individually. */
330 198 memset(channel_layout, 0, sizeof(*channel_layout));
331
332 /* ambisonic */
333
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 183 times.
 198 if (!strncmp(str, "ambisonic ", 10)) {
334 15 const char *p = str + 10;
335 char *endptr;
336 15 AVChannelLayout extra = {0};
337 int order;
338
339 15 order = strtol(p, &endptr, 0);
340
2/4
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.
✗ Branch 3 not taken.
 15 if (order < 0 || order + 1 > INT_MAX / (order + 1) ||
341
3/4
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 5 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 10 times.
 15 (*endptr && *endptr != '+'))
342 ✗ return AVERROR(EINVAL);
343
344 15 channel_layout->order = AV_CHANNEL_ORDER_AMBISONIC;
345 15 channel_layout->nb_channels = (order + 1) * (order + 1);
346
347
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 5 times.
 15 if (*endptr) {
348 10 ret = av_channel_layout_from_string(&extra, endptr + 1);
349
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (ret < 0)
350 ✗ return ret;
351
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (extra.nb_channels >= INT_MAX - channel_layout->nb_channels) {
352 ✗ av_channel_layout_uninit(&extra);
353 ✗ return AVERROR(EINVAL);
354 }
355
356
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 2 times.
 10 if (extra.order == AV_CHANNEL_ORDER_NATIVE) {
357 8 channel_layout->u.mask = extra.u.mask;
358 } else {
359 2 channel_layout->order = AV_CHANNEL_ORDER_CUSTOM;
360 2 channel_layout->u.map =
361 2 av_calloc(channel_layout->nb_channels + extra.nb_channels,
362 sizeof(*channel_layout->u.map));
363
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (!channel_layout->u.map) {
364 ✗ av_channel_layout_uninit(&extra);
365 ✗ return AVERROR(ENOMEM);
366 }
367
368
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 2 times.
 15 for (i = 0; i < channel_layout->nb_channels; i++)
369 13 channel_layout->u.map[i].id = AV_CHAN_AMBISONIC_BASE + i;
370
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2 times.
 5 for (i = 0; i < extra.nb_channels; i++) {
371 3 enum AVChannel ch = av_channel_layout_channel_from_index(&extra, i);
372
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 3 if (CHAN_IS_AMBI(ch)) {
373 ✗ av_channel_layout_uninit(channel_layout);
374 ✗ av_channel_layout_uninit(&extra);
375 ✗ return AVERROR(EINVAL);
376 }
377 3 channel_layout->u.map[channel_layout->nb_channels + i].id = ch;
378
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 if (extra.order == AV_CHANNEL_ORDER_CUSTOM &&
379
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2 times.
 3 extra.u.map[i].name[0])
380 1 av_strlcpy(channel_layout->u.map[channel_layout->nb_channels + i].name,
381 1 extra.u.map[i].name,
382 sizeof(channel_layout->u.map[channel_layout->nb_channels + i].name));
383 }
384 }
385 10 channel_layout->nb_channels += extra.nb_channels;
386 10 av_channel_layout_uninit(&extra);
387 }
388
389 15 return 0;
390 }
391
392 183 chlist = av_strdup(str);
393
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 183 times.
 183 if (!chlist)
394 ✗ return AVERROR(ENOMEM);
395
396 /* channel names */
397 183 matches = av_sscanf(str, "%d channels (%[^)]", &nb_channels, chlist);
398 183 ret = parse_channel_list(channel_layout, chlist);
399 183 av_freep(&chlist);
400
3/4
✓ Branch 0 taken 103 times.
✓ Branch 1 taken 80 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 103 times.
 183 if (ret < 0 && ret != AVERROR(EINVAL))
401 ✗ return ret;
402
403
2/2
✓ Branch 0 taken 80 times.
✓ Branch 1 taken 103 times.
 183 if (ret >= 0) {
404 80 end = strchr(str, ')');
405
7/8
✓ Branch 0 taken 38 times.
✓ Branch 1 taken 42 times.
✓ Branch 2 taken 36 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 35 times.
✓ Branch 5 taken 1 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 35 times.
 80 if (matches == 2 && (nb_channels != channel_layout->nb_channels || !end || *++end)) {
406 3 av_channel_layout_uninit(channel_layout);
407 3 return AVERROR(EINVAL);
408 }
409 77 return 0;
410 }
411
412 103 errno = 0;
413 103 mask = strtoull(str, &end, 0);
414
415 /* channel layout mask */
416
7/8
✓ Branch 0 taken 103 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 49 times.
✓ Branch 3 taken 54 times.
✓ Branch 4 taken 48 times.
✓ Branch 5 taken 1 times.
✓ Branch 6 taken 47 times.
✓ Branch 7 taken 1 times.
 103 if (!errno && !*end && !strchr(str, '-') && mask) {
417 47 av_channel_layout_from_mask(channel_layout, mask);
418 47 return 0;
419 }
420
421 56 errno = 0;
422 56 channels = strtol(str, &end, 10);
423
424 /* number of channels */
425
5/6
✓ Branch 0 taken 56 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 44 times.
✓ Branch 4 taken 11 times.
✓ Branch 5 taken 1 times.
 56 if (!errno && !strcmp(end, "c") && channels > 0) {
426 11 av_channel_layout_default(channel_layout, channels);
427
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 2 times.
 11 if (channel_layout->order == AV_CHANNEL_ORDER_NATIVE)
428 9 return 0;
429 }
430
431 /* number of unordered channels */
432
5/6
✓ Branch 0 taken 47 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
✓ Branch 3 taken 25 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 21 times.
 47 if (!errno && (!strcmp(end, "C") || !strcmp(end, " channels"))
433
1/2
✓ Branch 0 taken 26 times.
✗ Branch 1 not taken.
 26 && channels > 0) {
434 26 channel_layout->order = AV_CHANNEL_ORDER_UNSPEC;
435 26 channel_layout->nb_channels = channels;
436 26 return 0;
437 }
438
439 21 return AVERROR(EINVAL);
440 }
441
442 11708530 void av_channel_layout_uninit(AVChannelLayout *channel_layout)
443 {
444
2/2
✓ Branch 0 taken 1972 times.
✓ Branch 1 taken 11706558 times.
 11708530 if (channel_layout->order == AV_CHANNEL_ORDER_CUSTOM)
445 1972 av_freep(&channel_layout->u.map);
446 11708530 memset(channel_layout, 0, sizeof(*channel_layout));
447 11708530 }
448
449 2648127 int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
450 {
451 2648127 av_channel_layout_uninit(dst);
452 2648127 *dst = *src;
453
2/2
✓ Branch 0 taken 1691 times.
✓ Branch 1 taken 2646436 times.
 2648127 if (src->order == AV_CHANNEL_ORDER_CUSTOM) {
454 1691 dst->u.map = av_malloc_array(src->nb_channels, sizeof(*dst->u.map));
455
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1691 times.
 1691 if (!dst->u.map)
456 ✗ return AVERROR(ENOMEM);
457 1691 memcpy(dst->u.map, src->u.map, src->nb_channels * sizeof(*src->u.map));
458 }
459 2648127 return 0;
460 }
461
462 867 static int64_t masked_description(const AVChannelLayout *channel_layout, int start_channel)
463 {
464 867 uint64_t mask = 0;
465
2/2
✓ Branch 0 taken 1697 times.
✓ Branch 1 taken 266 times.
 1963 for (int i = start_channel; i < channel_layout->nb_channels; i++) {
466 1697 enum AVChannel ch = channel_layout->u.map[i].id;
467
5/6
✓ Branch 0 taken 1697 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1238 times.
✓ Branch 3 taken 459 times.
✓ Branch 4 taken 1096 times.
✓ Branch 5 taken 142 times.
 1697 if (ch >= 0 && ch < 63 && mask < (1ULL << ch))
468 1096 mask |= (1ULL << ch);
469 else
470 601 return AVERROR(EINVAL);
471 }
472 266 return mask;
473 }
474
475 840 static int has_channel_names(const AVChannelLayout *channel_layout)
476 {
477
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 840 times.
 840 if (channel_layout->order != AV_CHANNEL_ORDER_CUSTOM)
478 ✗ return 0;
479
2/2
✓ Branch 0 taken 1835 times.
✓ Branch 1 taken 821 times.
 2656 for (int i = 0; i < channel_layout->nb_channels; i++)
480
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 1816 times.
 1835 if (channel_layout->u.map[i].name[0])
481 19 return 1;
482 821 return 0;
483 }
484
485 615 int av_channel_layout_ambisonic_order(const AVChannelLayout *channel_layout)
486 {
487 int i, highest_ambi, order;
488
489
2/2
✓ Branch 0 taken 580 times.
✓ Branch 1 taken 35 times.
 615 if (channel_layout->order != AV_CHANNEL_ORDER_AMBISONIC &&
490
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 580 times.
 580 channel_layout->order != AV_CHANNEL_ORDER_CUSTOM)
491 ✗ return AVERROR(EINVAL);
492
493 615 highest_ambi = -1;
494
2/2
✓ Branch 0 taken 35 times.
✓ Branch 1 taken 580 times.
 615 if (channel_layout->order == AV_CHANNEL_ORDER_AMBISONIC)
495 35 highest_ambi = channel_layout->nb_channels - av_popcount64(channel_layout->u.mask) - 1;
496 else {
497 580 const AVChannelCustom *map = channel_layout->u.map;
498
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 580 times.
 580 av_assert0(channel_layout->order == AV_CHANNEL_ORDER_CUSTOM);
499
500
2/2
✓ Branch 0 taken 1268 times.
✓ Branch 1 taken 135 times.
 1403 for (i = 0; i < channel_layout->nb_channels; i++) {
501
3/4
✓ Branch 0 taken 511 times.
✓ Branch 1 taken 757 times.
✓ Branch 2 taken 511 times.
✗ Branch 3 not taken.
 1268 int is_ambi = CHAN_IS_AMBI(map[i].id);
502
503 /* ambisonic following non-ambisonic */
504
6/8
✓ Branch 0 taken 688 times.
✓ Branch 1 taken 580 times.
✓ Branch 2 taken 53 times.
✓ Branch 3 taken 635 times.
✓ Branch 4 taken 53 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 53 times.
 1268 if (i > 0 && is_ambi && !CHAN_IS_AMBI(map[i - 1].id))
505 ✗ return AVERROR(EINVAL);
506
507 /* non-default ordering */
508
4/4
✓ Branch 0 taken 511 times.
✓ Branch 1 taken 757 times.
✓ Branch 2 taken 445 times.
✓ Branch 3 taken 66 times.
 1268 if (is_ambi && map[i].id - AV_CHAN_AMBISONIC_BASE != i)
509 445 return AVERROR(EINVAL);
510
511
3/4
✓ Branch 0 taken 66 times.
✓ Branch 1 taken 757 times.
✓ Branch 2 taken 66 times.
✗ Branch 3 not taken.
 823 if (CHAN_IS_AMBI(map[i].id))
512 66 highest_ambi = i;
513 }
514 }
515 /* no ambisonic channels*/
516
2/2
✓ Branch 0 taken 122 times.
✓ Branch 1 taken 48 times.
 170 if (highest_ambi < 0)
517 122 return AVERROR(EINVAL);
518
519 48 order = floor(sqrt(highest_ambi));
520 /* incomplete order - some harmonics are missing */
521
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
 48 if ((order + 1) * (order + 1) != highest_ambi + 1)
522 ✗ return AVERROR(EINVAL);
523
524 48 return order;
525 }
526
527 318 static enum AVChannelOrder canonical_order(AVChannelLayout *channel_layout)
528 {
529 318 int has_known_channel = 0;
530 int order;
531
532
2/2
✓ Branch 0 taken 117 times.
✓ Branch 1 taken 201 times.
 318 if (channel_layout->order != AV_CHANNEL_ORDER_CUSTOM)
533 117 return channel_layout->order;
534
535
2/2
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 197 times.
 201 if (has_channel_names(channel_layout))
536 4 return AV_CHANNEL_ORDER_CUSTOM;
537
538
4/4
✓ Branch 0 taken 287 times.
✓ Branch 1 taken 108 times.
✓ Branch 2 taken 198 times.
✓ Branch 3 taken 89 times.
 395 for (int i = 0; i < channel_layout->nb_channels && !has_known_channel; i++)
539
2/2
✓ Branch 0 taken 197 times.
✓ Branch 1 taken 1 times.
 198 if (channel_layout->u.map[i].id != AV_CHAN_UNKNOWN)
540 197 has_known_channel = 1;
541
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 197 times.
 197 if (!has_known_channel)
542 ✗ return AV_CHANNEL_ORDER_UNSPEC;
543
544
2/2
✓ Branch 1 taken 116 times.
✓ Branch 2 taken 81 times.
 197 if (masked_description(channel_layout, 0) > 0)
545 116 return AV_CHANNEL_ORDER_NATIVE;
546
547 81 order = av_channel_layout_ambisonic_order(channel_layout);
548
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 80 times.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
 81 if (order >= 0 && masked_description(channel_layout, (order + 1) * (order + 1)) >= 0)
549 1 return AV_CHANNEL_ORDER_AMBISONIC;
550
551 80 return AV_CHANNEL_ORDER_CUSTOM;
552 }
553
554 /**
555 * If the custom layout is n-th order standard-order ambisonic, with optional
556 * extra non-diegetic channels at the end, write its string description in bp.
557 * Return a negative error code otherwise.
558 */
559 527 static int try_describe_ambisonic(AVBPrint *bp, const AVChannelLayout *channel_layout)
560 {
561 int nb_ambi_channels;
562 527 int order = av_channel_layout_ambisonic_order(channel_layout);
563
2/2
✓ Branch 0 taken 485 times.
✓ Branch 1 taken 42 times.
 527 if (order < 0)
564 485 return order;
565
566 42 av_bprintf(bp, "ambisonic %d", order);
567
568 /* extra channels present */
569 42 nb_ambi_channels = (order + 1) * (order + 1);
570
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 30 times.
 42 if (nb_ambi_channels < channel_layout->nb_channels) {
571 12 AVChannelLayout extra = { 0 };
572
573
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 7 times.
 12 if (channel_layout->order == AV_CHANNEL_ORDER_AMBISONIC) {
574 5 extra.order = AV_CHANNEL_ORDER_NATIVE;
575 5 extra.nb_channels = av_popcount64(channel_layout->u.mask);
576 5 extra.u.mask = channel_layout->u.mask;
577 } else {
578 int64_t mask;
579
4/4
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 3 times.
 11 if (!has_channel_names(channel_layout) &&
580 4 (mask = masked_description(channel_layout, nb_ambi_channels)) > 0) {
581 1 extra.order = AV_CHANNEL_ORDER_NATIVE;
582 1 extra.nb_channels = av_popcount64(mask);
583 1 extra.u.mask = mask;
584 } else {
585 6 extra.order = AV_CHANNEL_ORDER_CUSTOM;
586 6 extra.nb_channels = channel_layout->nb_channels - nb_ambi_channels;
587 6 extra.u.map = channel_layout->u.map + nb_ambi_channels;
588 }
589 }
590
591 12 av_bprint_chars(bp, '+', 1);
592 12 av_channel_layout_describe_bprint(&extra, bp);
593 /* Not calling uninit here on extra because we don't own the u.map pointer */
594 }
595
596 42 return 0;
597 }
598
599 17478 int av_channel_layout_describe_bprint(const AVChannelLayout *channel_layout,
600 AVBPrint *bp)
601 {
602 int i;
603
604
4/5
✓ Branch 0 taken 16802 times.
✓ Branch 1 taken 492 times.
✓ Branch 2 taken 149 times.
✓ Branch 3 taken 35 times.
✗ Branch 4 not taken.
 17478 switch (channel_layout->order) {
605 16802 case AV_CHANNEL_ORDER_NATIVE:
606
2/2
✓ Branch 0 taken 60151 times.
✓ Branch 1 taken 191 times.
 60342 for (i = 0; i < FF_ARRAY_ELEMS(channel_layout_map); i++)
607
2/2
✓ Branch 0 taken 16611 times.
✓ Branch 1 taken 43540 times.
 60151 if (channel_layout->u.mask == channel_layout_map[i].layout.u.mask) {
608 16611 av_bprintf(bp, "%s", channel_layout_map[i].name);
609 16611 return 0;
610 }
611 // fall-through
612 case AV_CHANNEL_ORDER_CUSTOM:
613
2/2
✓ Branch 0 taken 492 times.
✓ Branch 1 taken 191 times.
 683 if (channel_layout->order == AV_CHANNEL_ORDER_CUSTOM) {
614 int64_t mask;
615 492 int res = try_describe_ambisonic(bp, channel_layout);
616
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 485 times.
 492 if (res >= 0)
617 7 return 0;
618
4/4
✓ Branch 1 taken 474 times.
✓ Branch 2 taken 11 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 473 times.
 959 if (!has_channel_names(channel_layout) &&
619 474 (mask = masked_description(channel_layout, 0)) > 0) {
620 1 AVChannelLayout native = { .order = AV_CHANNEL_ORDER_NATIVE,
621 1 .nb_channels = av_popcount64(mask),
622 .u.mask = mask };
623 1 return av_channel_layout_describe_bprint(&native, bp);
624 }
625 }
626
1/2
✓ Branch 0 taken 675 times.
✗ Branch 1 not taken.
 675 if (channel_layout->nb_channels)
627 675 av_bprintf(bp, "%d channels (", channel_layout->nb_channels);
628
2/2
✓ Branch 0 taken 1696 times.
✓ Branch 1 taken 675 times.
 2371 for (i = 0; i < channel_layout->nb_channels; i++) {
629 1696 enum AVChannel ch = av_channel_layout_channel_from_index(channel_layout, i);
630
631
2/2
✓ Branch 0 taken 1021 times.
✓ Branch 1 taken 675 times.
 1696 if (i)
632 1021 av_bprintf(bp, "+");
633 1696 av_channel_name_bprint(bp, ch);
634
2/2
✓ Branch 0 taken 1061 times.
✓ Branch 1 taken 635 times.
 1696 if (channel_layout->order == AV_CHANNEL_ORDER_CUSTOM &&
635
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 1044 times.
 1061 channel_layout->u.map[i].name[0])
636 17 av_bprintf(bp, "@%s", channel_layout->u.map[i].name);
637 }
638
1/2
✓ Branch 0 taken 675 times.
✗ Branch 1 not taken.
 675 if (channel_layout->nb_channels) {
639 675 av_bprintf(bp, ")");
640 675 return 0;
641 }
642 // fall-through
643 case AV_CHANNEL_ORDER_UNSPEC:
644 149 av_bprintf(bp, "%d channels", channel_layout->nb_channels);
645 149 return 0;
646 35 case AV_CHANNEL_ORDER_AMBISONIC:
647 35 return try_describe_ambisonic(bp, channel_layout);
648 ✗ default:
649 ✗ return AVERROR(EINVAL);
650 }
651 }
652
653 11763 int av_channel_layout_describe(const AVChannelLayout *channel_layout,
654 char *buf, size_t buf_size)
655 {
656 AVBPrint bp;
657 int ret;
658
659
3/4
✓ Branch 0 taken 22 times.
✓ Branch 1 taken 11741 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 22 times.
 11763 if (!buf && buf_size)
660 ✗ return AVERROR(EINVAL);
661
662 11763 av_bprint_init_for_buffer(&bp, buf, buf_size);
663 11763 ret = av_channel_layout_describe_bprint(channel_layout, &bp);
664
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11763 times.
 11763 if (ret < 0)
665 ✗ return ret;
666
667
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11763 times.
 11763 if (bp.len >= INT_MAX)
668 ✗ return AVERROR(ERANGE);
669 11763 return bp.len + 1;
670 }
671
672 enum AVChannel
673 6812 av_channel_layout_channel_from_index(const AVChannelLayout *channel_layout,
674 unsigned int idx)
675 {
676 int i;
677
678
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 6809 times.
 6812 if (idx >= channel_layout->nb_channels)
679 3 return AV_CHAN_NONE;
680
681
4/4
✓ Branch 0 taken 5327 times.
✓ Branch 1 taken 344 times.
✓ Branch 2 taken 1136 times.
✓ Branch 3 taken 2 times.
 6809 switch (channel_layout->order) {
682 5327 case AV_CHANNEL_ORDER_CUSTOM:
683 5327 return channel_layout->u.map[idx].id;
684 344 case AV_CHANNEL_ORDER_AMBISONIC: {
685 344 int ambi_channels = channel_layout->nb_channels - av_popcount64(channel_layout->u.mask);
686
2/2
✓ Branch 0 taken 330 times.
✓ Branch 1 taken 14 times.
 344 if (idx < ambi_channels)
687 330 return AV_CHAN_AMBISONIC_BASE + idx;
688 14 idx -= ambi_channels;
689 }
690 // fall-through
691 1150 case AV_CHANNEL_ORDER_NATIVE:
692
1/2
✓ Branch 0 taken 6400 times.
✗ Branch 1 not taken.
 6400 for (i = 0; i < 64; i++) {
693
4/4
✓ Branch 0 taken 2989 times.
✓ Branch 1 taken 3411 times.
✓ Branch 2 taken 1150 times.
✓ Branch 3 taken 1839 times.
 6400 if ((1ULL << i) & channel_layout->u.mask && !idx--)
694 1150 return i;
695 }
696 default:
697 2 return AV_CHAN_NONE;
698 }
699 }
700
701 enum AVChannel
702 19 av_channel_layout_channel_from_string(const AVChannelLayout *channel_layout,
703 const char *str)
704 {
705 19 int index = av_channel_layout_index_from_string(channel_layout, str);
706
707
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 12 times.
 19 if (index < 0)
708 7 return AV_CHAN_NONE;
709
710 12 return av_channel_layout_channel_from_index(channel_layout, index);
711 }
712
713 14165 int av_channel_layout_index_from_channel(const AVChannelLayout *channel_layout,
714 enum AVChannel channel)
715 {
716 int i;
717
718
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14165 times.
 14165 if (channel == AV_CHAN_NONE)
719 ✗ return AVERROR(EINVAL);
720
721
3/3
✓ Branch 0 taken 2166 times.
✓ Branch 1 taken 11983 times.
✓ Branch 2 taken 16 times.
 14165 switch (channel_layout->order) {
722 2166 case AV_CHANNEL_ORDER_CUSTOM:
723
2/2
✓ Branch 0 taken 15021 times.
✓ Branch 1 taken 1887 times.
 16908 for (i = 0; i < channel_layout->nb_channels; i++)
724
2/2
✓ Branch 0 taken 279 times.
✓ Branch 1 taken 14742 times.
 15021 if (channel_layout->u.map[i].id == channel)
725 279 return i;
726 1887 return AVERROR(EINVAL);
727 11983 case AV_CHANNEL_ORDER_AMBISONIC:
728 case AV_CHANNEL_ORDER_NATIVE: {
729 11983 uint64_t mask = channel_layout->u.mask;
730 11983 int ambi_channels = channel_layout->nb_channels - av_popcount64(mask);
731
4/4
✓ Branch 0 taken 202 times.
✓ Branch 1 taken 11781 times.
✓ Branch 2 taken 193 times.
✓ Branch 3 taken 9 times.
 11983 if (channel_layout->order == AV_CHANNEL_ORDER_AMBISONIC &&
732 channel >= AV_CHAN_AMBISONIC_BASE) {
733
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 193 times.
 193 if (channel - AV_CHAN_AMBISONIC_BASE >= ambi_channels)
734 ✗ return AVERROR(EINVAL);
735 193 return channel - AV_CHAN_AMBISONIC_BASE;
736 }
737
3/4
✓ Branch 0 taken 11790 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6444 times.
✓ Branch 3 taken 5346 times.
 11790 if ((unsigned)channel > 63 || !(mask & (1ULL << channel)))
738 6444 return AVERROR(EINVAL);
739 5346 mask &= (1ULL << channel) - 1;
740 5346 return av_popcount64(mask) + ambi_channels;
741 }
742 16 default:
743 16 return AVERROR(EINVAL);
744 }
745 }
746
747 35 int av_channel_layout_index_from_string(const AVChannelLayout *channel_layout,
748 const char *str)
749 {
750 char *chname;
751 35 enum AVChannel ch = AV_CHAN_NONE;
752
753
2/3
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 17 times.
✗ Branch 2 not taken.
 35 switch (channel_layout->order) {
754 18 case AV_CHANNEL_ORDER_CUSTOM:
755 18 chname = strstr(str, "@");
756
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 10 times.
 18 if (chname) {
757 char buf[16];
758 8 chname++;
759 8 av_strlcpy(buf, str, FFMIN(sizeof(buf), chname - str));
760
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 if (!*chname)
761 ✗ chname = NULL;
762 8 ch = av_channel_from_string(buf);
763
3/4
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 8 if (ch == AV_CHAN_NONE && *buf)
764 ✗ return AVERROR(EINVAL);
765 }
766
4/4
✓ Branch 0 taken 22 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 20 times.
✓ Branch 3 taken 2 times.
 32 for (int i = 0; chname && i < channel_layout->nb_channels; i++) {
767
4/4
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 2 times.
 20 if (!strcmp(chname, channel_layout->u.map[i].name) &&
768
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 6 times.
 10 (ch == AV_CHAN_NONE || ch == channel_layout->u.map[i].id))
769 6 return i;
770 }
771 // fall-through
772 case AV_CHANNEL_ORDER_AMBISONIC:
773 case AV_CHANNEL_ORDER_NATIVE:
774 29 ch = av_channel_from_string(str);
775
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 22 times.
 29 if (ch == AV_CHAN_NONE)
776 7 return AVERROR(EINVAL);
777 22 return av_channel_layout_index_from_channel(channel_layout, ch);
778 }
779
780 ✗ return AVERROR(EINVAL);
781 }
782
783 347135 int av_channel_layout_check(const AVChannelLayout *channel_layout)
784 {
785
2/2
✓ Branch 0 taken 6702 times.
✓ Branch 1 taken 340433 times.
 347135 if (channel_layout->nb_channels <= 0)
786 6702 return 0;
787
788
4/5
✓ Branch 0 taken 301740 times.
✓ Branch 1 taken 619 times.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 38062 times.
✗ Branch 4 not taken.
 340433 switch (channel_layout->order) {
789 301740 case AV_CHANNEL_ORDER_NATIVE:
790 301740 return av_popcount64(channel_layout->u.mask) == channel_layout->nb_channels;
791 619 case AV_CHANNEL_ORDER_CUSTOM:
792
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 619 times.
 619 if (!channel_layout->u.map)
793 ✗ return 0;
794
2/2
✓ Branch 0 taken 1266 times.
✓ Branch 1 taken 619 times.
 1885 for (int i = 0; i < channel_layout->nb_channels; i++) {
795
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1266 times.
 1266 if (channel_layout->u.map[i].id == AV_CHAN_NONE)
796 ✗ return 0;
797 }
798 619 return 1;
799 12 case AV_CHANNEL_ORDER_AMBISONIC:
800 /* If non-diegetic channels are present, ensure they are taken into account */
801 12 return av_popcount64(channel_layout->u.mask) < channel_layout->nb_channels;
802 38062 case AV_CHANNEL_ORDER_UNSPEC:
803 38062 return 1;
804 ✗ default:
805 ✗ return 0;
806 }
807 }
808
809 1969598 int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
810 {
811 int i;
812
813 /* different channel counts -> not equal */
814
2/2
✓ Branch 0 taken 8528 times.
✓ Branch 1 taken 1961070 times.
 1969598 if (chl->nb_channels != chl1->nb_channels)
815 8528 return 1;
816
817 /* if only one is unspecified -> not equal */
818 1961070 if ((chl->order == AV_CHANNEL_ORDER_UNSPEC) !=
819
2/2
✓ Branch 0 taken 67 times.
✓ Branch 1 taken 1961003 times.
 1961070 (chl1->order == AV_CHANNEL_ORDER_UNSPEC))
820 67 return 1;
821 /* both are unspecified -> equal */
822
2/2
✓ Branch 0 taken 244729 times.
✓ Branch 1 taken 1716274 times.
 1961003 else if (chl->order == AV_CHANNEL_ORDER_UNSPEC)
823 244729 return 0;
824
825 /* can compare masks directly */
826
2/2
✓ Branch 0 taken 714 times.
✓ Branch 1 taken 1715560 times.
 1716274 if ((chl->order == AV_CHANNEL_ORDER_NATIVE ||
827
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 701 times.
 714 chl->order == AV_CHANNEL_ORDER_AMBISONIC) &&
828
1/2
✓ Branch 0 taken 1715573 times.
✗ Branch 1 not taken.
 1715573 chl->order == chl1->order)
829 1715573 return chl->u.mask != chl1->u.mask;
830
831 /* compare channel by channel */
832
2/2
✓ Branch 0 taken 2030 times.
✓ Branch 1 taken 698 times.
 2728 for (i = 0; i < chl->nb_channels; i++)
833
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 2027 times.
 4060 if (av_channel_layout_channel_from_index(chl, i) !=
834 2030 av_channel_layout_channel_from_index(chl1, i))
835 3 return 1;
836 698 return 0;
837 }
838
839 28060 void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
840 {
841 int i;
842
2/2
✓ Branch 0 taken 46626 times.
✓ Branch 1 taken 15 times.
 46641 for (i = 0; i < FF_ARRAY_ELEMS(channel_layout_map); i++)
843
2/2
✓ Branch 0 taken 28045 times.
✓ Branch 1 taken 18581 times.
 46626 if (nb_channels == channel_layout_map[i].layout.nb_channels) {
844 28045 *ch_layout = channel_layout_map[i].layout;
845 28045 return;
846 }
847
848 15 ch_layout->order = AV_CHANNEL_ORDER_UNSPEC;
849 15 ch_layout->nb_channels = nb_channels;
850 }
851
852 41 const AVChannelLayout *av_channel_layout_standard(void **opaque)
853 {
854 41 uintptr_t i = (uintptr_t)*opaque;
855 41 const AVChannelLayout *ch_layout = NULL;
856
857
2/2
✓ Branch 0 taken 40 times.
✓ Branch 1 taken 1 times.
 41 if (i < FF_ARRAY_ELEMS(channel_layout_map)) {
858 40 ch_layout = &channel_layout_map[i].layout;
859 40 *opaque = (void*)(i + 1);
860 }
861
862 41 return ch_layout;
863 }
864
865 2321 uint64_t av_channel_layout_subset(const AVChannelLayout *channel_layout,
866 uint64_t mask)
867 {
868 2321 uint64_t ret = 0;
869 int i;
870
871
3/3
✓ Branch 0 taken 1912 times.
✓ Branch 1 taken 41 times.
✓ Branch 2 taken 368 times.
 2321 switch (channel_layout->order) {
872 1912 case AV_CHANNEL_ORDER_NATIVE:
873 case AV_CHANNEL_ORDER_AMBISONIC:
874 1912 return channel_layout->u.mask & mask;
875 41 case AV_CHANNEL_ORDER_CUSTOM:
876
2/2
✓ Branch 0 taken 2624 times.
✓ Branch 1 taken 41 times.
 2665 for (i = 0; i < 64; i++)
877
4/4
✓ Branch 0 taken 2007 times.
✓ Branch 1 taken 617 times.
✓ Branch 3 taken 245 times.
✓ Branch 4 taken 1762 times.
 2624 if (mask & (1ULL << i) && av_channel_layout_index_from_channel(channel_layout, i) >= 0)
878 245 ret |= (1ULL << i);
879 41 break;
880 }
881
882 409 return ret;
883 }
884
885 410 int av_channel_layout_retype(AVChannelLayout *channel_layout, enum AVChannelOrder order, int flags)
886 {
887 410 int allow_lossy = !(flags & AV_CHANNEL_LAYOUT_RETYPE_FLAG_LOSSLESS);
888 int lossy;
889
890
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 410 times.
 410 if (!av_channel_layout_check(channel_layout))
891 ✗ return AVERROR(EINVAL);
892
893
2/2
✓ Branch 0 taken 318 times.
✓ Branch 1 taken 92 times.
 410 if (flags & AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL)
894 318 order = canonical_order(channel_layout);
895
896
2/2
✓ Branch 0 taken 206 times.
✓ Branch 1 taken 204 times.
 410 if (channel_layout->order == order)
897 206 return 0;
898
899
4/5
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 188 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 9 times.
✗ Branch 4 not taken.
 204 switch (order) {
900 4 case AV_CHANNEL_ORDER_UNSPEC: {
901 4 int nb_channels = channel_layout->nb_channels;
902
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
 4 if (channel_layout->order == AV_CHANNEL_ORDER_CUSTOM) {
903 2 lossy = 0;
904
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 for (int i = 0; i < nb_channels; i++) {
905
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 2 if (channel_layout->u.map[i].id != AV_CHAN_UNKNOWN || channel_layout->u.map[i].name[0]) {
906 2 lossy = 1;
907 2 break;
908 }
909 }
910 } else {
911 2 lossy = 1;
912 }
913
2/4
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
 4 if (!lossy || allow_lossy) {
914 4 void *opaque = channel_layout->opaque;
915 4 av_channel_layout_uninit(channel_layout);
916 4 channel_layout->order = AV_CHANNEL_ORDER_UNSPEC;
917 4 channel_layout->nb_channels = nb_channels;
918 4 channel_layout->opaque = opaque;
919 4 return lossy;
920 }
921 ✗ return AVERROR(ENOSYS);
922 }
923 188 case AV_CHANNEL_ORDER_NATIVE:
924
2/2
✓ Branch 0 taken 186 times.
✓ Branch 1 taken 2 times.
 188 if (channel_layout->order == AV_CHANNEL_ORDER_CUSTOM) {
925 186 int64_t mask = masked_description(channel_layout, 0);
926
2/2
✓ Branch 0 taken 44 times.
✓ Branch 1 taken 142 times.
 186 if (mask < 0)
927 44 return AVERROR(ENOSYS);
928 142 lossy = has_channel_names(channel_layout);
929
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 141 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 142 if (!lossy || allow_lossy) {
930 142 void *opaque = channel_layout->opaque;
931 142 av_channel_layout_uninit(channel_layout);
932 142 av_channel_layout_from_mask(channel_layout, mask);
933 142 channel_layout->opaque = opaque;
934 142 return lossy;
935 }
936 }
937 2 return AVERROR(ENOSYS);
938 3 case AV_CHANNEL_ORDER_CUSTOM: {
939 3 AVChannelLayout custom = { 0 };
940 3 int ret = av_channel_layout_custom_init(&custom, channel_layout->nb_channels);
941 3 void *opaque = channel_layout->opaque;
942
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 if (ret < 0)
943 ✗ return ret;
944
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
 3 if (channel_layout->order != AV_CHANNEL_ORDER_UNSPEC)
945
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 2 times.
 15 for (int i = 0; i < channel_layout->nb_channels; i++)
946 13 custom.u.map[i].id = av_channel_layout_channel_from_index(channel_layout, i);
947 3 av_channel_layout_uninit(channel_layout);
948 3 *channel_layout = custom;
949 3 channel_layout->opaque = opaque;
950 3 return 0;
951 }
952 9 case AV_CHANNEL_ORDER_AMBISONIC:
953
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 2 times.
 9 if (channel_layout->order == AV_CHANNEL_ORDER_CUSTOM) {
954 int64_t mask;
955 7 int nb_channels = channel_layout->nb_channels;
956 7 int amb_order = av_channel_layout_ambisonic_order(channel_layout);
957
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 5 times.
 7 if (amb_order < 0)
958 2 return AVERROR(ENOSYS);
959 5 mask = masked_description(channel_layout, (amb_order + 1) * (amb_order + 1));
960
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
 5 if (mask < 0)
961 ✗ return AVERROR(ENOSYS);
962 5 lossy = has_channel_names(channel_layout);
963
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 5 if (!lossy || allow_lossy) {
964 5 void *opaque = channel_layout->opaque;
965 5 av_channel_layout_uninit(channel_layout);
966 5 channel_layout->order = AV_CHANNEL_ORDER_AMBISONIC;
967 5 channel_layout->nb_channels = nb_channels;
968 5 channel_layout->u.mask = mask;
969 5 channel_layout->opaque = opaque;
970 5 return lossy;
971 }
972 }
973 2 return AVERROR(ENOSYS);
974 ✗ default:
975 ✗ return AVERROR(EINVAL);
976 }
977 }
978