FFmpeg
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
iamf_writer.c
Go to the documentation of this file.
1 /*
2  * Immersive Audio Model and Formats muxing helpers and structs
3  * Copyright (c) 2023 James Almer <jamrial@gmail.com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/bprint.h"
24 #include "libavutil/intreadwrite.h"
25 #include "libavutil/iamf.h"
26 #include "libavutil/mem.h"
27 #include "libavcodec/get_bits.h"
28 #include "libavcodec/put_bits.h"
29 #include "avformat.h"
30 #include "avio_internal.h"
31 #include "iamf.h"
32 #include "iamf_writer.h"
33 
34 
35 static int update_extradata(IAMFCodecConfig *codec_config)
36 {
37  GetBitContext gb;
38  PutBitContext pb;
39  int ret;
40 
41  switch(codec_config->codec_id) {
42  case AV_CODEC_ID_OPUS:
43  if (codec_config->extradata_size != 19)
44  return AVERROR_INVALIDDATA;
45  codec_config->extradata_size -= 8;
46  AV_WB8(codec_config->extradata + 0, AV_RL8(codec_config->extradata + 8)); // version
47  AV_WB8(codec_config->extradata + 1, 2); // set channels to stereo
48  AV_WB16A(codec_config->extradata + 2, AV_RL16A(codec_config->extradata + 10)); // Byte swap pre-skip
49  AV_WB32A(codec_config->extradata + 4, AV_RL32A(codec_config->extradata + 12)); // Byte swap sample rate
50  AV_WB16A(codec_config->extradata + 8, 0); // set Output Gain to 0
51  AV_WB8(codec_config->extradata + 10, AV_RL8(codec_config->extradata + 18)); // Mapping family
52  break;
53  case AV_CODEC_ID_FLAC: {
54  uint8_t buf[13];
55 
56  init_put_bits(&pb, buf, sizeof(buf));
57  ret = init_get_bits8(&gb, codec_config->extradata, codec_config->extradata_size);
58  if (ret < 0)
59  return ret;
60 
61  put_bits32(&pb, get_bits_long(&gb, 32)); // min/max blocksize
62  put_bits64(&pb, 48, get_bits64(&gb, 48)); // min/max framesize
63  put_bits(&pb, 20, get_bits(&gb, 20)); // samplerate
64  skip_bits(&gb, 3);
65  put_bits(&pb, 3, 1); // set channels to stereo
66  ret = put_bits_left(&pb);
67  put_bits(&pb, ret, get_bits(&gb, ret));
68  flush_put_bits(&pb);
69 
70  memcpy(codec_config->extradata, buf, sizeof(buf));
71  break;
72  }
73  default:
74  break;
75  }
76 
77  return 0;
78 }
79 
81 {
82  switch (codec_config->codec_id) {
83  case AV_CODEC_ID_OPUS:
84  if (!codec_config->nb_samples)
85  return AVERROR(EINVAL);
86  // ceil(3840 / nb_samples)
87  codec_config->audio_roll_distance = -(1 + ((3840 - 1) / codec_config->nb_samples));
88  break;
89  case AV_CODEC_ID_AAC:
90  codec_config->audio_roll_distance = -1;
91  break;
92  case AV_CODEC_ID_FLAC:
99  codec_config->audio_roll_distance = 0;
100  break;
101  default:
102  return AVERROR(EINVAL);
103  }
104 
105  return 0;
106 }
107 
108 static int fill_codec_config(IAMFContext *iamf, const AVStreamGroup *stg,
109  IAMFCodecConfig *codec_config)
110 {
111  const AVStream *st = stg->streams[0];
113  int j, ret = 0;
114 
115  codec_config->codec_id = st->codecpar->codec_id;
116  codec_config->codec_tag = st->codecpar->codec_tag;
117  switch (codec_config->codec_id) {
118  case AV_CODEC_ID_OPUS:
119  codec_config->sample_rate = 48000;
120  codec_config->nb_samples = av_rescale(st->codecpar->frame_size, 48000, st->codecpar->sample_rate);
121  break;
122  default:
123  codec_config->sample_rate = st->codecpar->sample_rate;
124  codec_config->nb_samples = st->codecpar->frame_size;
125  break;
126  }
127  populate_audio_roll_distance(codec_config);
128  if (st->codecpar->extradata_size) {
129  codec_config->extradata = av_memdup(st->codecpar->extradata, st->codecpar->extradata_size);
130  if (!codec_config->extradata)
131  return AVERROR(ENOMEM);
132  codec_config->extradata_size = st->codecpar->extradata_size;
133  ret = update_extradata(codec_config);
134  if (ret < 0)
135  goto fail;
136  }
137 
138  for (j = 0; j < iamf->nb_codec_configs; j++) {
139  if (!memcmp(iamf->codec_configs[j], codec_config, offsetof(IAMFCodecConfig, extradata)) &&
140  (!codec_config->extradata_size || !memcmp(iamf->codec_configs[j]->extradata,
141  codec_config->extradata, codec_config->extradata_size)))
142  break;
143  }
144 
145  if (j < iamf->nb_codec_configs) {
146  av_free(iamf->codec_configs[j]->extradata);
147  av_free(iamf->codec_configs[j]);
148  iamf->codec_configs[j] = codec_config;
149  return j;
150  }
151 
152  tmp = av_realloc_array(iamf->codec_configs, iamf->nb_codec_configs + 1, sizeof(*iamf->codec_configs));
153  if (!tmp) {
154  ret = AVERROR(ENOMEM);
155  goto fail;
156  }
157 
158  iamf->codec_configs = tmp;
159  iamf->codec_configs[iamf->nb_codec_configs] = codec_config;
160  codec_config->codec_config_id = iamf->nb_codec_configs;
161 
162  return iamf->nb_codec_configs++;
163 
164 fail:
165  av_freep(&codec_config->extradata);
166  return ret;
167 }
168 
170  const IAMFAudioElement *audio_element, void *log_ctx)
171 {
173  IAMFCodecConfig *codec_config = NULL;
174 
176  sizeof(*iamf->param_definitions));
177  if (!tmp)
178  return AVERROR(ENOMEM);
179 
180  iamf->param_definitions = tmp;
181 
182  if (audio_element)
183  codec_config = iamf->codec_configs[audio_element->codec_config_id];
184 
185  if (!param->parameter_rate) {
186  if (!codec_config) {
187  av_log(log_ctx, AV_LOG_ERROR, "parameter_rate needed but not set for parameter_id %u\n",
188  param->parameter_id);
189  return AVERROR(EINVAL);
190  }
191  param->parameter_rate = codec_config->sample_rate;
192  }
193  if (codec_config) {
194  if (!param->duration)
195  param->duration = av_rescale(codec_config->nb_samples, param->parameter_rate, codec_config->sample_rate);
196  if (!param->constant_subblock_duration)
197  param->constant_subblock_duration = av_rescale(codec_config->nb_samples, param->parameter_rate, codec_config->sample_rate);
198  }
199 
201  if (!param_definition)
202  return AVERROR(ENOMEM);
203 
204  param_definition->mode = !!param->duration;
205  param_definition->param = param;
206  param_definition->audio_element = audio_element;
208 
209  return 0;
210 }
211 
212 int ff_iamf_add_audio_element(IAMFContext *iamf, const AVStreamGroup *stg, void *log_ctx)
213 {
214  const AVIAMFAudioElement *iamf_audio_element;
215  IAMFAudioElement **tmp, *audio_element;
216  IAMFCodecConfig *codec_config;
217  int ret;
218 
220  return AVERROR(EINVAL);
221  if (!stg->nb_streams) {
222  av_log(log_ctx, AV_LOG_ERROR, "Audio Element id %"PRId64" has no streams\n", stg->id);
223  return AVERROR(EINVAL);
224  }
225 
226  iamf_audio_element = stg->params.iamf_audio_element;
227  if (iamf_audio_element->audio_element_type == AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE) {
228  const AVIAMFLayer *layer = iamf_audio_element->layers[0];
229  if (iamf_audio_element->nb_layers != 1) {
230  av_log(log_ctx, AV_LOG_ERROR, "Invalid amount of layers for SCENE_BASED audio element. Must be 1\n");
231  return AVERROR(EINVAL);
232  }
233  if (layer->ch_layout.order != AV_CHANNEL_ORDER_CUSTOM &&
235  av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout for SCENE_BASED audio element\n");
236  return AVERROR(EINVAL);
237  }
239  av_log(log_ctx, AV_LOG_ERROR, "Unsuported ambisonics mode %d\n", layer->ambisonics_mode);
240  return AVERROR_PATCHWELCOME;
241  }
242  for (int i = 0; i < stg->nb_streams; i++) {
243  if (stg->streams[i]->codecpar->ch_layout.nb_channels > 1) {
244  av_log(log_ctx, AV_LOG_ERROR, "Invalid amount of channels in a stream for MONO mode ambisonics\n");
245  return AVERROR(EINVAL);
246  }
247  }
248  } else
249  for (int j, i = 0; i < iamf_audio_element->nb_layers; i++) {
250  const AVIAMFLayer *layer = iamf_audio_element->layers[i];
251  for (j = 0; j < FF_ARRAY_ELEMS(ff_iamf_scalable_ch_layouts); j++)
253  break;
254 
258  break;
260  AVBPrint bp;
263  av_log(log_ctx, AV_LOG_ERROR, "Unsupported channel layout in Audio Element id %"PRId64
264  ", Layer %d: %s\n",
265  stg->id, i, bp.str);
266  av_bprint_finalize(&bp, NULL);
267  return AVERROR(EINVAL);
268  }
269  }
270  }
271 
272  for (int i = 0; i < iamf->nb_audio_elements; i++) {
273  if (stg->id == iamf->audio_elements[i]->audio_element_id) {
274  av_log(log_ctx, AV_LOG_ERROR, "Duplicated Audio Element id %"PRId64"\n", stg->id);
275  return AVERROR(EINVAL);
276  }
277  }
278 
279  codec_config = av_mallocz(sizeof(*codec_config));
280  if (!codec_config)
281  return AVERROR(ENOMEM);
282 
283  ret = fill_codec_config(iamf, stg, codec_config);
284  if (ret < 0) {
285  av_free(codec_config);
286  return ret;
287  }
288 
289  audio_element = av_mallocz(sizeof(*audio_element));
290  if (!audio_element)
291  return AVERROR(ENOMEM);
292 
293  audio_element->celement = stg->params.iamf_audio_element;
294  audio_element->audio_element_id = stg->id;
295  audio_element->codec_config_id = ret;
296 
297  audio_element->substreams = av_calloc(stg->nb_streams, sizeof(*audio_element->substreams));
298  if (!audio_element->substreams) {
299  ret = AVERROR(ENOMEM);
300  goto fail;
301  }
302  audio_element->nb_substreams = stg->nb_streams;
303 
304  audio_element->layers = av_calloc(iamf_audio_element->nb_layers, sizeof(*audio_element->layers));
305  if (!audio_element->layers) {
306  ret = AVERROR(ENOMEM);
307  goto fail;
308  }
309 
310  for (int i = 0, j = 0; i < iamf_audio_element->nb_layers; i++) {
311  int nb_channels = iamf_audio_element->layers[i]->ch_layout.nb_channels;
312 
313  IAMFLayer *layer = &audio_element->layers[i];
314 
315  if (i)
316  nb_channels -= iamf_audio_element->layers[i - 1]->ch_layout.nb_channels;
317  for (; nb_channels > 0 && j < stg->nb_streams; j++) {
318  const AVStream *st = stg->streams[j];
319  IAMFSubStream *substream = &audio_element->substreams[j];
320 
321  substream->audio_substream_id = st->id;
322  layer->substream_count++;
324  nb_channels -= st->codecpar->ch_layout.nb_channels;
325  }
326  if (nb_channels) {
327  av_log(log_ctx, AV_LOG_ERROR, "Invalid channel count across substreams in layer %u from stream group %u\n",
328  i, stg->index);
329  ret = AVERROR(EINVAL);
330  goto fail;
331  }
332  }
333 
334  for (int i = 0; i < audio_element->nb_substreams; i++) {
335  for (int j = i + 1; j < audio_element->nb_substreams; j++)
336  if (audio_element->substreams[i].audio_substream_id ==
337  audio_element->substreams[j].audio_substream_id) {
338  av_log(log_ctx, AV_LOG_ERROR, "Duplicate id %u in streams %u and %u from stream group %u\n",
339  audio_element->substreams[i].audio_substream_id, i, j, stg->index);
340  ret = AVERROR(EINVAL);
341  goto fail;
342  }
343  }
344 
345  if (iamf_audio_element->demixing_info) {
346  AVIAMFParamDefinition *param = iamf_audio_element->demixing_info;
348 
349  if (param->nb_subblocks != 1) {
350  av_log(log_ctx, AV_LOG_ERROR, "nb_subblocks in demixing_info for stream group %u is not 1\n", stg->index);
351  ret = AVERROR(EINVAL);
352  goto fail;
353  }
354 
355  if (!param_definition) {
356  ret = add_param_definition(iamf, param, audio_element, log_ctx);
357  if (ret < 0)
358  goto fail;
359  }
360  }
361  if (iamf_audio_element->recon_gain_info) {
362  AVIAMFParamDefinition *param = iamf_audio_element->recon_gain_info;
364 
365  if (param->nb_subblocks != 1) {
366  av_log(log_ctx, AV_LOG_ERROR, "nb_subblocks in recon_gain_info for stream group %u is not 1\n", stg->index);
367  ret = AVERROR(EINVAL);
368  goto fail;
369  }
370 
371  if (!param_definition) {
372  ret = add_param_definition(iamf, param, audio_element, log_ctx);
373  if (ret < 0)
374  goto fail;
375  }
376  }
377 
378  tmp = av_realloc_array(iamf->audio_elements, iamf->nb_audio_elements + 1, sizeof(*iamf->audio_elements));
379  if (!tmp) {
380  ret = AVERROR(ENOMEM);
381  goto fail;
382  }
383 
384  iamf->audio_elements = tmp;
385  iamf->audio_elements[iamf->nb_audio_elements++] = audio_element;
386 
387  return 0;
388 fail:
389  ff_iamf_free_audio_element(&audio_element);
390  return ret;
391 }
392 
393 int ff_iamf_add_mix_presentation(IAMFContext *iamf, const AVStreamGroup *stg, void *log_ctx)
394 {
395  IAMFMixPresentation **tmp, *mix_presentation;
396  int ret;
397 
399  return AVERROR(EINVAL);
400  if (!stg->nb_streams) {
401  av_log(log_ctx, AV_LOG_ERROR, "Mix Presentation id %"PRId64" has no streams\n", stg->id);
402  return AVERROR(EINVAL);
403  }
404 
405  for (int i = 0; i < iamf->nb_mix_presentations; i++) {
406  if (stg->id == iamf->mix_presentations[i]->mix_presentation_id) {
407  av_log(log_ctx, AV_LOG_ERROR, "Duplicate Mix Presentation id %"PRId64"\n", stg->id);
408  return AVERROR(EINVAL);
409  }
410  }
411 
412  mix_presentation = av_mallocz(sizeof(*mix_presentation));
413  if (!mix_presentation)
414  return AVERROR(ENOMEM);
415 
416  mix_presentation->cmix = stg->params.iamf_mix_presentation;
417  mix_presentation->mix_presentation_id = stg->id;
418 
419  for (int i = 0; i < mix_presentation->cmix->nb_submixes; i++) {
420  const AVIAMFSubmix *submix = mix_presentation->cmix->submixes[i];
421  AVIAMFParamDefinition *param = submix->output_mix_config;
423 
424  if (!param) {
425  av_log(log_ctx, AV_LOG_ERROR, "output_mix_config is not present in submix %u from "
426  "Mix Presentation ID %"PRId64"\n", i, stg->id);
427  ret = AVERROR(EINVAL);
428  goto fail;
429  }
430 
432  if (!param_definition) {
433  ret = add_param_definition(iamf, param, NULL, log_ctx);
434  if (ret < 0)
435  goto fail;
436  }
437 
438  for (int j = 0; j < submix->nb_elements; j++) {
439  const AVIAMFSubmixElement *element = submix->elements[j];
440  param = element->element_mix_config;
441 
442  if (!param) {
443  av_log(log_ctx, AV_LOG_ERROR, "element_mix_config is not present for element %u in submix %u from "
444  "Mix Presentation ID %"PRId64"\n", j, i, stg->id);
445  ret = AVERROR(EINVAL);
446  goto fail;
447  }
449  if (!param_definition) {
450  ret = add_param_definition(iamf, param, NULL, log_ctx);
451  if (ret < 0)
452  goto fail;
453  }
454  }
455  }
456 
458  if (!tmp) {
459  ret = AVERROR(ENOMEM);
460  goto fail;
461  }
462 
463  iamf->mix_presentations = tmp;
464  iamf->mix_presentations[iamf->nb_mix_presentations++] = mix_presentation;
465 
466  return 0;
467 fail:
468  ff_iamf_free_mix_presentation(&mix_presentation);
469  return ret;
470 }
471 
472 static int iamf_write_codec_config(const IAMFContext *iamf,
473  const IAMFCodecConfig *codec_config,
474  AVIOContext *pb)
475 {
477  AVIOContext *dyn_bc;
478  uint8_t *dyn_buf = NULL;
479  PutBitContext pbc;
480  int dyn_size;
481 
482  int ret = avio_open_dyn_buf(&dyn_bc);
483  if (ret < 0)
484  return ret;
485 
486  ffio_write_leb(dyn_bc, codec_config->codec_config_id);
487  avio_wl32(dyn_bc, codec_config->codec_tag);
488 
489  ffio_write_leb(dyn_bc, codec_config->nb_samples);
490  avio_wb16(dyn_bc, codec_config->audio_roll_distance);
491 
492  switch(codec_config->codec_id) {
493  case AV_CODEC_ID_OPUS:
494  avio_write(dyn_bc, codec_config->extradata, codec_config->extradata_size);
495  break;
496  case AV_CODEC_ID_AAC:
497  return AVERROR_PATCHWELCOME;
498  case AV_CODEC_ID_FLAC:
499  avio_w8(dyn_bc, 0x80);
500  avio_wb24(dyn_bc, codec_config->extradata_size);
501  avio_write(dyn_bc, codec_config->extradata, codec_config->extradata_size);
502  break;
504  avio_w8(dyn_bc, 1);
505  avio_w8(dyn_bc, 16);
506  avio_wb32(dyn_bc, codec_config->sample_rate);
507  break;
509  avio_w8(dyn_bc, 1);
510  avio_w8(dyn_bc, 24);
511  avio_wb32(dyn_bc, codec_config->sample_rate);
512  break;
514  avio_w8(dyn_bc, 1);
515  avio_w8(dyn_bc, 32);
516  avio_wb32(dyn_bc, codec_config->sample_rate);
517  break;
519  avio_w8(dyn_bc, 0);
520  avio_w8(dyn_bc, 16);
521  avio_wb32(dyn_bc, codec_config->sample_rate);
522  break;
524  avio_w8(dyn_bc, 0);
525  avio_w8(dyn_bc, 24);
526  avio_wb32(dyn_bc, codec_config->sample_rate);
527  break;
529  avio_w8(dyn_bc, 0);
530  avio_w8(dyn_bc, 32);
531  avio_wb32(dyn_bc, codec_config->sample_rate);
532  break;
533  default:
534  break;
535  }
536 
537  init_put_bits(&pbc, header, sizeof(header));
539  put_bits(&pbc, 3, 0);
540  flush_put_bits(&pbc);
541 
542  dyn_size = avio_get_dyn_buf(dyn_bc, &dyn_buf);
543  avio_write(pb, header, put_bytes_count(&pbc, 1));
544  ffio_write_leb(pb, dyn_size);
545  avio_write(pb, dyn_buf, dyn_size);
546  ffio_free_dyn_buf(&dyn_bc);
547 
548  return 0;
549 }
550 
551 static inline int rescale_rational(AVRational q, int b)
552 {
553  return av_clip_int16(av_rescale(q.num, b, q.den));
554 }
555 
556 static int scalable_channel_layout_config(const IAMFAudioElement *audio_element,
557  AVIOContext *dyn_bc)
558 {
559  const AVIAMFAudioElement *element = audio_element->celement;
561  PutBitContext pb;
562 
563  init_put_bits(&pb, header, sizeof(header));
564  put_bits(&pb, 3, element->nb_layers);
565  put_bits(&pb, 5, 0);
566  flush_put_bits(&pb);
567  avio_write(dyn_bc, header, put_bytes_count(&pb, 1));
568  for (int i = 0; i < element->nb_layers; i++) {
569  const AVIAMFLayer *layer = element->layers[i];
570  int layout, expanded_layout = -1;
573  break;
574  }
576  for (expanded_layout = 0; expanded_layout < FF_ARRAY_ELEMS(ff_iamf_scalable_ch_layouts); expanded_layout++) {
578  break;
579  }
580  av_assert0(expanded_layout > 0 || layout < FF_ARRAY_ELEMS(ff_iamf_scalable_ch_layouts));
581  init_put_bits(&pb, header, sizeof(header));
582  put_bits(&pb, 4, expanded_layout >= 0 ? 15 : layout);
583  put_bits(&pb, 1, !!layer->output_gain_flags);
584  put_bits(&pb, 1, !!(layer->flags & AV_IAMF_LAYER_FLAG_RECON_GAIN));
585  put_bits(&pb, 2, 0); // reserved
586  put_bits(&pb, 8, audio_element->layers[i].substream_count);
587  put_bits(&pb, 8, audio_element->layers[i].coupled_substream_count);
588  if (layer->output_gain_flags) {
589  put_bits(&pb, 6, layer->output_gain_flags);
590  put_bits(&pb, 2, 0);
591  put_bits(&pb, 16, rescale_rational(layer->output_gain, 1 << 8));
592  }
593  if (expanded_layout >= 0)
594  put_bits(&pb, 8, expanded_layout);
595  flush_put_bits(&pb);
596  avio_write(dyn_bc, header, put_bytes_count(&pb, 1));
597  }
598 
599  return 0;
600 }
601 
602 static int ambisonics_config(const IAMFAudioElement *audio_element,
603  AVIOContext *dyn_bc)
604 {
605  const AVIAMFAudioElement *element = audio_element->celement;
606  const AVIAMFLayer *layer = element->layers[0];
607 
608  ffio_write_leb(dyn_bc, 0); // ambisonics_mode
609  ffio_write_leb(dyn_bc, layer->ch_layout.nb_channels); // output_channel_count
610  ffio_write_leb(dyn_bc, audio_element->nb_substreams); // substream_count
611 
613  for (int i = 0; i < layer->ch_layout.nb_channels; i++)
614  avio_w8(dyn_bc, i);
615  else
616  for (int i = 0; i < layer->ch_layout.nb_channels; i++)
617  avio_w8(dyn_bc, layer->ch_layout.u.map[i].id);
618 
619  return 0;
620 }
621 
622 static int param_definition(const IAMFContext *iamf,
623  const IAMFParamDefinition *param_def,
624  AVIOContext *dyn_bc, void *log_ctx)
625 {
626  const AVIAMFParamDefinition *param = param_def->param;
627 
628  ffio_write_leb(dyn_bc, param->parameter_id);
629  ffio_write_leb(dyn_bc, param->parameter_rate);
630  avio_w8(dyn_bc, param->duration ? 0 : 1 << 7);
631  if (param->duration) {
632  ffio_write_leb(dyn_bc, param->duration);
634  if (param->constant_subblock_duration == 0) {
635  ffio_write_leb(dyn_bc, param->nb_subblocks);
636  for (int i = 0; i < param->nb_subblocks; i++) {
637  const void *subblock = av_iamf_param_definition_get_subblock(param, i);
638 
639  switch (param->type) {
641  const AVIAMFMixGain *mix = subblock;
642  ffio_write_leb(dyn_bc, mix->subblock_duration);
643  break;
644  }
646  const AVIAMFDemixingInfo *demix = subblock;
647  ffio_write_leb(dyn_bc, demix->subblock_duration);
648  break;
649  }
651  const AVIAMFReconGain *recon = subblock;
652  ffio_write_leb(dyn_bc, recon->subblock_duration);
653  break;
654  }
655  }
656  }
657  }
658  }
659 
660  return 0;
661 }
662 
663 static int iamf_write_audio_element(const IAMFContext *iamf,
664  const IAMFAudioElement *audio_element,
665  AVIOContext *pb, void *log_ctx)
666 {
667  const AVIAMFAudioElement *element = audio_element->celement;
668  const IAMFCodecConfig *codec_config = iamf->codec_configs[audio_element->codec_config_id];
670  AVIOContext *dyn_bc;
671  uint8_t *dyn_buf = NULL;
672  PutBitContext pbc;
673  int param_definition_types = AV_IAMF_PARAMETER_DEFINITION_DEMIXING, dyn_size;
674 
675  int ret = avio_open_dyn_buf(&dyn_bc);
676  if (ret < 0)
677  return ret;
678 
679  ffio_write_leb(dyn_bc, audio_element->audio_element_id);
680 
681  init_put_bits(&pbc, header, sizeof(header));
682  put_bits(&pbc, 3, element->audio_element_type);
683  put_bits(&pbc, 5, 0);
684  flush_put_bits(&pbc);
685  avio_write(dyn_bc, header, put_bytes_count(&pbc, 1));
686 
687  ffio_write_leb(dyn_bc, audio_element->codec_config_id);
688  ffio_write_leb(dyn_bc, audio_element->nb_substreams);
689 
690  for (int i = 0; i < audio_element->nb_substreams; i++)
691  ffio_write_leb(dyn_bc, audio_element->substreams[i].audio_substream_id);
692 
693  if (element->nb_layers == 1)
694  param_definition_types &= ~AV_IAMF_PARAMETER_DEFINITION_DEMIXING;
695  if (element->nb_layers > 1)
696  param_definition_types |= AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN;
697  if (codec_config->codec_tag == MKTAG('f','L','a','C') ||
698  codec_config->codec_tag == MKTAG('i','p','c','m'))
699  param_definition_types &= ~AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN;
700 
701  ffio_write_leb(dyn_bc, av_popcount(param_definition_types)); // num_parameters
702 
703  if (param_definition_types & 1) {
704  const AVIAMFParamDefinition *param = element->demixing_info;
705  const IAMFParamDefinition *param_def;
706  const AVIAMFDemixingInfo *demix;
707 
708  if (!param) {
709  av_log(log_ctx, AV_LOG_ERROR, "demixing_info needed but not set in Stream Group #%u\n",
710  audio_element->audio_element_id);
711  return AVERROR(EINVAL);
712  }
713 
714  demix = av_iamf_param_definition_get_subblock(param, 0);
716 
717  param_def = ff_iamf_get_param_definition(iamf, param->parameter_id);
718  ret = param_definition(iamf, param_def, dyn_bc, log_ctx);
719  if (ret < 0)
720  return ret;
721 
722  avio_w8(dyn_bc, demix->dmixp_mode << 5); // dmixp_mode
723  avio_w8(dyn_bc, element->default_w << 4); // default_w
724  }
725  if (param_definition_types & 2) {
726  const AVIAMFParamDefinition *param = element->recon_gain_info;
727  const IAMFParamDefinition *param_def;
728 
729  if (!param) {
730  av_log(log_ctx, AV_LOG_ERROR, "recon_gain_info needed but not set in Stream Group #%u\n",
731  audio_element->audio_element_id);
732  return AVERROR(EINVAL);
733  }
735 
736  param_def = ff_iamf_get_param_definition(iamf, param->parameter_id);
737  ret = param_definition(iamf, param_def, dyn_bc, log_ctx);
738  if (ret < 0)
739  return ret;
740  }
741 
743  ret = scalable_channel_layout_config(audio_element, dyn_bc);
744  if (ret < 0)
745  return ret;
746  } else {
747  ret = ambisonics_config(audio_element, dyn_bc);
748  if (ret < 0)
749  return ret;
750  }
751 
752  init_put_bits(&pbc, header, sizeof(header));
754  put_bits(&pbc, 3, 0);
755  flush_put_bits(&pbc);
756 
757  dyn_size = avio_get_dyn_buf(dyn_bc, &dyn_buf);
758  avio_write(pb, header, put_bytes_count(&pbc, 1));
759  ffio_write_leb(pb, dyn_size);
760  avio_write(pb, dyn_buf, dyn_size);
761  ffio_free_dyn_buf(&dyn_bc);
762 
763  return 0;
764 }
765 
767  const IAMFMixPresentation *mix_presentation,
768  AVIOContext *pb, void *log_ctx)
769 {
771  const AVIAMFMixPresentation *mix = mix_presentation->cmix;
772  const AVDictionaryEntry *tag = NULL;
773  PutBitContext pbc;
774  AVIOContext *dyn_bc;
775  uint8_t *dyn_buf = NULL;
776  int dyn_size;
777 
778  int ret = avio_open_dyn_buf(&dyn_bc);
779  if (ret < 0)
780  return ret;
781 
782  ffio_write_leb(dyn_bc, mix_presentation->mix_presentation_id); // mix_presentation_id
783  ffio_write_leb(dyn_bc, av_dict_count(mix->annotations)); // count_label
784 
785  while ((tag = av_dict_iterate(mix->annotations, tag)))
786  avio_put_str(dyn_bc, tag->key);
787  while ((tag = av_dict_iterate(mix->annotations, tag)))
788  avio_put_str(dyn_bc, tag->value);
789 
790  ffio_write_leb(dyn_bc, mix->nb_submixes);
791  for (int i = 0; i < mix->nb_submixes; i++) {
792  const AVIAMFSubmix *sub_mix = mix->submixes[i];
793  const IAMFParamDefinition *param_def;
794 
795  ffio_write_leb(dyn_bc, sub_mix->nb_elements);
796  for (int j = 0; j < sub_mix->nb_elements; j++) {
797  const IAMFAudioElement *audio_element = NULL;
798  const AVIAMFSubmixElement *submix_element = sub_mix->elements[j];
799 
800  for (int k = 0; k < iamf->nb_audio_elements; k++)
801  if (iamf->audio_elements[k]->audio_element_id == submix_element->audio_element_id) {
802  audio_element = iamf->audio_elements[k];
803  break;
804  }
805 
806  av_assert0(audio_element);
807  ffio_write_leb(dyn_bc, submix_element->audio_element_id);
808 
809  if (av_dict_count(submix_element->annotations) != av_dict_count(mix->annotations)) {
810  av_log(log_ctx, AV_LOG_ERROR, "Inconsistent amount of labels in submix %d from Mix Presentation id #%u\n",
811  j, audio_element->audio_element_id);
812  return AVERROR(EINVAL);
813  }
814  while ((tag = av_dict_iterate(submix_element->annotations, tag)))
815  avio_put_str(dyn_bc, tag->value);
816 
817  init_put_bits(&pbc, header, sizeof(header));
818  put_bits(&pbc, 2, submix_element->headphones_rendering_mode);
819  put_bits(&pbc, 6, 0); // reserved
820  flush_put_bits(&pbc);
821  avio_write(dyn_bc, header, put_bytes_count(&pbc, 1));
822  ffio_write_leb(dyn_bc, 0); // rendering_config_extension_size
823 
824  param_def = ff_iamf_get_param_definition(iamf, submix_element->element_mix_config->parameter_id);
825  ret = param_definition(iamf, param_def, dyn_bc, log_ctx);
826  if (ret < 0)
827  return ret;
828 
829  avio_wb16(dyn_bc, rescale_rational(submix_element->default_mix_gain, 1 << 8));
830  }
831 
832  param_def = ff_iamf_get_param_definition(iamf, sub_mix->output_mix_config->parameter_id);
833  ret = param_definition(iamf, param_def, dyn_bc, log_ctx);
834  if (ret < 0)
835  return ret;
836  avio_wb16(dyn_bc, rescale_rational(sub_mix->default_mix_gain, 1 << 8));
837 
838  ffio_write_leb(dyn_bc, sub_mix->nb_layouts); // nb_layouts
839  for (int i = 0; i < sub_mix->nb_layouts; i++) {
840  const AVIAMFSubmixLayout *submix_layout = sub_mix->layouts[i];
841  int layout, info_type;
842  int dialogue = submix_layout->dialogue_anchored_loudness.num &&
843  submix_layout->dialogue_anchored_loudness.den;
844  int album = submix_layout->album_anchored_loudness.num &&
845  submix_layout->album_anchored_loudness.den;
846 
850  break;
851  }
853  av_log(log_ctx, AV_LOG_ERROR, "Invalid Sound System value in a submix\n");
854  return AVERROR(EINVAL);
855  }
856  } else if (submix_layout->layout_type != AV_IAMF_SUBMIX_LAYOUT_TYPE_BINAURAL) {
857  av_log(log_ctx, AV_LOG_ERROR, "Unsupported Layout Type value in a submix\n");
858  return AVERROR(EINVAL);
859  }
860  init_put_bits(&pbc, header, sizeof(header));
861  put_bits(&pbc, 2, submix_layout->layout_type); // layout_type
863  put_bits(&pbc, 4, ff_iamf_sound_system_map[layout].id); // sound_system
864  put_bits(&pbc, 2, 0); // reserved
865  } else
866  put_bits(&pbc, 6, 0); // reserved
867  flush_put_bits(&pbc);
868  avio_write(dyn_bc, header, put_bytes_count(&pbc, 1));
869 
870  info_type = (submix_layout->true_peak.num && submix_layout->true_peak.den);
871  info_type |= (dialogue || album) << 1;
872  avio_w8(dyn_bc, info_type);
873  avio_wb16(dyn_bc, rescale_rational(submix_layout->integrated_loudness, 1 << 8));
874  avio_wb16(dyn_bc, rescale_rational(submix_layout->digital_peak, 1 << 8));
875  if (info_type & 1)
876  avio_wb16(dyn_bc, rescale_rational(submix_layout->true_peak, 1 << 8));
877  if (info_type & 2) {
878  avio_w8(dyn_bc, dialogue + album); // num_anchored_loudness
879  if (dialogue) {
881  avio_wb16(dyn_bc, rescale_rational(submix_layout->dialogue_anchored_loudness, 1 << 8));
882  }
883  if (album) {
885  avio_wb16(dyn_bc, rescale_rational(submix_layout->album_anchored_loudness, 1 << 8));
886  }
887  }
888  }
889  }
890 
891  init_put_bits(&pbc, header, sizeof(header));
893  put_bits(&pbc, 3, 0);
894  flush_put_bits(&pbc);
895 
896  dyn_size = avio_get_dyn_buf(dyn_bc, &dyn_buf);
897  avio_write(pb, header, put_bytes_count(&pbc, 1));
898  ffio_write_leb(pb, dyn_size);
899  avio_write(pb, dyn_buf, dyn_size);
900  ffio_free_dyn_buf(&dyn_bc);
901 
902  return 0;
903 }
904 
905 int ff_iamf_write_descriptors(const IAMFContext *iamf, AVIOContext *pb, void *log_ctx)
906 {
907  int ret;
908 
909  // Sequence Header
911 
912  ffio_write_leb(pb, 6);
913  avio_wb32(pb, MKBETAG('i','a','m','f'));
914  avio_w8(pb, iamf->nb_audio_elements > 1); // primary_profile
915  avio_w8(pb, iamf->nb_audio_elements > 1); // additional_profile
916 
917  for (int i = 0; i < iamf->nb_codec_configs; i++) {
918  ret = iamf_write_codec_config(iamf, iamf->codec_configs[i], pb);
919  if (ret < 0)
920  return ret;
921  }
922 
923  for (int i = 0; i < iamf->nb_audio_elements; i++) {
924  ret = iamf_write_audio_element(iamf, iamf->audio_elements[i], pb, log_ctx);
925  if (ret < 0)
926  return ret;
927  }
928 
929  for (int i = 0; i < iamf->nb_mix_presentations; i++) {
930  ret = iamf_write_mixing_presentation(iamf, iamf->mix_presentations[i], pb, log_ctx);
931  if (ret < 0)
932  return ret;
933  }
934 
935  return 0;
936 }
937 
938 static int write_parameter_block(const IAMFContext *iamf, AVIOContext *pb,
939  const AVIAMFParamDefinition *param, void *log_ctx)
940 {
943  PutBitContext pbc;
944  AVIOContext *dyn_bc;
945  uint8_t *dyn_buf = NULL;
946  int dyn_size, ret;
947 
949  av_log(log_ctx, AV_LOG_DEBUG, "Ignoring side data with unknown type %u\n",
950  param->type);
951  return 0;
952  }
953 
954  if (!param_definition) {
955  av_log(log_ctx, AV_LOG_ERROR, "Non-existent Parameter Definition with ID %u referenced by a packet\n",
956  param->parameter_id);
957  return AVERROR(EINVAL);
958  }
959 
960  if (param->type != param_definition->param->type) {
961  av_log(log_ctx, AV_LOG_ERROR, "Inconsistent values for Parameter Definition "
962  "with ID %u in a packet\n",
963  param->parameter_id);
964  return AVERROR(EINVAL);
965  }
966 
967  ret = avio_open_dyn_buf(&dyn_bc);
968  if (ret < 0)
969  return ret;
970 
971  // Sequence Header
972  init_put_bits(&pbc, header, sizeof(header));
974  put_bits(&pbc, 3, 0);
975  flush_put_bits(&pbc);
976  avio_write(pb, header, put_bytes_count(&pbc, 1));
977 
978  ffio_write_leb(dyn_bc, param->parameter_id);
979  if (!param_definition->mode) {
980  ffio_write_leb(dyn_bc, param->duration);
982  if (param->constant_subblock_duration == 0)
983  ffio_write_leb(dyn_bc, param->nb_subblocks);
984  }
985 
986  for (int i = 0; i < param->nb_subblocks; i++) {
987  const void *subblock = av_iamf_param_definition_get_subblock(param, i);
988 
989  switch (param->type) {
991  const AVIAMFMixGain *mix = subblock;
992  if (!param_definition->mode && param->constant_subblock_duration == 0)
993  ffio_write_leb(dyn_bc, mix->subblock_duration);
994 
995  ffio_write_leb(dyn_bc, mix->animation_type);
996 
997  avio_wb16(dyn_bc, rescale_rational(mix->start_point_value, 1 << 8));
998  if (mix->animation_type >= AV_IAMF_ANIMATION_TYPE_LINEAR)
999  avio_wb16(dyn_bc, rescale_rational(mix->end_point_value, 1 << 8));
1000  if (mix->animation_type == AV_IAMF_ANIMATION_TYPE_BEZIER) {
1001  avio_wb16(dyn_bc, rescale_rational(mix->control_point_value, 1 << 8));
1002  avio_w8(dyn_bc, av_clip_uint8(av_rescale(mix->control_point_relative_time.num, 1 << 8,
1003  mix->control_point_relative_time.den)));
1004  }
1005  break;
1006  }
1008  const AVIAMFDemixingInfo *demix = subblock;
1009  if (!param_definition->mode && param->constant_subblock_duration == 0)
1010  ffio_write_leb(dyn_bc, demix->subblock_duration);
1011 
1012  avio_w8(dyn_bc, demix->dmixp_mode << 5);
1013  break;
1014  }
1016  const AVIAMFReconGain *recon = subblock;
1017  const AVIAMFAudioElement *audio_element = param_definition->audio_element->celement;
1018 
1019  if (!param_definition->mode && param->constant_subblock_duration == 0)
1020  ffio_write_leb(dyn_bc, recon->subblock_duration);
1021 
1022  if (!audio_element) {
1023  av_log(log_ctx, AV_LOG_ERROR, "Invalid Parameter Definition with ID %u referenced by a packet\n", param->parameter_id);
1024  return AVERROR(EINVAL);
1025  }
1026 
1027  for (int j = 0; j < audio_element->nb_layers; j++) {
1028  const AVIAMFLayer *layer = audio_element->layers[j];
1029 
1030  if (layer->flags & AV_IAMF_LAYER_FLAG_RECON_GAIN) {
1031  unsigned int recon_gain_flags = 0;
1032  int k = 0;
1033 
1034  for (; k < 7; k++)
1035  recon_gain_flags |= (1 << k) * !!recon->recon_gain[j][k];
1036  for (; k < 12; k++)
1037  recon_gain_flags |= (2 << k) * !!recon->recon_gain[j][k];
1038  if (recon_gain_flags >> 8)
1039  recon_gain_flags |= (1 << k);
1040 
1041  ffio_write_leb(dyn_bc, recon_gain_flags);
1042  for (k = 0; k < 12; k++) {
1043  if (recon->recon_gain[j][k])
1044  avio_w8(dyn_bc, recon->recon_gain[j][k]);
1045  }
1046  }
1047  }
1048  break;
1049  }
1050  default:
1051  av_assert0(0);
1052  }
1053  }
1054 
1055  dyn_size = avio_get_dyn_buf(dyn_bc, &dyn_buf);
1056  ffio_write_leb(pb, dyn_size);
1057  avio_write(pb, dyn_buf, dyn_size);
1058  ffio_free_dyn_buf(&dyn_bc);
1059 
1060  return 0;
1061 }
1062 
1064  const AVPacket *pkt, void *log_ctx)
1065 {
1069  NULL);
1070  AVIAMFParamDefinition *demix =
1073  NULL);
1074  AVIAMFParamDefinition *recon =
1077  NULL);
1078 
1079  if (mix) {
1080  int ret = write_parameter_block(iamf, pb, mix, log_ctx);
1081  if (ret < 0)
1082  return ret;
1083  }
1084  if (demix) {
1085  int ret = write_parameter_block(iamf, pb, demix, log_ctx);
1086  if (ret < 0)
1087  return ret;
1088  }
1089  if (recon) {
1090  int ret = write_parameter_block(iamf, pb, recon, log_ctx);
1091  if (ret < 0)
1092  return ret;
1093  }
1094 
1095  return 0;
1096 }
1097 
1099  unsigned int audio_substream_id)
1100 {
1101  for (int i = 0; i < c->nb_audio_elements; i++) {
1102  IAMFAudioElement *audio_element = c->audio_elements[i];
1103  for (int j = 0; j < audio_element->nb_substreams; j++) {
1104  IAMFSubStream *substream = &audio_element->substreams[j];
1105  if (substream->audio_substream_id == audio_substream_id)
1106  return audio_element;
1107  }
1108  }
1109 
1110  return NULL;
1111 }
1112 
1114  unsigned audio_substream_id, const AVPacket *pkt)
1115 {
1117  PutBitContext pbc;
1118  AVIOContext *dyn_bc;
1119  const uint8_t *side_data;
1120  uint8_t *dyn_buf = NULL;
1121  unsigned int skip_samples = 0, discard_padding = 0;
1122  size_t side_data_size;
1123  int dyn_size, type = audio_substream_id <= 17 ?
1125  int ret;
1126 
1127  if (!pkt->size) {
1128  const IAMFAudioElement *audio_element;
1129  IAMFCodecConfig *codec_config;
1130  size_t new_extradata_size;
1131  const uint8_t *new_extradata = av_packet_get_side_data(pkt,
1133  &new_extradata_size);
1134 
1135  if (!new_extradata)
1136  return AVERROR_INVALIDDATA;
1137  audio_element = get_audio_element(iamf, audio_substream_id);
1138  if (!audio_element)
1139  return AVERROR(EINVAL);
1140  codec_config = ff_iamf_get_codec_config(iamf, audio_element->codec_config_id);
1141  if (!codec_config)
1142  return AVERROR(EINVAL);
1143 
1144  av_free(codec_config->extradata);
1145  codec_config->extradata = av_memdup(new_extradata, new_extradata_size);
1146  if (!codec_config->extradata) {
1147  codec_config->extradata_size = 0;
1148  return AVERROR(ENOMEM);
1149  }
1150  codec_config->extradata_size = new_extradata_size;
1151 
1152  return update_extradata(codec_config);
1153  }
1154 
1156  &side_data_size);
1157 
1158  if (side_data && side_data_size >= 10) {
1159  skip_samples = AV_RL32(side_data);
1160  discard_padding = AV_RL32(side_data + 4);
1161  }
1162 
1163  ret = avio_open_dyn_buf(&dyn_bc);
1164  if (ret < 0)
1165  return ret;
1166 
1167  init_put_bits(&pbc, header, sizeof(header));
1168  put_bits(&pbc, 5, type);
1169  put_bits(&pbc, 1, 0); // obu_redundant_copy
1170  put_bits(&pbc, 1, skip_samples || discard_padding);
1171  put_bits(&pbc, 1, 0); // obu_extension_flag
1172  flush_put_bits(&pbc);
1173  avio_write(pb, header, put_bytes_count(&pbc, 1));
1174 
1175  if (skip_samples || discard_padding) {
1176  ffio_write_leb(dyn_bc, discard_padding);
1177  ffio_write_leb(dyn_bc, skip_samples);
1178  }
1179 
1180  if (audio_substream_id > 17)
1181  ffio_write_leb(dyn_bc, audio_substream_id);
1182 
1183  dyn_size = avio_get_dyn_buf(dyn_bc, &dyn_buf);
1184  ffio_write_leb(pb, dyn_size + pkt->size);
1185  avio_write(pb, dyn_buf, dyn_size);
1186  ffio_free_dyn_buf(&dyn_bc);
1187  avio_write(pb, pkt->data, pkt->size);
1188 
1189  return 0;
1190 }
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:335
iamf.h
ff_iamf_free_mix_presentation
void ff_iamf_free_mix_presentation(IAMFMixPresentation **pmix_presentation)
Definition: iamf.c:158
AVIAMFSubmix::elements
AVIAMFSubmixElement ** elements
Array of submix elements.
Definition: iamf.h:565
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:498
AVIAMFAudioElement::nb_layers
unsigned int nb_layers
Number of layers, or channel groups, in the Audio Element.
Definition: iamf.h:368
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
AVStreamGroup::id
int64_t id
Group type-specific group ID.
Definition: avformat.h:1153
AVIAMFSubmix::layouts
AVIAMFSubmixLayout ** layouts
Array of submix layouts.
Definition: iamf.h:580
mix
static int mix(int c0, int c1)
Definition: 4xm.c:716
AVERROR
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 sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
put_bits32
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:291
IAMF_OBU_IA_SEQUENCE_HEADER
@ IAMF_OBU_IA_SEQUENCE_HEADER
Definition: iamf.h:63
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
AVIAMFAudioElement::default_w
unsigned int default_w
Default weight value as defined in section 3.6 of IAMF.
Definition: iamf.h:393
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:56
IAMFAudioElement::nb_substreams
unsigned int nb_substreams
Definition: iamf.h:99
AVIAMFAudioElement::layers
AVIAMFLayer ** layers
Definition: iamf.h:359
av_dict_count
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
Definition: dict.c:39
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
AVChannelLayout::map
AVChannelCustom * map
This member must be used when the channel order is AV_CHANNEL_ORDER_CUSTOM.
Definition: channel_layout.h:370
AVIAMFMixPresentation::nb_submixes
unsigned int nb_submixes
Number of submixes in the presentation.
Definition: iamf.h:629
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
AVIAMFParamDefinition::type
enum AVIAMFParamDefinitionType type
Parameters type.
Definition: iamf.h:213
AVPacket::data
uint8_t * data
Definition: packet.h:539
put_bits64
static void put_bits64(PutBitContext *s, int n, uint64_t value)
Write up to 64 bits into a bitstream.
Definition: put_bits.h:334
b
#define b
Definition: input.c:41
put_bytes_count
static int put_bytes_count(const PutBitContext *s, int round_up)
Definition: put_bits.h:100
AVIAMFSubmixLayout::layout_type
enum AVIAMFSubmixLayoutType layout_type
Definition: iamf.h:517
IAMFParamDefinition::param
AVIAMFParamDefinition * param
Definition: iamf.h:123
AVIAMFParamDefinition
Parameters as defined in section 3.6.1 of IAMF.
Definition: iamf.h:193
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
AVIAMFSubmixElement::default_mix_gain
AVRational default_mix_gain
Default mix gain value to apply when there are no AVIAMFParamDefinition with element_mix_config's par...
Definition: iamf.h:469
add_param_definition
static int add_param_definition(IAMFContext *iamf, AVIAMFParamDefinition *param, const IAMFAudioElement *audio_element, void *log_ctx)
Definition: iamf_writer.c:169
AV_CODEC_ID_FLAC
@ AV_CODEC_ID_FLAC
Definition: codec_id.h:460
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:324
av_popcount
#define av_popcount
Definition: common.h:154
ff_iamf_get_param_definition
static IAMFParamDefinition * ff_iamf_get_param_definition(const IAMFContext *iamf, unsigned int parameter_id)
Definition: iamf.h:185
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
AV_RL8
#define AV_RL8(x)
Definition: intreadwrite.h:394
avio_get_dyn_buf
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1374
AVStreamGroup::params
union AVStreamGroup::@368 params
Group type-specific parameters.
av_channel_layout_describe_bprint
int av_channel_layout_describe_bprint(const AVChannelLayout *channel_layout, AVBPrint *bp)
bprint variant of av_channel_layout_describe().
Definition: channel_layout.c:599
IAMFMixPresentation::cmix
const AVIAMFMixPresentation * cmix
Definition: iamf.h:108
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:304
write_parameter_block
static int write_parameter_block(const IAMFContext *iamf, AVIOContext *pb, const AVIAMFParamDefinition *param, void *log_ctx)
Definition: iamf_writer.c:938
AVIAMFSubmixLayout::digital_peak
AVRational digital_peak
The digital (sampled) peak value of the audio signal, as defined in ITU-1770-4.
Definition: iamf.h:535
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
fill_codec_config
static int fill_codec_config(IAMFContext *iamf, const AVStreamGroup *stg, IAMFCodecConfig *codec_config)
Definition: iamf_writer.c:108
AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM
@ AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM
IAMF Recon Gain Info Parameter Data associated with the audio frame.
Definition: packet.h:320
AVIAMFSubmixLayout::integrated_loudness
AVRational integrated_loudness
The program integrated loudness information, as defined in ITU-1770-4.
Definition: iamf.h:530
IAMFCodecConfig::extradata
uint8_t * extradata
Definition: iamf.h:74
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:336
IAMFParamDefinition
Definition: iamf.h:121
fail
#define fail()
Definition: checkasm.h:193
IAMFCodecConfig::codec_tag
uint32_t codec_tag
Definition: iamf.h:69
GetBitContext
Definition: get_bits.h:108
AVIAMFSubmixLayout
Submix layout as defined in section 3.7.6 of IAMF.
Definition: iamf.h:514
IAMF_ANCHOR_ELEMENT_ALBUM
@ IAMF_ANCHOR_ELEMENT_ALBUM
Definition: iamf.h:142
put_bits_left
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:125
AV_BPRINT_SIZE_AUTOMATIC
#define AV_BPRINT_SIZE_AUTOMATIC
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
IAMF_OBU_IA_PARAMETER_BLOCK
@ IAMF_OBU_IA_PARAMETER_BLOCK
Definition: iamf.h:41
AVIAMFAudioElement::audio_element_type
enum AVIAMFAudioElementType audio_element_type
Audio element type as defined in section 3.6 of IAMF.
Definition: iamf.h:388
AVIAMFReconGain
Recon Gain Info Parameter Data as defined in section 3.8.3 of IAMF.
Definition: iamf.h:148
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN
@ AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN
Subblocks are of struct type AVIAMFReconGain.
Definition: iamf.h:181
rescale_rational
static int rescale_rational(AVRational q, int b)
Definition: iamf_writer.c:551
IAMFContext::audio_elements
IAMFAudioElement ** audio_elements
Definition: iamf.h:131
AVIAMFSubmixElement::annotations
AVDictionary * annotations
A dictionary of strings describing the submix in different languages.
Definition: iamf.h:490
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
IAMFCodecConfig::sample_rate
int sample_rate
Definition: iamf.h:72
IAMF_OBU_IA_MIX_PRESENTATION
@ IAMF_OBU_IA_MIX_PRESENTATION
Definition: iamf.h:40
AVCodecParameters::frame_size
int frame_size
Audio only.
Definition: codec_par.h:195
avio_open_dyn_buf
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1362
AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
@ AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
Definition: avformat.h:1126
AV_IAMF_ANIMATION_TYPE_BEZIER
@ AV_IAMF_ANIMATION_TYPE_BEZIER
Definition: iamf.h:69
update_extradata
static int update_extradata(IAMFCodecConfig *codec_config)
Definition: iamf_writer.c:35
ff_iamf_add_audio_element
int ff_iamf_add_audio_element(IAMFContext *iamf, const AVStreamGroup *stg, void *log_ctx)
Definition: iamf_writer.c:212
intreadwrite.h
IAMFSubStream::audio_substream_id
unsigned int audio_substream_id
Definition: iamf.h:83
IAMFLayer::substream_count
unsigned int substream_count
Definition: iamf.h:78
AVIAMFSubmixLayout::dialogue_anchored_loudness
AVRational dialogue_anchored_loudness
The Dialogue loudness information, as defined in ITU-1770-4.
Definition: iamf.h:543
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
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:260
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AVIAMFSubmixElement::headphones_rendering_mode
enum AVIAMFHeadphonesMode headphones_rendering_mode
A value that indicates whether the referenced channel-based Audio Element shall be rendered to stereo...
Definition: iamf.h:478
AVStreamGroup::index
unsigned int index
Group index in AVFormatContext.
Definition: avformat.h:1145
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
get_bits.h
AVIAMFLayer::ch_layout
AVChannelLayout ch_layout
Definition: iamf.h:297
ffio_write_leb
void ffio_write_leb(AVIOContext *s, unsigned val)
Definition: aviobuf.c:944
IAMFContext::nb_mix_presentations
int nb_mix_presentations
Definition: iamf.h:134
PutBitContext
Definition: put_bits.h:50
IAMFAudioElement::audio_element_id
unsigned int audio_element_id
Definition: iamf.h:96
AVIAMFDemixingInfo
Demixing Info Parameter Data as defined in section 3.8.2 of IAMF.
Definition: iamf.h:128
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
IAMFSoundSystemMap::layout
AVChannelLayout layout
Definition: iamf.h:164
AV_CHANNEL_ORDER_AMBISONIC
@ AV_CHANNEL_ORDER_AMBISONIC
The audio is represented as the decomposition of the sound field into spherical harmonics.
Definition: channel_layout.h:155
av_clip_int16
#define av_clip_int16
Definition: common.h:115
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
IAMF_OBU_IA_AUDIO_ELEMENT
@ IAMF_OBU_IA_AUDIO_ELEMENT
Definition: iamf.h:39
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVIAMFParamDefinition::duration
unsigned int duration
The accumulated duration of all blocks in this parameter definition, in units of 1 / parameter_rate.
Definition: iamf.h:231
get_audio_element
static IAMFAudioElement * get_audio_element(const IAMFContext *c, unsigned int audio_substream_id)
Definition: iamf_writer.c:1098
ff_iamf_get_codec_config
static IAMFCodecConfig * ff_iamf_get_codec_config(const IAMFContext *c, unsigned int codec_config_id)
Definition: iamf.h:172
AVIAMFLayer
A layer defining a Channel Layout in the Audio Element.
Definition: iamf.h:294
IAMFContext::nb_codec_configs
int nb_codec_configs
Definition: iamf.h:130
IAMF_OBU_IA_CODEC_CONFIG
@ IAMF_OBU_IA_CODEC_CONFIG
Definition: iamf.h:38
IAMFSubStream
Definition: iamf.h:82
IAMFAudioElement::layers
IAMFLayer * layers
Definition: iamf.h:103
ff_iamf_add_mix_presentation
int ff_iamf_add_mix_presentation(IAMFContext *iamf, const AVStreamGroup *stg, void *log_ctx)
Definition: iamf_writer.c:393
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:179
AV_IAMF_ANIMATION_TYPE_LINEAR
@ AV_IAMF_ANIMATION_TYPE_LINEAR
Definition: iamf.h:68
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
IAMFAudioElement::celement
const AVIAMFAudioElement * celement
Definition: iamf.h:90
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
AVIAMFLayer::output_gain_flags
unsigned int output_gain_flags
Output gain channel flags as defined in section 3.6.2 of IAMF.
Definition: iamf.h:310
ff_iamf_expanded_scalable_ch_layouts
const AVChannelLayout ff_iamf_expanded_scalable_ch_layouts[13]
Definition: iamf.c:48
populate_audio_roll_distance
static int populate_audio_roll_distance(IAMFCodecConfig *codec_config)
Definition: iamf_writer.c:80
AVIAMFSubmixElement::audio_element_id
unsigned int audio_element_id
The id of the Audio Element this submix element references.
Definition: iamf.h:452
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
AVIAMFSubmix
Submix layout as defined in section 3.7 of IAMF.
Definition: iamf.h:556
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:450
IAMFLayer
Definition: iamf.h:77
IAMFAudioElement
Definition: iamf.h:89
AVIAMFReconGain::subblock_duration
unsigned int subblock_duration
Duration for the given subblock, in units of 1 / parameter_rate.
Definition: iamf.h:156
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
IAMFCodecConfig::nb_samples
unsigned nb_samples
Definition: iamf.h:70
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:347
IAMFContext::nb_param_definitions
int nb_param_definitions
Definition: iamf.h:136
AVIAMFDemixingInfo::subblock_duration
unsigned int subblock_duration
Duration for the given subblock, in units of 1 / parameter_rate.
Definition: iamf.h:136
AVPacket::size
int size
Definition: packet.h:540
IAMFCodecConfig
Definition: iamf.h:66
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
ff_iamf_sound_system_map
const struct IAMFSoundSystemMap ff_iamf_sound_system_map[14]
Definition: iamf.c:120
IAMFCodecConfig::extradata_size
int extradata_size
Definition: iamf.h:73
IAMFLayer::coupled_substream_count
unsigned int coupled_substream_count
Definition: iamf.h:79
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
ff_iamf_write_parameter_blocks
int ff_iamf_write_parameter_blocks(const IAMFContext *iamf, AVIOContext *pb, const AVPacket *pkt, void *log_ctx)
Definition: iamf_writer.c:1063
AVStreamGroup::iamf_audio_element
struct AVIAMFAudioElement * iamf_audio_element
Definition: avformat.h:1167
iamf_write_mixing_presentation
static int iamf_write_mixing_presentation(const IAMFContext *iamf, const IAMFMixPresentation *mix_presentation, AVIOContext *pb, void *log_ctx)
Definition: iamf_writer.c:766
AV_CODEC_ID_OPUS
@ AV_CODEC_ID_OPUS
Definition: codec_id.h:508
AV_RL16A
#define AV_RL16A(p)
Definition: intreadwrite.h:554
IAMFContext
Definition: iamf.h:128
header
static const uint8_t header[24]
Definition: sdr2.c:68
scalable_channel_layout_config
static int scalable_channel_layout_config(const IAMFAudioElement *audio_element, AVIOContext *dyn_bc)
Definition: iamf_writer.c:556
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:201
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:365
IAMFAudioElement::substreams
IAMFSubStream * substreams
Definition: iamf.h:98
iamf_write_codec_config
static int iamf_write_codec_config(const IAMFContext *iamf, const IAMFCodecConfig *codec_config, AVIOContext *pb)
Definition: iamf_writer.c:472
AVIAMFParamDefinition::constant_subblock_duration
unsigned int constant_subblock_duration
The duration of every subblock in the case where all subblocks, with the optional exception of the la...
Definition: iamf.h:238
AVIAMFAudioElement
Information on how to combine one or more audio streams, as defined in section 3.6 of IAMF.
Definition: iamf.h:356
avio_wl32
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:357
AVIAMFMixGain
Mix Gain Parameter Data as defined in section 3.8.1 of IAMF.
Definition: iamf.h:77
AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
@ AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
Definition: avformat.h:1125
AVStreamGroup::streams
AVStream ** streams
A list of streams in the group.
Definition: avformat.h:1201
AVStreamGroup::iamf_mix_presentation
struct AVIAMFMixPresentation * iamf_mix_presentation
Definition: avformat.h:1168
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:809
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
get_bits64
static uint64_t get_bits64(GetBitContext *s, int n)
Read 0-64 bits.
Definition: get_bits.h:453
IAMFContext::param_definitions
IAMFParamDefinition ** param_definitions
Definition: iamf.h:135
bprint.h
IAMFContext::nb_audio_elements
int nb_audio_elements
Definition: iamf.h:132
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVIAMFParamDefinition::parameter_id
unsigned int parameter_id
Identifier for the paremeter substream.
Definition: iamf.h:218
avio_internal.h
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: packet.c:253
AVIAMFMixPresentation
Information on how to render and mix one or more AVIAMFAudioElement to generate the final audio outpu...
Definition: iamf.h:613
param_definition
static int param_definition(const IAMFContext *iamf, const IAMFParamDefinition *param_def, AVIOContext *dyn_bc, void *log_ctx)
Definition: iamf_writer.c:622
AV_WB16A
#define AV_WB16A(p, v)
Definition: intreadwrite.h:564
IAMFContext::codec_configs
IAMFCodecConfig ** codec_configs
Definition: iamf.h:129
AV_CODEC_ID_PCM_S32BE
@ AV_CODEC_ID_PCM_S32BE
Definition: codec_id.h:344
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
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
IAMF_OBU_IA_AUDIO_FRAME
@ IAMF_OBU_IA_AUDIO_FRAME
Definition: iamf.h:43
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AVIAMFParamDefinition::nb_subblocks
unsigned int nb_subblocks
Number of subblocks in the array.
Definition: iamf.h:208
AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE
@ AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE
Definition: iamf.h:346
AV_WB32A
#define AV_WB32A(p, v)
Definition: intreadwrite.h:578
AV_WB8
#define AV_WB8(p, d)
Definition: intreadwrite.h:392
ff_iamf_write_audio_frame
int ff_iamf_write_audio_frame(const IAMFContext *iamf, AVIOContext *pb, unsigned audio_substream_id, const AVPacket *pkt)
Definition: iamf_writer.c:1113
ff_iamf_write_descriptors
int ff_iamf_write_descriptors(const IAMFContext *iamf, AVIOContext *pb, void *log_ctx)
Definition: iamf_writer.c:905
AVIAMFSubmix::nb_layouts
unsigned int nb_layouts
Number of layouts in the submix.
Definition: iamf.h:587
ambisonics_config
static int ambisonics_config(const IAMFAudioElement *audio_element, AVIOContext *dyn_bc)
Definition: iamf_writer.c:602
tag
uint32_t tag
Definition: movenc.c:1879
ffio_free_dyn_buf
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1435
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:760
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
ff_iamf_free_audio_element
void ff_iamf_free_audio_element(IAMFAudioElement **paudio_element)
Definition: iamf.c:143
avformat.h
IAMF_OBU_IA_AUDIO_FRAME_ID0
@ IAMF_OBU_IA_AUDIO_FRAME_ID0
Definition: iamf.h:44
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
AVStreamGroup
Definition: avformat.h:1134
IAMFMixPresentation
Definition: iamf.h:107
AV_CHANNEL_ORDER_CUSTOM
@ AV_CHANNEL_ORDER_CUSTOM
The channel order does not correspond to any other predefined order and is stored as an explicit map.
Definition: channel_layout.h:132
AVStreamGroup::nb_streams
unsigned int nb_streams
Number of elements in AVStreamGroup.streams.
Definition: avformat.h:1188
channel_layout.h
AVIAMFSubmix::default_mix_gain
AVRational default_mix_gain
Default mix gain value to apply when there are no AVIAMFParamDefinition with output_mix_config's para...
Definition: iamf.h:603
AVIAMFSubmixLayout::album_anchored_loudness
AVRational album_anchored_loudness
The Album loudness information, as defined in ITU-1770-4.
Definition: iamf.h:547
AVIAMFSubmixLayout::true_peak
AVRational true_peak
The true peak of the audio signal, as defined in ITU-1770-4.
Definition: iamf.h:539
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVIAMFSubmixLayout::sound_system
AVChannelLayout sound_system
Channel layout matching one of Sound Systems A to J of ITU-2051-3, plus 7.1.2ch, 3....
Definition: iamf.h:525
IAMFCodecConfig::codec_id
enum AVCodecID codec_id
Definition: iamf.h:68
IAMFCodecConfig::codec_config_id
unsigned codec_config_id
Definition: iamf.h:67
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:153
IAMF_ANCHOR_ELEMENT_DIALOGUE
@ IAMF_ANCHOR_ELEMENT_DIALOGUE
Definition: iamf.h:141
AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN
@ AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN
Subblocks are of struct type AVIAMFMixGain.
Definition: iamf.h:173
AV_RL32A
#define AV_RL32A(p)
Definition: intreadwrite.h:568
MAX_IAMF_OBU_HEADER_SIZE
#define MAX_IAMF_OBU_HEADER_SIZE
Definition: iamf.h:34
av_clip_uint8
#define av_clip_uint8
Definition: common.h:106
AVIAMFSubmix::nb_elements
unsigned int nb_elements
Number of elements in the submix.
Definition: iamf.h:572
AV_CODEC_ID_PCM_S32LE
@ AV_CODEC_ID_PCM_S32LE
Definition: codec_id.h:343
AVIAMFAudioElement::demixing_info
AVIAMFParamDefinition * demixing_info
Demixing information used to reconstruct a scalable channel audio representation.
Definition: iamf.h:376
AVIAMFDemixingInfo::dmixp_mode
unsigned int dmixp_mode
Pre-defined combination of demixing parameters.
Definition: iamf.h:140
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:595
AVStreamGroup::type
enum AVStreamGroupParamsType type
Group type.
Definition: avformat.h:1161
IAMFContext::mix_presentations
IAMFMixPresentation ** mix_presentations
Definition: iamf.h:133
AVIAMFLayer::ambisonics_mode
enum AVIAMFAmbisonicsMode ambisonics_mode
Ambisonics mode as defined in section 3.6.3 of IAMF.
Definition: iamf.h:328
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
avio_wb24
void avio_wb24(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:455
AV_IAMF_SUBMIX_LAYOUT_TYPE_BINAURAL
@ AV_IAMF_SUBMIX_LAYOUT_TYPE_BINAURAL
The layout is binaural.
Definition: iamf.h:505
AVIAMFLayer::flags
unsigned int flags
A bitmask which may contain a combination of AV_IAMF_LAYER_FLAG_* flags.
Definition: iamf.h:302
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
AVIAMFLayer::output_gain
AVRational output_gain
Output gain as defined in section 3.6.2 of IAMF.
Definition: iamf.h:316
AV_IAMF_AMBISONICS_MODE_PROJECTION
@ AV_IAMF_AMBISONICS_MODE_PROJECTION
Definition: iamf.h:274
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:516
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
iamf.h
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:461
AVIAMFParamDefinition::parameter_rate
unsigned int parameter_rate
Sample rate for the paremeter substream.
Definition: iamf.h:222
ff_iamf_scalable_ch_layouts
const AVChannelLayout ff_iamf_scalable_ch_layouts[10]
Definition: iamf.c:27
AVChannelLayout::u
union AVChannelLayout::@434 u
Details about which channels are present in this layout.
AVIAMFSubmixElement
Submix element as defined in section 3.7 of IAMF.
Definition: iamf.h:446
avio_wb16
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:443
AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL
@ AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL
Definition: iamf.h:345
IAMFAudioElement::codec_config_id
unsigned int codec_config_id
Definition: iamf.h:101
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
AVIAMFAudioElement::recon_gain_info
AVIAMFParamDefinition * recon_gain_info
Recon gain information used to reconstruct a scalable channel audio representation.
Definition: iamf.h:383
avio_put_str
int avio_put_str(AVIOContext *s, const char *str)
Write a NULL-terminated string.
Definition: aviobuf.c:373
put_bits.h
IAMFCodecConfig::audio_roll_distance
int audio_roll_distance
Definition: iamf.h:71
AVIAMFMixPresentation::submixes
AVIAMFSubmix ** submixes
Array of submixes.
Definition: iamf.h:622
IAMFMixPresentation::mix_presentation_id
unsigned int mix_presentation_id
Definition: iamf.h:114
AVIAMFReconGain::recon_gain
uint8_t recon_gain[6][12]
Array of gain values to be applied to each channel for each layer defined in the Audio Element refere...
Definition: iamf.h:166
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:348
AV_PKT_DATA_IAMF_MIX_GAIN_PARAM
@ AV_PKT_DATA_IAMF_MIX_GAIN_PARAM
IAMF Mix Gain Parameter Data associated with the audio frame.
Definition: packet.h:304
AVChannelCustom::id
enum AVChannel id
Definition: channel_layout.h:284
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:44
AV_IAMF_PARAMETER_DEFINITION_DEMIXING
@ AV_IAMF_PARAMETER_DEFINITION_DEMIXING
Subblocks are of struct type AVIAMFDemixingInfo.
Definition: iamf.h:177
iamf_write_audio_element
static int iamf_write_audio_element(const IAMFContext *iamf, const IAMFAudioElement *audio_element, AVIOContext *pb, void *log_ctx)
Definition: iamf_writer.c:663
iamf_writer.h
AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM
@ AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM
IAMF Demixing Info Parameter Data associated with the audio frame.
Definition: packet.h:312