FFmpeg
iamf.c
Go to the documentation of this file.
1 /*
2  * Immersive Audio Model and Formats helper functions and defines
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 #include <limits.h>
22 #include <stddef.h>
23 #include <stdint.h>
24 
25 #include "avassert.h"
26 #include "error.h"
27 #include "iamf.h"
28 #include "log.h"
29 #include "mem.h"
30 #include "opt.h"
31 
32 #define IAMF_ADD_FUNC_TEMPLATE(parent_type, parent_name, child_type, child_name, suffix) \
33 child_type *av_iamf_ ## parent_name ## _add_ ## child_name(parent_type *parent_name) \
34 { \
35  child_type **child_name ## suffix, *child_name; \
36  \
37  if (parent_name->nb_## child_name ## suffix == UINT_MAX) \
38  return NULL; \
39  \
40  child_name ## suffix = av_realloc_array(parent_name->child_name ## suffix, \
41  parent_name->nb_## child_name ## suffix + 1, \
42  sizeof(*parent_name->child_name ## suffix)); \
43  if (!child_name ## suffix) \
44  return NULL; \
45  \
46  parent_name->child_name ## suffix = child_name ## suffix; \
47  \
48  child_name = parent_name->child_name ## suffix[parent_name->nb_## child_name ## suffix] \
49  = av_mallocz(sizeof(*child_name)); \
50  if (!child_name) \
51  return NULL; \
52  \
53  child_name->av_class = &child_name ## _class; \
54  av_opt_set_defaults(child_name); \
55  parent_name->nb_## child_name ## suffix++; \
56  \
57  return child_name; \
58 }
59 
60 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM
61 
62 //
63 // Param Definition
64 //
65 #define OFFSET(x) offsetof(AVIAMFMixGain, x)
66 static const AVOption mix_gain_options[] = {
67  { "subblock_duration", "set subblock_duration", OFFSET(subblock_duration), AV_OPT_TYPE_INT, {.i64 = 1 }, 1, UINT_MAX, FLAGS },
68  { "animation_type", "set animation_type", OFFSET(animation_type), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, FLAGS },
69  { "start_point_value", "set start_point_value", OFFSET(animation_type), AV_OPT_TYPE_RATIONAL, {.dbl = 0 }, -128.0, 128.0, FLAGS },
70  { "end_point_value", "set end_point_value", OFFSET(animation_type), AV_OPT_TYPE_RATIONAL, {.dbl = 0 }, -128.0, 128.0, FLAGS },
71  { "control_point_value", "set control_point_value", OFFSET(animation_type), AV_OPT_TYPE_RATIONAL, {.dbl = 0 }, -128.0, 128.0, FLAGS },
72  { "control_point_relative_time", "set control_point_relative_time", OFFSET(animation_type), AV_OPT_TYPE_RATIONAL, {.dbl = 0 }, 0.0, 1.0, FLAGS },
73  { NULL },
74 };
75 
76 static const AVClass mix_gain_class = {
77  .class_name = "AVIAMFSubmixElement",
78  .item_name = av_default_item_name,
79  .version = LIBAVUTIL_VERSION_INT,
80  .option = mix_gain_options,
81 };
82 
83 #undef OFFSET
84 #define OFFSET(x) offsetof(AVIAMFDemixingInfo, x)
85 static const AVOption demixing_info_options[] = {
86  { "subblock_duration", "set subblock_duration", OFFSET(subblock_duration), AV_OPT_TYPE_INT, {.i64 = 1 }, 1, UINT_MAX, FLAGS },
87  { "dmixp_mode", "set dmixp_mode", OFFSET(dmixp_mode), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 6, FLAGS },
88  { NULL },
89 };
90 
91 static const AVClass demixing_info_class = {
92  .class_name = "AVIAMFDemixingInfo",
93  .item_name = av_default_item_name,
94  .version = LIBAVUTIL_VERSION_INT,
95  .option = demixing_info_options,
96 };
97 
98 #undef OFFSET
99 #define OFFSET(x) offsetof(AVIAMFReconGain, x)
100 static const AVOption recon_gain_options[] = {
101  { "subblock_duration", "set subblock_duration", OFFSET(subblock_duration), AV_OPT_TYPE_INT, {.i64 = 1 }, 1, UINT_MAX, FLAGS },
102  { NULL },
103 };
104 
105 static const AVClass recon_gain_class = {
106  .class_name = "AVIAMFReconGain",
107  .item_name = av_default_item_name,
108  .version = LIBAVUTIL_VERSION_INT,
109  .option = recon_gain_options,
110 };
111 
112 #undef OFFSET
113 #define OFFSET(x) offsetof(AVIAMFParamDefinition, x)
115  { "parameter_id", "set parameter_id", OFFSET(parameter_id), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, UINT_MAX, FLAGS },
116  { "parameter_rate", "set parameter_rate", OFFSET(parameter_rate), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, UINT_MAX, FLAGS },
117  { "duration", "set duration", OFFSET(duration), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, UINT_MAX, FLAGS },
118  { "constant_subblock_duration", "set constant_subblock_duration", OFFSET(constant_subblock_duration), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, UINT_MAX, FLAGS },
119  { NULL },
120 };
121 
122 static const AVClass *param_definition_child_iterate(void **opaque)
123 {
124  uintptr_t i = (uintptr_t)*opaque;
125  const AVClass *ret = NULL;
126 
127  switch(i) {
129  ret = &mix_gain_class;
130  break;
133  break;
136  break;
137  default:
138  break;
139  }
140 
141  if (ret)
142  *opaque = (void*)(i + 1);
143  return ret;
144 }
145 
147  .class_name = "AVIAMFParamDefinition",
148  .item_name = av_default_item_name,
149  .version = LIBAVUTIL_VERSION_INT,
150  .option = param_definition_options,
151  .child_class_iterate = param_definition_child_iterate,
152 };
153 
155 {
156  return &param_definition_class;
157 }
158 
160  unsigned int nb_subblocks, size_t *out_size)
161 {
162 
163  struct MixGainStruct {
165  AVIAMFMixGain m;
166  };
167  struct DemixStruct {
170  };
171  struct ReconGainStruct {
174  };
175  size_t subblocks_offset, subblock_size;
176  size_t size;
178 
179  switch (type) {
181  subblocks_offset = offsetof(struct MixGainStruct, m);
182  subblock_size = sizeof(AVIAMFMixGain);
183  break;
185  subblocks_offset = offsetof(struct DemixStruct, d);
186  subblock_size = sizeof(AVIAMFDemixingInfo);
187  break;
189  subblocks_offset = offsetof(struct ReconGainStruct, r);
190  subblock_size = sizeof(AVIAMFReconGain);
191  break;
192  default:
193  return NULL;
194  }
195 
196  size = subblocks_offset;
197  if (nb_subblocks > (SIZE_MAX - size) / subblock_size)
198  return NULL;
199  size += subblock_size * nb_subblocks;
200 
201  par = av_mallocz(size);
202  if (!par)
203  return NULL;
204 
206  av_opt_set_defaults(par);
207 
208  par->type = type;
209  par->nb_subblocks = nb_subblocks;
210  par->subblock_size = subblock_size;
211  par->subblocks_offset = subblocks_offset;
212 
213  for (int i = 0; i < nb_subblocks; i++) {
214  void *subblock = av_iamf_param_definition_get_subblock(par, i);
215 
216  switch (type) {
218  ((AVIAMFMixGain *)subblock)->av_class = &mix_gain_class;
219  break;
221  ((AVIAMFDemixingInfo *)subblock)->av_class = &demixing_info_class;
222  break;
224  ((AVIAMFReconGain *)subblock)->av_class = &recon_gain_class;
225  break;
226  default:
227  av_assert0(0);
228  }
229 
230  av_opt_set_defaults(subblock);
231  }
232 
233  if (out_size)
234  *out_size = size;
235 
236  return par;
237 }
238 
239 //
240 // Audio Element
241 //
242 #undef OFFSET
243 #define OFFSET(x) offsetof(AVIAMFLayer, x)
244 static const AVOption layer_options[] = {
245  { "ch_layout", "set ch_layout", OFFSET(ch_layout), AV_OPT_TYPE_CHLAYOUT, {.str = NULL }, 0, 0, FLAGS },
246  { "flags", "set flags", OFFSET(flags), AV_OPT_TYPE_FLAGS,
247  {.i64 = 0 }, 0, AV_IAMF_LAYER_FLAG_RECON_GAIN, FLAGS, .unit = "flags" },
248  {"recon_gain", "Recon gain is present", 0, AV_OPT_TYPE_CONST,
249  {.i64 = AV_IAMF_LAYER_FLAG_RECON_GAIN }, INT_MIN, INT_MAX, FLAGS, .unit = "flags"},
250  { "output_gain_flags", "set output_gain_flags", OFFSET(output_gain_flags), AV_OPT_TYPE_FLAGS,
251  {.i64 = 0 }, 0, (1 << 6) - 1, FLAGS, .unit = "output_gain_flags" },
252  {"FL", "Left channel", 0, AV_OPT_TYPE_CONST,
253  {.i64 = 1 << 5 }, INT_MIN, INT_MAX, FLAGS, .unit = "output_gain_flags"},
254  {"FR", "Right channel", 0, AV_OPT_TYPE_CONST,
255  {.i64 = 1 << 4 }, INT_MIN, INT_MAX, FLAGS, .unit = "output_gain_flags"},
256  {"BL", "Left surround channel", 0, AV_OPT_TYPE_CONST,
257  {.i64 = 1 << 3 }, INT_MIN, INT_MAX, FLAGS, .unit = "output_gain_flags"},
258  {"BR", "Right surround channel", 0, AV_OPT_TYPE_CONST,
259  {.i64 = 1 << 2 }, INT_MIN, INT_MAX, FLAGS, .unit = "output_gain_flags"},
260  {"TFL", "Left top front channel", 0, AV_OPT_TYPE_CONST,
261  {.i64 = 1 << 1 }, INT_MIN, INT_MAX, FLAGS, .unit = "output_gain_flags"},
262  {"TFR", "Right top front channel", 0, AV_OPT_TYPE_CONST,
263  {.i64 = 1 << 0 }, INT_MIN, INT_MAX, FLAGS, .unit = "output_gain_flags"},
264  { "output_gain", "set output_gain", OFFSET(output_gain), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, -128.0, 128.0, FLAGS },
265  { "ambisonics_mode", "set ambisonics_mode", OFFSET(ambisonics_mode), AV_OPT_TYPE_INT,
266  { .i64 = AV_IAMF_AMBISONICS_MODE_MONO },
268  { "mono", NULL, 0, AV_OPT_TYPE_CONST,
269  { .i64 = AV_IAMF_AMBISONICS_MODE_MONO }, .unit = "ambisonics_mode" },
270  { "projection", NULL, 0, AV_OPT_TYPE_CONST,
271  { .i64 = AV_IAMF_AMBISONICS_MODE_PROJECTION }, .unit = "ambisonics_mode" },
272  { NULL },
273 };
274 
275 static const AVClass layer_class = {
276  .class_name = "AVIAMFLayer",
277  .item_name = av_default_item_name,
278  .version = LIBAVUTIL_VERSION_INT,
279  .option = layer_options,
280 };
281 
282 #undef OFFSET
283 #define OFFSET(x) offsetof(AVIAMFAudioElement, x)
284 static const AVOption audio_element_options[] = {
285  { "audio_element_type", "set audio_element_type", OFFSET(audio_element_type), AV_OPT_TYPE_INT,
288  { "channel", NULL, 0, AV_OPT_TYPE_CONST,
289  { .i64 = AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL }, .unit = "audio_element_type" },
290  { "scene", NULL, 0, AV_OPT_TYPE_CONST,
291  { .i64 = AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE }, .unit = "audio_element_type" },
292  { "default_w", "set default_w", OFFSET(default_w), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 10, FLAGS },
293  { NULL },
294 };
295 
296 static const AVClass *audio_element_child_iterate(void **opaque)
297 {
298  uintptr_t i = (uintptr_t)*opaque;
299  const AVClass *ret = NULL;
300 
301  if (i)
302  ret = &layer_class;
303 
304  if (ret)
305  *opaque = (void*)(i + 1);
306  return ret;
307 }
308 
309 static const AVClass audio_element_class = {
310  .class_name = "AVIAMFAudioElement",
311  .item_name = av_default_item_name,
312  .version = LIBAVUTIL_VERSION_INT,
313  .option = audio_element_options,
314  .child_class_iterate = audio_element_child_iterate,
315 };
316 
318 {
319  return &audio_element_class;
320 }
321 
323 {
324  AVIAMFAudioElement *audio_element = av_mallocz(sizeof(*audio_element));
325 
326  if (audio_element) {
327  audio_element->av_class = &audio_element_class;
328  av_opt_set_defaults(audio_element);
329  }
330 
331  return audio_element;
332 }
333 
335 
337 {
338  AVIAMFAudioElement *audio_element = *paudio_element;
339 
340  if (!audio_element)
341  return;
342 
343  for (int i = 0; i < audio_element->nb_layers; i++) {
344  AVIAMFLayer *layer = audio_element->layers[i];
345  av_opt_free(layer);
346  av_free(layer->demixing_matrix);
347  av_free(layer);
348  }
349  av_free(audio_element->layers);
350 
351  av_free(audio_element->demixing_info);
352  av_free(audio_element->recon_gain_info);
353  av_freep(paudio_element);
354 }
355 
356 //
357 // Mix Presentation
358 //
359 #undef OFFSET
360 #define OFFSET(x) offsetof(AVIAMFSubmixElement, x)
362  { "headphones_rendering_mode", "Headphones rendering mode", OFFSET(headphones_rendering_mode), AV_OPT_TYPE_INT,
364  AV_IAMF_HEADPHONES_MODE_STEREO, AV_IAMF_HEADPHONES_MODE_BINAURAL, FLAGS, .unit = "headphones_rendering_mode" },
365  { "stereo", NULL, 0, AV_OPT_TYPE_CONST,
366  { .i64 = AV_IAMF_HEADPHONES_MODE_STEREO }, .unit = "headphones_rendering_mode" },
367  { "binaural", NULL, 0, AV_OPT_TYPE_CONST,
368  { .i64 = AV_IAMF_HEADPHONES_MODE_BINAURAL }, .unit = "headphones_rendering_mode" },
369  { "default_mix_gain", "Default mix gain", OFFSET(default_mix_gain), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, -128.0, 128.0, FLAGS },
370  { "annotations", "Annotations", OFFSET(annotations), AV_OPT_TYPE_DICT, { .str = NULL }, 0, 0, FLAGS },
371  { NULL },
372 };
373 
374 static void *submix_element_child_next(void *obj, void *prev)
375 {
376  AVIAMFSubmixElement *submix_element = obj;
377  if (!prev)
378  return submix_element->element_mix_config;
379 
380  return NULL;
381 }
382 
383 static const AVClass *submix_element_child_iterate(void **opaque)
384 {
385  uintptr_t i = (uintptr_t)*opaque;
386  const AVClass *ret = NULL;
387 
388  if (i)
390 
391  if (ret)
392  *opaque = (void*)(i + 1);
393  return ret;
394 }
395 
396 static const AVClass element_class = {
397  .class_name = "AVIAMFSubmixElement",
398  .item_name = av_default_item_name,
399  .version = LIBAVUTIL_VERSION_INT,
400  .option = submix_element_options,
401  .child_next = submix_element_child_next,
402  .child_class_iterate = submix_element_child_iterate,
403 };
404 
406 
407 #undef OFFSET
408 #define OFFSET(x) offsetof(AVIAMFSubmixLayout, x)
409 static const AVOption submix_layout_options[] = {
410  { "layout_type", "Layout type", OFFSET(layout_type), AV_OPT_TYPE_INT,
413  { "loudspeakers", NULL, 0, AV_OPT_TYPE_CONST,
414  { .i64 = AV_IAMF_SUBMIX_LAYOUT_TYPE_LOUDSPEAKERS }, .unit = "layout_type" },
415  { "binaural", NULL, 0, AV_OPT_TYPE_CONST,
416  { .i64 = AV_IAMF_SUBMIX_LAYOUT_TYPE_BINAURAL }, .unit = "layout_type" },
417  { "sound_system", "Sound System", OFFSET(sound_system), AV_OPT_TYPE_CHLAYOUT, { .str = NULL }, 0, 0, FLAGS },
418  { "integrated_loudness", "Integrated loudness", OFFSET(integrated_loudness), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, -128.0, 128.0, FLAGS },
419  { "digital_peak", "Digital peak", OFFSET(digital_peak), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, -128.0, 128.0, FLAGS },
420  { "true_peak", "True peak", OFFSET(true_peak), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, -128.0, 128.0, FLAGS },
421  { "dialog_anchored_loudness", "Anchored loudness (Dialog)", OFFSET(dialogue_anchored_loudness), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, -128.0, 128.0, FLAGS },
422  { "album_anchored_loudness", "Anchored loudness (Album)", OFFSET(album_anchored_loudness), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, -128.0, 128.0, FLAGS },
423  { NULL },
424 };
425 
426 static const AVClass layout_class = {
427  .class_name = "AVIAMFSubmixLayout",
428  .item_name = av_default_item_name,
429  .version = LIBAVUTIL_VERSION_INT,
430  .option = submix_layout_options,
431 };
432 
434 
435 #undef OFFSET
436 #define OFFSET(x) offsetof(AVIAMFSubmix, x)
438  { "default_mix_gain", "Default mix gain", OFFSET(default_mix_gain), AV_OPT_TYPE_RATIONAL, { .dbl = 0 }, -128.0, 128.0, FLAGS },
439  { NULL },
440 };
441 
442 static void *submix_presentation_child_next(void *obj, void *prev)
443 {
444  AVIAMFSubmix *sub_mix = obj;
445  if (!prev)
446  return sub_mix->output_mix_config;
447 
448  return NULL;
449 }
450 
451 static const AVClass *submix_presentation_child_iterate(void **opaque)
452 {
453  uintptr_t i = (uintptr_t)*opaque;
454  const AVClass *ret = NULL;
455 
456  switch(i) {
457  case 0:
458  ret = &element_class;
459  break;
460  case 1:
461  ret = &layout_class;
462  break;
463  case 2:
465  break;
466  default:
467  break;
468  }
469 
470  if (ret)
471  *opaque = (void*)(i + 1);
472  return ret;
473 }
474 
475 static const AVClass submix_class = {
476  .class_name = "AVIAMFSubmix",
477  .item_name = av_default_item_name,
478  .version = LIBAVUTIL_VERSION_INT,
479  .option = submix_presentation_options,
480  .child_next = submix_presentation_child_next,
481  .child_class_iterate = submix_presentation_child_iterate,
482 };
483 
484 #undef OFFSET
485 #define OFFSET(x) offsetof(AVIAMFMixPresentation, x)
487  { "annotations", "set annotations", OFFSET(annotations), AV_OPT_TYPE_DICT, {.str = NULL }, 0, 0, FLAGS },
488  { NULL },
489 };
490 
491 #undef OFFSET
492 #undef FLAGS
493 
494 static const AVClass *mix_presentation_child_iterate(void **opaque)
495 {
496  uintptr_t i = (uintptr_t)*opaque;
497  const AVClass *ret = NULL;
498 
499  if (i)
500  ret = &submix_class;
501 
502  if (ret)
503  *opaque = (void*)(i + 1);
504  return ret;
505 }
506 
508  .class_name = "AVIAMFMixPresentation",
509  .item_name = av_default_item_name,
510  .version = LIBAVUTIL_VERSION_INT,
511  .option = mix_presentation_options,
512  .child_class_iterate = mix_presentation_child_iterate,
513 };
514 
516 {
517  return &mix_presentation_class;
518 }
519 
521 {
522  AVIAMFMixPresentation *mix_presentation = av_mallocz(sizeof(*mix_presentation));
523 
524  if (mix_presentation) {
525  mix_presentation->av_class = &mix_presentation_class;
526  av_opt_set_defaults(mix_presentation);
527  }
528 
529  return mix_presentation;
530 }
531 
532 IAMF_ADD_FUNC_TEMPLATE(AVIAMFMixPresentation, mix_presentation, AVIAMFSubmix, submix, es)
533 
535 {
536  AVIAMFMixPresentation *mix_presentation = *pmix_presentation;
537 
538  if (!mix_presentation)
539  return;
540 
541  for (int i = 0; i < mix_presentation->nb_submixes; i++) {
542  AVIAMFSubmix *sub_mix = mix_presentation->submixes[i];
543  for (int j = 0; j < sub_mix->nb_elements; j++) {
544  AVIAMFSubmixElement *submix_element = sub_mix->elements[j];
545  av_opt_free(submix_element);
546  av_free(submix_element->element_mix_config);
547  av_free(submix_element);
548  }
549  av_free(sub_mix->elements);
550  for (int j = 0; j < sub_mix->nb_layouts; j++) {
551  AVIAMFSubmixLayout *submix_layout = sub_mix->layouts[j];
552  av_opt_free(submix_layout);
553  av_free(submix_layout);
554  }
555  av_free(sub_mix->layouts);
556  av_free(sub_mix->output_mix_config);
557  av_free(sub_mix);
558  }
559  av_opt_free(mix_presentation);
560  av_free(mix_presentation->submixes);
561 
562  av_freep(pmix_presentation);
563 }
audio_element_options
static const AVOption audio_element_options[]
Definition: iamf.c:284
iamf.h
AVIAMFSubmix::elements
AVIAMFSubmixElement ** elements
Array of submix elements.
Definition: iamf.h:552
AV_IAMF_SUBMIX_LAYOUT_TYPE_LOUDSPEAKERS
@ AV_IAMF_SUBMIX_LAYOUT_TYPE_LOUDSPEAKERS
The layout follows the loudspeaker sound system convention of ITU-2051-3.
Definition: iamf.h:488
AVIAMFAudioElement::nb_layers
unsigned int nb_layers
Number of layers, or channel groups, in the Audio Element.
Definition: iamf.h:359
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1640
AVIAMFSubmix::layouts
AVIAMFSubmixLayout ** layouts
Array of submix layouts.
Definition: iamf.h:567
r
const char * r
Definition: vf_curves.c:127
opt.h
element_class
static const AVClass element_class
Definition: iamf.c:396
submix_presentation_child_next
static void * submix_presentation_child_next(void *obj, void *prev)
Definition: iamf.c:442
mix_gain_options
static const AVOption mix_gain_options[]
Definition: iamf.c:66
av_iamf_param_definition_alloc
AVIAMFParamDefinition * av_iamf_param_definition_alloc(enum AVIAMFParamDefinitionType type, unsigned int nb_subblocks, size_t *out_size)
Allocates memory for AVIAMFParamDefinition, plus an array of.
Definition: iamf.c:159
AVIAMFAudioElement::layers
AVIAMFLayer ** layers
Definition: iamf.h:350
AVIAMFMixPresentation::nb_submixes
unsigned int nb_submixes
Number of submixes in the presentation.
Definition: iamf.h:616
out_size
int out_size
Definition: movenc.c:56
submix_class
static const AVClass submix_class
Definition: iamf.c:475
AVIAMFParamDefinition::type
enum AVIAMFParamDefinitionType type
Parameters type.
Definition: iamf.h:204
AVOption
AVOption.
Definition: opt.h:346
AV_IAMF_HEADPHONES_MODE_STEREO
@ AV_IAMF_HEADPHONES_MODE_STEREO
The referenced Audio Element shall be rendered to stereo loudspeakers.
Definition: iamf.h:424
av_iamf_mix_presentation_free
void av_iamf_mix_presentation_free(AVIAMFMixPresentation **pmix_presentation)
Free an AVIAMFMixPresentation and all its contents.
Definition: iamf.c:534
demixing_info_class
static const AVClass demixing_info_class
Definition: iamf.c:91
submix_element_child_next
static void * submix_element_child_next(void *obj, void *prev)
Definition: iamf.c:374
AVIAMFParamDefinition
Parameters as defined in section 3.6.1 of IAMF.
Definition: iamf.h:184
AV_OPT_TYPE_RATIONAL
@ AV_OPT_TYPE_RATIONAL
Definition: opt.h:240
recon_gain_options
static const AVOption recon_gain_options[]
Definition: iamf.c:100
AVIAMFSubmixLayout
Submix layout as defined in section 3.7.6 of IAMF.
Definition: iamf.h:501
av_iamf_audio_element_free
void av_iamf_audio_element_free(AVIAMFAudioElement **paudio_element)
Free an AVIAMFAudioElement and all its contents.
Definition: iamf.c:336
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1910
av_iamf_audio_element_alloc
AVIAMFAudioElement * av_iamf_audio_element_alloc(void)
Allocates a AVIAMFAudioElement, and initializes its fields with default values.
Definition: iamf.c:322
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
submix_presentation_options
static const AVOption submix_presentation_options[]
Definition: iamf.c:437
AVIAMFReconGain
Recon Gain Info Parameter Data as defined in section 3.8.3 of IAMF.
Definition: iamf.h:139
AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN
@ AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN
Subblocks are of struct type AVIAMFReconGain.
Definition: iamf.h:172
FLAGS
#define FLAGS
Definition: iamf.c:60
avassert.h
duration
int64_t duration
Definition: movenc.c:65
s
#define s(width, name)
Definition: cbs_vp9.c:198
mix_presentation_class
static const AVClass mix_presentation_class
Definition: iamf.c:507
av_iamf_param_definition_get_subblock
static av_always_inline void * av_iamf_param_definition_get_subblock(const AVIAMFParamDefinition *par, unsigned int idx)
Get the subblock at the specified.
Definition: iamf.h:251
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
av_iamf_param_definition_get_class
const AVClass * av_iamf_param_definition_get_class(void)
Definition: iamf.c:154
limits.h
AV_IAMF_HEADPHONES_MODE_BINAURAL
@ AV_IAMF_HEADPHONES_MODE_BINAURAL
The referenced Audio Element shall be rendered with a binaural renderer.
Definition: iamf.h:428
AVIAMFDemixingInfo
Demixing Info Parameter Data as defined in section 3.8.2 of IAMF.
Definition: iamf.h:119
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
output_gain
static double output_gain(double lin_slope, double ratio, double thres, double knee, double knee_start, double knee_stop, double range, int mode)
Definition: af_agate.c:120
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
submix_element_options
static const AVOption submix_element_options[]
Definition: iamf.c:361
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:242
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AVIAMFLayer
A layer defining a Channel Layout in the Audio Element.
Definition: iamf.h:285
submix_presentation_child_iterate
static const AVClass * submix_presentation_child_iterate(void **opaque)
Definition: iamf.c:451
demixing_info_options
static const AVOption demixing_info_options[]
Definition: iamf.c:85
param_definition_options
static const AVOption param_definition_options[]
Definition: iamf.c:114
AVIAMFParamDefinition::subblocks_offset
size_t subblocks_offset
Offset in bytes from the start of this struct, at which the subblocks array is located.
Definition: iamf.h:191
AV_IAMF_AMBISONICS_MODE_MONO
@ AV_IAMF_AMBISONICS_MODE_MONO
Definition: iamf.h:264
AV_OPT_TYPE_CHLAYOUT
@ AV_OPT_TYPE_CHLAYOUT
Definition: opt.h:252
error.h
AVIAMFSubmix
Submix layout as defined in section 3.7 of IAMF.
Definition: iamf.h:543
size
int size
Definition: twinvq_data.h:10344
layout_class
static const AVClass layout_class
Definition: iamf.c:426
av_iamf_mix_presentation_alloc
AVIAMFMixPresentation * av_iamf_mix_presentation_alloc(void)
Allocates a AVIAMFMixPresentation, and initializes its fields with default values.
Definition: iamf.c:520
AVIAMFAudioElement
Information on how to combine one or more audio streams, as defined in section 3.6 of IAMF.
Definition: iamf.h:347
AVIAMFMixGain
Mix Gain Parameter Data as defined in section 3.8.1 of IAMF.
Definition: iamf.h:68
av_iamf_audio_element_get_class
const AVClass * av_iamf_audio_element_get_class(void)
Definition: iamf.c:317
AVIAMFParamDefinition::av_class
const AVClass * av_class
Definition: iamf.h:185
layout
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel layout
Definition: filter_design.txt:18
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVIAMFLayer::demixing_matrix
AVRational * demixing_matrix
Demixing matrix as defined in section 3.6.3 of IAMF.
Definition: iamf.h:331
param_definition_child_iterate
static const AVClass * param_definition_child_iterate(void **opaque)
Definition: iamf.c:122
AVIAMFAudioElement::av_class
const AVClass * av_class
Definition: iamf.h:348
AVIAMFMixPresentation
Information on how to render and mix one or more AVIAMFAudioElement to generate the final audio outpu...
Definition: iamf.h:600
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
OFFSET
#define OFFSET(x)
Definition: iamf.c:485
AVIAMFParamDefinition::nb_subblocks
unsigned int nb_subblocks
Number of subblocks in the array.
Definition: iamf.h:199
AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE
@ AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE
Definition: iamf.h:337
AVIAMFSubmix::nb_layouts
unsigned int nb_layouts
Number of layouts in the submix.
Definition: iamf.h:574
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
submix_layout_options
static const AVOption submix_layout_options[]
Definition: iamf.c:409
submix_element_child_iterate
static const AVClass * submix_element_child_iterate(void **opaque)
Definition: iamf.c:383
IAMF_ADD_FUNC_TEMPLATE
#define IAMF_ADD_FUNC_TEMPLATE(parent_type, parent_name, child_type, child_name, suffix)
Definition: iamf.c:32
mix_presentation_child_iterate
static const AVClass * mix_presentation_child_iterate(void **opaque)
Definition: iamf.c:494
av_iamf_mix_presentation_get_class
const AVClass * av_iamf_mix_presentation_get_class(void)
Definition: iamf.c:515
mix_gain_class
static const AVClass mix_gain_class
Definition: iamf.c:76
layer_class
static const AVClass layer_class
Definition: iamf.c:275
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN
@ AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN
Subblocks are of struct type AVIAMFMixGain.
Definition: iamf.h:164
audio_element_class
static const AVClass audio_element_class
Definition: iamf.c:309
AVIAMFSubmix::nb_elements
unsigned int nb_elements
Number of elements in the submix.
Definition: iamf.h:559
AVIAMFAudioElement::demixing_info
AVIAMFParamDefinition * demixing_info
Demixing information used to reconstruct a scalable channel audio representation.
Definition: iamf.h:367
mem.h
AVIAMFSubmix::output_mix_config
AVIAMFParamDefinition * output_mix_config
Information required for post-processing the mixed audio signal to generate the audio signal for play...
Definition: iamf.h:582
AVIAMFParamDefinitionType
AVIAMFParamDefinitionType
Definition: iamf.h:160
AV_IAMF_SUBMIX_LAYOUT_TYPE_BINAURAL
@ AV_IAMF_SUBMIX_LAYOUT_TYPE_BINAURAL
The layout is binaural.
Definition: iamf.h:492
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AV_IAMF_AMBISONICS_MODE_PROJECTION
@ AV_IAMF_AMBISONICS_MODE_PROJECTION
Definition: iamf.h:265
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
d
d
Definition: ffmpeg_filter.c:424
AVIAMFSubmixElement::element_mix_config
AVIAMFParamDefinition * element_mix_config
Information required required for applying any processing to the referenced and rendered Audio Elemen...
Definition: iamf.h:452
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:234
AVIAMFSubmixElement
Submix element as defined in section 3.7 of IAMF.
Definition: iamf.h:437
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL
@ AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL
Definition: iamf.h:336
AVIAMFParamDefinition::subblock_size
size_t subblock_size
Size in bytes of each element in the subblocks array.
Definition: iamf.h:195
recon_gain_class
static const AVClass recon_gain_class
Definition: iamf.c:105
AVIAMFAudioElement::recon_gain_info
AVIAMFParamDefinition * recon_gain_info
Recon gain information used to reconstruct a scalable channel audio representation.
Definition: iamf.h:374
audio_element_child_iterate
static const AVClass * audio_element_child_iterate(void **opaque)
Definition: iamf.c:296
AVIAMFMixPresentation::submixes
AVIAMFSubmix ** submixes
Array of submixes.
Definition: iamf.h:609
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
mix_presentation_options
static const AVOption mix_presentation_options[]
Definition: iamf.c:486
param_definition_class
static const AVClass param_definition_class
Definition: iamf.c:146
AVIAMFMixPresentation::av_class
const AVClass * av_class
Definition: iamf.h:601
AV_IAMF_PARAMETER_DEFINITION_DEMIXING
@ AV_IAMF_PARAMETER_DEFINITION_DEMIXING
Subblocks are of struct type AVIAMFDemixingInfo.
Definition: iamf.h:168
layer_options
static const AVOption layer_options[]
Definition: iamf.c:244