FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavutil/channel_layout.c
Date: 2025-10-31 17:51:11
Exec Total Coverage
Lines: 481 531 90.6%
Functions: 28 28 100.0%
Branches: 353 434 81.3%
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 2344 void av_channel_name_bprint(AVBPrint *bp, enum AVChannel channel_id)
87 {
88
3/4
✓ Branch 0 taken 579 times.
✓ Branch 1 taken 1765 times.
✓ Branch 2 taken 579 times.
✗ Branch 3 not taken.
 2344 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 1748 times.
✓ Branch 1 taken 17 times.
 1765 else if ((unsigned)channel_id < FF_ARRAY_ELEMS(channel_names) &&
92
1/2
✓ Branch 0 taken 1748 times.
✗ Branch 1 not taken.
 1748 channel_names[channel_id].name)
93 1748 av_bprintf(bp, "%s", channel_names[channel_id].name);
94
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17 times.
 17 else if (channel_id == AV_CHAN_NONE)
95 ✗ av_bprintf(bp, "NONE");
96
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 12 times.
 17 else if (channel_id == AV_CHAN_UNKNOWN)
97 5 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 2344 }
103
104 437 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 432 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
 437 if (!buf && buf_size)
109 ✗ return AVERROR(EINVAL);
110
111 437 av_bprint_init_for_buffer(&bp, buf, buf_size);
112 437 av_channel_name_bprint(&bp, channel_id);
113
114
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 437 times.
 437 if (bp.len >= INT_MAX)
115 ✗ return AVERROR(ERANGE);
116 437 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 667 enum AVChannel av_channel_from_string(const char *str)
153 {
154 int i;
155 667 char *endptr = (char *)str;
156 667 enum AVChannel id = AV_CHAN_NONE;
157
158
2/2
✓ Branch 0 taken 260 times.
✓ Branch 1 taken 407 times.
 667 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 8613 times.
✓ Branch 1 taken 119 times.
 8732 for (i = 0; i < FF_ARRAY_ELEMS(channel_names); i++) {
166
4/4
✓ Branch 0 taken 5356 times.
✓ Branch 1 taken 3257 times.
✓ Branch 2 taken 288 times.
✓ Branch 3 taken 5068 times.
 8613 if (channel_names[i].name && !strcmp(str, channel_names[i].name))
167 288 return i;
168 }
169
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 118 times.
 119 if (!strcmp(str, "UNK"))
170 1 return AV_CHAN_UNKNOWN;
171
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 117 times.
 118 if (!strcmp(str, "UNSD"))
172 1 return AV_CHAN_UNUSED;
173
174
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 110 times.
 117 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 110 times.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
 117 if (id >= 0 && !*endptr)
179 7 return id;
180
181 110 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 118 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 118 times.
 118 if (nb_channels <= 0)
237 ✗ return AVERROR(EINVAL);
238
239 118 map = av_calloc(nb_channels, sizeof(*channel_layout->u.map));
240
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 118 times.
 118 if (!map)
241 ✗ return AVERROR(ENOMEM);
242
2/2
✓ Branch 0 taken 505 times.
✓ Branch 1 taken 118 times.
 623 for (int i = 0; i < nb_channels; i++)
243 505 map[i].id = AV_CHAN_UNKNOWN;
244
245 118 channel_layout->order = AV_CHANNEL_ORDER_CUSTOM;
246 118 channel_layout->nb_channels = nb_channels;
247 118 channel_layout->u.map = map;
248
249 118 return 0;
250 }
251
252 23955 int av_channel_layout_from_mask(AVChannelLayout *channel_layout,
253 uint64_t mask)
254 {
255
2/2
✓ Branch 0 taken 40 times.
✓ Branch 1 taken 23915 times.
 23955 if (!mask)
256 40 return AVERROR(EINVAL);
257
258 23915 channel_layout->order = AV_CHANNEL_ORDER_NATIVE;
259 23915 channel_layout->nb_channels = av_popcount64(mask);
260 23915 channel_layout->u.mask = mask;
261
262 23915 return 0;
263 }
264
265 174 static int parse_channel_list(AVChannelLayout *ch_layout, const char *str)
266 {
267 int ret;
268 174 int nb_channels = 0;
269 174 AVChannelCustom *map = NULL;
270 174 AVChannelCustom custom = {0};
271
272
2/2
✓ Branch 0 taken 316 times.
✓ Branch 1 taken 77 times.
 393 while (*str) {
273 char *channel, *chname;
274 316 int ret = av_opt_get_key_value(&str, "@", "+", AV_OPT_FLAG_IMPLICIT_KEY, &channel, &chname);
275
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 316 times.
 316 if (ret < 0) {
276 ✗ av_freep(&map);
277 97 return ret;
278 }
279
2/2
✓ Branch 0 taken 144 times.
✓ Branch 1 taken 172 times.
 316 if (*str)
280 144 str++; // skip separator
281
2/2
✓ Branch 0 taken 302 times.
✓ Branch 1 taken 14 times.
 316 if (!channel) {
282 302 channel = chname;
283 302 chname = NULL;
284 }
285
2/2
✓ Branch 0 taken 14 times.
✓ Branch 1 taken 302 times.
 316 av_strlcpy(custom.name, chname ? chname : "", sizeof(custom.name));
286 316 custom.id = av_channel_from_string(channel);
287 316 av_free(channel);
288 316 av_free(chname);
289
2/2
✓ Branch 0 taken 97 times.
✓ Branch 1 taken 219 times.
 316 if (custom.id == AV_CHAN_NONE) {
290 97 av_freep(&map);
291 97 return AVERROR(EINVAL);
292 }
293
294 219 av_dynarray2_add((void **)&map, &nb_channels, sizeof(custom), (void *)&custom);
295
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 219 times.
 219 if (!map)
296 ✗ return AVERROR(ENOMEM);
297 }
298
299
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 76 times.
 77 if (!nb_channels)
300 1 return AVERROR(EINVAL);
301
302 76 ch_layout->order = AV_CHANNEL_ORDER_CUSTOM;
303 76 ch_layout->u.map = map;
304 76 ch_layout->nb_channels = nb_channels;
305
306 76 ret = av_channel_layout_retype(ch_layout, 0, AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL);
307
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 76 times.
 76 av_assert0(ret == 0);
308
309 76 return 0;
310 }
311
312 2121 int av_channel_layout_from_string(AVChannelLayout *channel_layout,
313 const char *str)
314 {
315 int i, matches, ret;
316 2121 int channels = 0, nb_channels = 0;
317 char *chlist, *end;
318 2121 uint64_t mask = 0;
319
320 /* channel layout names */
321
2/2
✓ Branch 0 taken 16090 times.
✓ Branch 1 taken 187 times.
 16277 for (i = 0; i < FF_ARRAY_ELEMS(channel_layout_map); i++) {
322
3/4
✓ Branch 0 taken 16090 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1934 times.
✓ Branch 3 taken 14156 times.
 16090 if (channel_layout_map[i].name && !strcmp(str, channel_layout_map[i].name)) {
323 1934 *channel_layout = channel_layout_map[i].layout;
324 1934 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 187 memset(channel_layout, 0, sizeof(*channel_layout));
331
332 /* ambisonic */
333
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 174 times.
 187 if (!strncmp(str, "ambisonic ", 10)) {
334 13 const char *p = str + 10;
335 char *endptr;
336 13 AVChannelLayout extra = {0};
337 int order;
338
339 13 order = strtol(p, &endptr, 0);
340
2/4
✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✗ Branch 3 not taken.
 13 if (order < 0 || order + 1 > INT_MAX / (order + 1) ||
341
3/4
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 10 times.
 13 (*endptr && *endptr != '+'))
342 ✗ return AVERROR(EINVAL);
343
344 13 channel_layout->order = AV_CHANNEL_ORDER_AMBISONIC;
345 13 channel_layout->nb_channels = (order + 1) * (order + 1);
346
347
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 3 times.
 13 if (*endptr) {
348 10 int 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 13 return 0;
390 }
391
392 174 chlist = av_strdup(str);
393
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 174 times.
 174 if (!chlist)
394 ✗ return AVERROR(ENOMEM);
395
396 /* channel names */
397 174 matches = av_sscanf(str, "%d channels (%[^)]", &nb_channels, chlist);
398 174 ret = parse_channel_list(channel_layout, chlist);
399 174 av_freep(&chlist);
400
3/4
✓ Branch 0 taken 98 times.
✓ Branch 1 taken 76 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 98 times.
 174 if (ret < 0 && ret != AVERROR(EINVAL))
401 ✗ return ret;
402
403
2/2
✓ Branch 0 taken 76 times.
✓ Branch 1 taken 98 times.
 174 if (ret >= 0) {
404 76 end = strchr(str, ')');
405
7/8
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 40 times.
✓ Branch 2 taken 34 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 33 times.
✓ Branch 5 taken 1 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 33 times.
 76 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 73 return 0;
410 }
411
412 98 errno = 0;
413 98 mask = strtoull(str, &end, 0);
414
415 /* channel layout mask */
416
7/8
✓ Branch 0 taken 98 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 45 times.
✓ Branch 3 taken 53 times.
✓ Branch 4 taken 44 times.
✓ Branch 5 taken 1 times.
✓ Branch 6 taken 43 times.
✓ Branch 7 taken 1 times.
 98 if (!errno && !*end && !strchr(str, '-') && mask) {
417 43 av_channel_layout_from_mask(channel_layout, mask);
418 43 return 0;
419 }
420
421 55 errno = 0;
422 55 channels = strtol(str, &end, 10);
423
424 /* number of channels */
425
5/6
✓ Branch 0 taken 55 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 43 times.
✓ Branch 4 taken 11 times.
✓ Branch 5 taken 1 times.
 55 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 46 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 22 times.
✓ Branch 3 taken 24 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 21 times.
 46 if (!errno && (!strcmp(end, "C") || !strcmp(end, " channels"))
433
1/2
✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
 25 && channels > 0) {
434 25 channel_layout->order = AV_CHANNEL_ORDER_UNSPEC;
435 25 channel_layout->nb_channels = channels;
436 25 return 0;
437 }
438
439 21 return AVERROR(EINVAL);
440 }
441
442 10611259 void av_channel_layout_uninit(AVChannelLayout *channel_layout)
443 {
444
2/2
✓ Branch 0 taken 1767 times.
✓ Branch 1 taken 10609492 times.
 10611259 if (channel_layout->order == AV_CHANNEL_ORDER_CUSTOM)
445 1767 av_freep(&channel_layout->u.map);
446 10611259 memset(channel_layout, 0, sizeof(*channel_layout));
447 10611259 }
448
449 2424355 int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
450 {
451 2424355 av_channel_layout_uninit(dst);
452 2424355 *dst = *src;
453
2/2
✓ Branch 0 taken 1503 times.
✓ Branch 1 taken 2422852 times.
 2424355 if (src->order == AV_CHANNEL_ORDER_CUSTOM) {
454 1503 dst->u.map = av_malloc_array(src->nb_channels, sizeof(*dst->u.map));
455
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1503 times.
 1503 if (!dst->u.map)
456 ✗ return AVERROR(ENOMEM);
457 1503 memcpy(dst->u.map, src->u.map, src->nb_channels * sizeof(*src->u.map));
458 }
459 2424355 return 0;
460 }
461
462 839 static int64_t masked_description(const AVChannelLayout *channel_layout, int start_channel)
463 {
464 839 uint64_t mask = 0;
465
2/2
✓ Branch 0 taken 1611 times.
✓ Branch 1 taken 254 times.
 1865 for (int i = start_channel; i < channel_layout->nb_channels; i++) {
466 1611 enum AVChannel ch = channel_layout->u.map[i].id;
467
5/6
✓ Branch 0 taken 1611 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1156 times.
✓ Branch 3 taken 455 times.
✓ Branch 4 taken 1026 times.
✓ Branch 5 taken 130 times.
 1611 if (ch >= 0 && ch < 63 && mask < (1ULL << ch))
468 1026 mask |= (1ULL << ch);
469 else
470 585 return AVERROR(EINVAL);
471 }
472 254 return mask;
473 }
474
475 818 static int has_channel_names(const AVChannelLayout *channel_layout)
476 {
477
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 818 times.
 818 if (channel_layout->order != AV_CHANNEL_ORDER_CUSTOM)
478 ✗ return 0;
479
2/2
✓ Branch 0 taken 1741 times.
✓ Branch 1 taken 799 times.
 2540 for (int i = 0; i < channel_layout->nb_channels; i++)
480
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 1722 times.
 1741 if (channel_layout->u.map[i].name[0])
481 19 return 1;
482 799 return 0;
483 }
484
485 592 int av_channel_layout_ambisonic_order(const AVChannelLayout *channel_layout)
486 {
487 int i, highest_ambi, order;
488
489
2/2
✓ Branch 0 taken 570 times.
✓ Branch 1 taken 22 times.
 592 if (channel_layout->order != AV_CHANNEL_ORDER_AMBISONIC &&
490
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 570 times.
 570 channel_layout->order != AV_CHANNEL_ORDER_CUSTOM)
491 ✗ return AVERROR(EINVAL);
492
493 592 highest_ambi = -1;
494
2/2
✓ Branch 0 taken 22 times.
✓ Branch 1 taken 570 times.
 592 if (channel_layout->order == AV_CHANNEL_ORDER_AMBISONIC)
495 22 highest_ambi = channel_layout->nb_channels - av_popcount64(channel_layout->u.mask) - 1;
496 else {
497 570 const AVChannelCustom *map = channel_layout->u.map;
498
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 570 times.
 570 av_assert0(channel_layout->order == AV_CHANNEL_ORDER_CUSTOM);
499
500
2/2
✓ Branch 0 taken 1188 times.
✓ Branch 1 taken 125 times.
 1313 for (i = 0; i < channel_layout->nb_channels; i++) {
501
3/4
✓ Branch 0 taken 511 times.
✓ Branch 1 taken 677 times.
✓ Branch 2 taken 511 times.
✗ Branch 3 not taken.
 1188 int is_ambi = CHAN_IS_AMBI(map[i].id);
502
503 /* ambisonic following non-ambisonic */
504
6/8
✓ Branch 0 taken 618 times.
✓ Branch 1 taken 570 times.
✓ Branch 2 taken 53 times.
✓ Branch 3 taken 565 times.
✓ Branch 4 taken 53 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 53 times.
 1188 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 677 times.
✓ Branch 2 taken 445 times.
✓ Branch 3 taken 66 times.
 1188 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 677 times.
✓ Branch 2 taken 66 times.
✗ Branch 3 not taken.
 743 if (CHAN_IS_AMBI(map[i].id))
512 66 highest_ambi = i;
513 }
514 }
515 /* no ambisonic channels*/
516
2/2
✓ Branch 0 taken 112 times.
✓ Branch 1 taken 35 times.
 147 if (highest_ambi < 0)
517 112 return AVERROR(EINVAL);
518
519 35 order = floor(sqrt(highest_ambi));
520 /* incomplete order - some harmonics are missing */
521
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 35 times.
 35 if ((order + 1) * (order + 1) != highest_ambi + 1)
522 ✗ return AVERROR(EINVAL);
523
524 35 return order;
525 }
526
527 312 static enum AVChannelOrder canonical_order(AVChannelLayout *channel_layout)
528 {
529 312 int has_known_channel = 0;
530 int order;
531
532
2/2
✓ Branch 0 taken 117 times.
✓ Branch 1 taken 195 times.
 312 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 191 times.
 195 if (has_channel_names(channel_layout))
536 4 return AV_CHANNEL_ORDER_CUSTOM;
537
538
4/4
✓ Branch 0 taken 280 times.
✓ Branch 1 taken 103 times.
✓ Branch 2 taken 192 times.
✓ Branch 3 taken 88 times.
 383 for (int i = 0; i < channel_layout->nb_channels && !has_known_channel; i++)
539
2/2
✓ Branch 0 taken 191 times.
✓ Branch 1 taken 1 times.
 192 if (channel_layout->u.map[i].id != AV_CHAN_UNKNOWN)
540 191 has_known_channel = 1;
541
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 191 times.
 191 if (!has_known_channel)
542 ✗ return AV_CHANNEL_ORDER_UNSPEC;
543
544
2/2
✓ Branch 1 taken 111 times.
✓ Branch 2 taken 80 times.
 191 if (masked_description(channel_layout, 0) > 0)
545 111 return AV_CHANNEL_ORDER_NATIVE;
546
547 80 order = av_channel_layout_ambisonic_order(channel_layout);
548
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 79 times.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
 80 if (order >= 0 && masked_description(channel_layout, (order + 1) * (order + 1)) >= 0)
549 1 return AV_CHANNEL_ORDER_AMBISONIC;
550
551 79 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 505 static int try_describe_ambisonic(AVBPrint *bp, const AVChannelLayout *channel_layout)
560 {
561 int nb_ambi_channels;
562 505 int order = av_channel_layout_ambisonic_order(channel_layout);
563
2/2
✓ Branch 0 taken 476 times.
✓ Branch 1 taken 29 times.
 505 if (order < 0)
564 476 return order;
565
566 29 av_bprintf(bp, "ambisonic %d", order);
567
568 /* extra channels present */
569 29 nb_ambi_channels = (order + 1) * (order + 1);
570
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 17 times.
 29 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 29 return 0;
597 }
598
599 16914 int av_channel_layout_describe_bprint(const AVChannelLayout *channel_layout,
600 AVBPrint *bp)
601 {
602 int i;
603
604
4/5
✓ Branch 0 taken 16290 times.
✓ Branch 1 taken 483 times.
✓ Branch 2 taken 119 times.
✓ Branch 3 taken 22 times.
✗ Branch 4 not taken.
 16914 switch (channel_layout->order) {
605 16290 case AV_CHANNEL_ORDER_NATIVE:
606
2/2
✓ Branch 0 taken 56849 times.
✓ Branch 1 taken 183 times.
 57032 for (i = 0; i < FF_ARRAY_ELEMS(channel_layout_map); i++)
607
2/2
✓ Branch 0 taken 16107 times.
✓ Branch 1 taken 40742 times.
 56849 if (channel_layout->u.mask == channel_layout_map[i].layout.u.mask) {
608 16107 av_bprintf(bp, "%s", channel_layout_map[i].name);
609 16107 return 0;
610 }
611 // fall-through
612 case AV_CHANNEL_ORDER_CUSTOM:
613
2/2
✓ Branch 0 taken 483 times.
✓ Branch 1 taken 183 times.
 666 if (channel_layout->order == AV_CHANNEL_ORDER_CUSTOM) {
614 int64_t mask;
615 483 int res = try_describe_ambisonic(bp, channel_layout);
616
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 476 times.
 483 if (res >= 0)
617 7 return 0;
618
4/4
✓ Branch 1 taken 465 times.
✓ Branch 2 taken 11 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 464 times.
 941 if (!has_channel_names(channel_layout) &&
619 465 (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 658 times.
✗ Branch 1 not taken.
 658 if (channel_layout->nb_channels)
627 658 av_bprintf(bp, "%d channels (", channel_layout->nb_channels);
628
2/2
✓ Branch 0 taken 1614 times.
✓ Branch 1 taken 658 times.
 2272 for (i = 0; i < channel_layout->nb_channels; i++) {
629 1614 enum AVChannel ch = av_channel_layout_channel_from_index(channel_layout, i);
630
631
2/2
✓ Branch 0 taken 956 times.
✓ Branch 1 taken 658 times.
 1614 if (i)
632 956 av_bprintf(bp, "+");
633 1614 av_channel_name_bprint(bp, ch);
634
2/2
✓ Branch 0 taken 987 times.
✓ Branch 1 taken 627 times.
 1614 if (channel_layout->order == AV_CHANNEL_ORDER_CUSTOM &&
635
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 970 times.
 987 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 658 times.
✗ Branch 1 not taken.
 658 if (channel_layout->nb_channels) {
639 658 av_bprintf(bp, ")");
640 658 return 0;
641 }
642 // fall-through
643 case AV_CHANNEL_ORDER_UNSPEC:
644 119 av_bprintf(bp, "%d channels", channel_layout->nb_channels);
645 119 return 0;
646 22 case AV_CHANNEL_ORDER_AMBISONIC:
647 22 return try_describe_ambisonic(bp, channel_layout);
648 ✗ default:
649 ✗ return AVERROR(EINVAL);
650 }
651 }
652
653 11508 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 11486 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 22 times.
 11508 if (!buf && buf_size)
660 ✗ return AVERROR(EINVAL);
661
662 11508 av_bprint_init_for_buffer(&bp, buf, buf_size);
663 11508 ret = av_channel_layout_describe_bprint(channel_layout, &bp);
664
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11508 times.
 11508 if (ret < 0)
665 ✗ return ret;
666
667
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11508 times.
 11508 if (bp.len >= INT_MAX)
668 ✗ return AVERROR(ERANGE);
669 11508 return bp.len + 1;
670 }
671
672 enum AVChannel
673 5200 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 5197 times.
 5200 if (idx >= channel_layout->nb_channels)
679 3 return AV_CHAN_NONE;
680
681
3/4
✓ Branch 0 taken 3781 times.
✓ Branch 1 taken 344 times.
✓ Branch 2 taken 1072 times.
✗ Branch 3 not taken.
 5197 switch (channel_layout->order) {
682 3781 case AV_CHANNEL_ORDER_CUSTOM:
683 3781 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 1086 case AV_CHANNEL_ORDER_NATIVE:
692
1/2
✓ Branch 0 taken 6201 times.
✗ Branch 1 not taken.
 6201 for (i = 0; i < 64; i++) {
693
4/4
✓ Branch 0 taken 2817 times.
✓ Branch 1 taken 3384 times.
✓ Branch 2 taken 1086 times.
✓ Branch 3 taken 1731 times.
 6201 if ((1ULL << i) & channel_layout->u.mask && !idx--)
694 1086 return i;
695 }
696 default:
697 ✗ 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 13278 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 13278 times.
 13278 if (channel == AV_CHAN_NONE)
719 ✗ return AVERROR(EINVAL);
720
721
3/3
✓ Branch 0 taken 1910 times.
✓ Branch 1 taken 11352 times.
✓ Branch 2 taken 16 times.
 13278 switch (channel_layout->order) {
722 1910 case AV_CHANNEL_ORDER_CUSTOM:
723
2/2
✓ Branch 0 taken 13093 times.
✓ Branch 1 taken 1663 times.
 14756 for (i = 0; i < channel_layout->nb_channels; i++)
724
2/2
✓ Branch 0 taken 247 times.
✓ Branch 1 taken 12846 times.
 13093 if (channel_layout->u.map[i].id == channel)
725 247 return i;
726 1663 return AVERROR(EINVAL);
727 11352 case AV_CHANNEL_ORDER_AMBISONIC:
728 case AV_CHANNEL_ORDER_NATIVE: {
729 11352 uint64_t mask = channel_layout->u.mask;
730 11352 int ambi_channels = channel_layout->nb_channels - av_popcount64(mask);
731
4/4
✓ Branch 0 taken 202 times.
✓ Branch 1 taken 11150 times.
✓ Branch 2 taken 193 times.
✓ Branch 3 taken 9 times.
 11352 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 11159 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5908 times.
✓ Branch 3 taken 5251 times.
 11159 if ((unsigned)channel > 63 || !(mask & (1ULL << channel)))
738 5908 return AVERROR(EINVAL);
739 5251 mask &= (1ULL << channel) - 1;
740 5251 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 306387 int av_channel_layout_check(const AVChannelLayout *channel_layout)
784 {
785
2/2
✓ Branch 0 taken 6585 times.
✓ Branch 1 taken 299802 times.
 306387 if (channel_layout->nb_channels <= 0)
786 6585 return 0;
787
788
4/5
✓ Branch 0 taken 294656 times.
✓ Branch 1 taken 476 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 4660 times.
✗ Branch 4 not taken.
 299802 switch (channel_layout->order) {
789 294656 case AV_CHANNEL_ORDER_NATIVE:
790 294656 return av_popcount64(channel_layout->u.mask) == channel_layout->nb_channels;
791 476 case AV_CHANNEL_ORDER_CUSTOM:
792
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 476 times.
 476 if (!channel_layout->u.map)
793 ✗ return 0;
794
2/2
✓ Branch 0 taken 1052 times.
✓ Branch 1 taken 476 times.
 1528 for (int i = 0; i < channel_layout->nb_channels; i++) {
795
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1052 times.
 1052 if (channel_layout->u.map[i].id == AV_CHAN_NONE)
796 ✗ return 0;
797 }
798 476 return 1;
799 10 case AV_CHANNEL_ORDER_AMBISONIC:
800 /* If non-diegetic channels are present, ensure they are taken into account */
801 10 return av_popcount64(channel_layout->u.mask) < channel_layout->nb_channels;
802 4660 case AV_CHANNEL_ORDER_UNSPEC:
803 4660 return 1;
804 ✗ default:
805 ✗ return 0;
806 }
807 }
808
809 1719054 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 7835 times.
✓ Branch 1 taken 1711219 times.
 1719054 if (chl->nb_channels != chl1->nb_channels)
815 7835 return 1;
816
817 /* if only one is unspecified -> not equal */
818 1711219 if ((chl->order == AV_CHANNEL_ORDER_UNSPEC) !=
819
2/2
✓ Branch 0 taken 67 times.
✓ Branch 1 taken 1711152 times.
 1711219 (chl1->order == AV_CHANNEL_ORDER_UNSPEC))
820 67 return 1;
821 /* both are unspecified -> equal */
822
2/2
✓ Branch 0 taken 12133 times.
✓ Branch 1 taken 1699019 times.
 1711152 else if (chl->order == AV_CHANNEL_ORDER_UNSPEC)
823 12133 return 0;
824
825 /* can compare masks directly */
826
2/2
✓ Branch 0 taken 594 times.
✓ Branch 1 taken 1698425 times.
 1699019 if ((chl->order == AV_CHANNEL_ORDER_NATIVE ||
827
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 581 times.
 594 chl->order == AV_CHANNEL_ORDER_AMBISONIC) &&
828
1/2
✓ Branch 0 taken 1698438 times.
✗ Branch 1 not taken.
 1698438 chl->order == chl1->order)
829 1698438 return chl->u.mask != chl1->u.mask;
830
831 /* compare channel by channel */
832
2/2
✓ Branch 0 taken 1310 times.
✓ Branch 1 taken 578 times.
 1888 for (i = 0; i < chl->nb_channels; i++)
833
2/2
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 1307 times.
 2620 if (av_channel_layout_channel_from_index(chl, i) !=
834 1310 av_channel_layout_channel_from_index(chl1, i))
835 3 return 1;
836 578 return 0;
837 }
838
839 27639 void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
840 {
841 int i;
842
2/2
✓ Branch 0 taken 46061 times.
✓ Branch 1 taken 15 times.
 46076 for (i = 0; i < FF_ARRAY_ELEMS(channel_layout_map); i++)
843
2/2
✓ Branch 0 taken 27624 times.
✓ Branch 1 taken 18437 times.
 46061 if (nb_channels == channel_layout_map[i].layout.nb_channels) {
844 27624 *ch_layout = channel_layout_map[i].layout;
845 27624 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 2297 uint64_t av_channel_layout_subset(const AVChannelLayout *channel_layout,
866 uint64_t mask)
867 {
868 2297 uint64_t ret = 0;
869 int i;
870
871
3/3
✓ Branch 0 taken 1892 times.
✓ Branch 1 taken 37 times.
✓ Branch 2 taken 368 times.
 2297 switch (channel_layout->order) {
872 1892 case AV_CHANNEL_ORDER_NATIVE:
873 case AV_CHANNEL_ORDER_AMBISONIC:
874 1892 return channel_layout->u.mask & mask;
875 37 case AV_CHANNEL_ORDER_CUSTOM:
876
2/2
✓ Branch 0 taken 2368 times.
✓ Branch 1 taken 37 times.
 2405 for (i = 0; i < 64; i++)
877
4/4
✓ Branch 0 taken 1751 times.
✓ Branch 1 taken 617 times.
✓ Branch 3 taken 213 times.
✓ Branch 4 taken 1538 times.
 2368 if (mask & (1ULL << i) && av_channel_layout_index_from_channel(channel_layout, i) >= 0)
878 213 ret |= (1ULL << i);
879 37 break;
880 }
881
882 405 return ret;
883 }
884
885 396 int av_channel_layout_retype(AVChannelLayout *channel_layout, enum AVChannelOrder order, int flags)
886 {
887 396 int allow_lossy = !(flags & AV_CHANNEL_LAYOUT_RETYPE_FLAG_LOSSLESS);
888 int lossy;
889
890
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 396 times.
 396 if (!av_channel_layout_check(channel_layout))
891 ✗ return AVERROR(EINVAL);
892
893
2/2
✓ Branch 0 taken 312 times.
✓ Branch 1 taken 84 times.
 396 if (flags & AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL)
894 312 order = canonical_order(channel_layout);
895
896
2/2
✓ Branch 0 taken 205 times.
✓ Branch 1 taken 191 times.
 396 if (channel_layout->order == order)
897 205 return 0;
898
899
4/5
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 175 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 9 times.
✗ Branch 4 not taken.
 191 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 175 case AV_CHANNEL_ORDER_NATIVE:
924
2/2
✓ Branch 0 taken 173 times.
✓ Branch 1 taken 2 times.
 175 if (channel_layout->order == AV_CHANNEL_ORDER_CUSTOM) {
925 173 int64_t mask = masked_description(channel_layout, 0);
926
2/2
✓ Branch 0 taken 38 times.
✓ Branch 1 taken 135 times.
 173 if (mask < 0)
927 38 return AVERROR(ENOSYS);
928 135 lossy = has_channel_names(channel_layout);
929
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 134 times.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 135 if (!lossy || allow_lossy) {
930 135 void *opaque = channel_layout->opaque;
931 135 av_channel_layout_uninit(channel_layout);
932 135 av_channel_layout_from_mask(channel_layout, mask);
933 135 channel_layout->opaque = opaque;
934 135 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 order = av_channel_layout_ambisonic_order(channel_layout);
957
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 5 times.
 7 if (order < 0)
958 2 return AVERROR(ENOSYS);
959 5 mask = masked_description(channel_layout, (order + 1) * (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