FFmpeg: libavutil/iamf.c Source File

FFmpeg

[フレーム]

libavutil

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 */

21 #include <limits.h>

22 #include <stddef.h>

23 #include <stdint.h>

25 #include "avassert.h"

26 #include "error.h"

27 #include "iamf.h"

28 #include "log.h"

29 #include "mem.h"

30 #include "opt.h"

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 }

60 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM

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_UINT, {.i64 = 1 }, 1, UINT_MAX, FLAGS },

68 { "animation_type", "set animation_type", OFFSET(animation_type), AV_OPT_TYPE_UINT, {.i64 = 0 }, 0, 2, FLAGS },

69 { "start_point_value", "set start_point_value", OFFSET(start_point_value), AV_OPT_TYPE_RATIONAL, {.dbl = 0 }, -128.0, 128.0, FLAGS },

70 { "end_point_value", "set end_point_value", OFFSET(end_point_value), AV_OPT_TYPE_RATIONAL, {.dbl = 0 }, -128.0, 128.0, FLAGS },

71 { "control_point_value", "set control_point_value", OFFSET(control_point_value), AV_OPT_TYPE_RATIONAL, {.dbl = 0 }, -128.0, 128.0, FLAGS },

72 { "control_point_relative_time", "set control_point_relative_time", OFFSET(control_point_relative_time), AV_OPT_TYPE_RATIONAL, {.dbl = 0 }, 0.0, 1.0, FLAGS },

73 { NULL },

74 };

76 static const AVClass mix_gain_class = {

77 .class_name = "AVIAMFMixGain",

78 .item_name = av_default_item_name,

79 .version = LIBAVUTIL_VERSION_INT,

80 .option = mix_gain_options,

81 };

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_UINT, {.i64 = 1 }, 1, UINT_MAX, FLAGS },

87 { "dmixp_mode", "set dmixp_mode", OFFSET(dmixp_mode), AV_OPT_TYPE_UINT, {.i64 = 0 }, 0, 6, FLAGS },

88 { NULL },

89 };

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 };

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_UINT, {.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)

114 static const AVOption param_definition_options[] = {

115 { "parameter_id", "set parameter_id", OFFSET(parameter_id), AV_OPT_TYPE_UINT, {.i64 = 0 }, 0, UINT_MAX, FLAGS },

116 { "parameter_rate", "set parameter_rate", OFFSET(parameter_rate), AV_OPT_TYPE_UINT, {.i64 = 0 }, 0, UINT_MAX, FLAGS },

117 { "duration", "set duration", OFFSET(duration), AV_OPT_TYPE_UINT, {.i64 = 0 }, 0, UINT_MAX, FLAGS },

118 { "constant_subblock_duration", "set constant_subblock_duration", OFFSET(constant_subblock_duration), AV_OPT_TYPE_UINT, {.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) {

128 case AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN:

129 ret = &mix_gain_class;

130 break;

131 case AV_IAMF_PARAMETER_DEFINITION_DEMIXING:

132 ret = &demixing_info_class;

133 break;

134 case AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN:

135 ret = &recon_gain_class;

136 break;

137 default:

138 break;

139 }

140

141 if (ret)

142 *opaque = (void*)(i + 1);

143 return ret;

144 }

145

146 static const AVClass param_definition_class = {

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

154 const AVClass *av_iamf_param_definition_get_class(void)

155 {

156 return &param_definition_class;

157 }

158

159 AVIAMFParamDefinition *av_iamf_param_definition_alloc(enum AVIAMFParamDefinitionType type,

160 unsigned int nb_subblocks, size_t *out_size)

161 {

162

163 struct MixGainStruct {

164 AVIAMFParamDefinition p;

165 AVIAMFMixGain m;

166 };

167 struct DemixStruct {

168 AVIAMFParamDefinition p;

169 AVIAMFDemixingInfo d;

170 };

171 struct ReconGainStruct {

172 AVIAMFParamDefinition p;

173 AVIAMFReconGain r;

174 };

175 size_t subblocks_offset, subblock_size;

176 size_t size;

177 AVIAMFParamDefinition *par;

178

179 switch (type) {

180 case AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN:

181 subblocks_offset = offsetof(struct MixGainStruct, m);

182 subblock_size = sizeof(AVIAMFMixGain);

183 break;

184 case AV_IAMF_PARAMETER_DEFINITION_DEMIXING:

185 subblocks_offset = offsetof(struct DemixStruct, d);

186 subblock_size = sizeof(AVIAMFDemixingInfo);

187 break;

188 case AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN:

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

205 par->av_class = &param_definition_class;

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) {

217 case AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN:

218 ((AVIAMFMixGain *)subblock)->av_class = &mix_gain_class;

219 break;

220 case AV_IAMF_PARAMETER_DEFINITION_DEMIXING:

221 ((AVIAMFDemixingInfo *)subblock)->av_class = &demixing_info_class;

222 break;

223 case AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN:

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 },

267 AV_IAMF_AMBISONICS_MODE_MONO, AV_IAMF_AMBISONICS_MODE_PROJECTION, FLAGS, .unit = "ambisonics_mode" },

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,

286 {.i64 = AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL },

287 AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL, AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE, FLAGS, .unit = "audio_element_type" },

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_UINT, {.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

317 const AVClass *av_iamf_audio_element_get_class(void)

318 {

319 return &audio_element_class;

320 }

321

322 AVIAMFAudioElement *av_iamf_audio_element_alloc(void)

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

334 IAMF_ADD_FUNC_TEMPLATE(AVIAMFAudioElement, audio_element, AVIAMFLayer, layer, s)

335

336 void av_iamf_audio_element_free(AVIAMFAudioElement **paudio_element)

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)

361 static const AVOption submix_element_options[] = {

362 { "headphones_rendering_mode", "Headphones rendering mode", OFFSET(headphones_rendering_mode), AV_OPT_TYPE_INT,

363 { .i64 = AV_IAMF_HEADPHONES_MODE_STEREO },

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)

389 ret = &param_definition_class;

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

405 IAMF_ADD_FUNC_TEMPLATE(AVIAMFSubmix, submix, AVIAMFSubmixElement, element, s)

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,

411 { .i64 = AV_IAMF_SUBMIX_LAYOUT_TYPE_LOUDSPEAKERS },

412 AV_IAMF_SUBMIX_LAYOUT_TYPE_LOUDSPEAKERS, AV_IAMF_SUBMIX_LAYOUT_TYPE_BINAURAL, FLAGS, .unit = "layout_type" },

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

433 IAMF_ADD_FUNC_TEMPLATE(AVIAMFSubmix, submix, AVIAMFSubmixLayout, layout, s)

434

435 #undef OFFSET

436 #define OFFSET(x) offsetof(AVIAMFSubmix, x)

437 static const AVOption submix_presentation_options[] = {

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:

464 ret = &param_definition_class;

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)

486 static const AVOption mix_presentation_options[] = {

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

507 static const AVClass mix_presentation_class = {

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

515 const AVClass *av_iamf_mix_presentation_get_class(void)

516 {

517 return &mix_presentation_class;

518 }

519

520 AVIAMFMixPresentation *av_iamf_mix_presentation_alloc(void)

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

534 void av_iamf_mix_presentation_free(AVIAMFMixPresentation **pmix_presentation)

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 }

flags

const SwsFlags flags[]

Definition: swscale.c:61

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: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

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:1678

AVIAMFSubmix::layouts

AVIAMFSubmixLayout ** layouts

Array of submix layouts.

Definition: iamf.h:580

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:359

AVIAMFMixPresentation::nb_submixes

unsigned int nb_submixes

Number of submixes in the presentation.

Definition: iamf.h:629

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:213

AVOption

AVOption.

Definition: opt.h:429

AV_IAMF_HEADPHONES_MODE_STEREO

@ AV_IAMF_HEADPHONES_MODE_STEREO

The referenced Audio Element shall be rendered to stereo loudspeakers.

Definition: iamf.h:433

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:193

AV_OPT_TYPE_RATIONAL

@ AV_OPT_TYPE_RATIONAL

Underlying C type is AVRational.

Definition: opt.h:280

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:514

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:1949

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:148

AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN

@ AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN

Subblocks are of struct type AVIAMFReconGain.

Definition: iamf.h:181

FLAGS

#define FLAGS

Definition: iamf.c:60

avassert.h

duration

int64_t duration

Definition: movenc.c:65

#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:260

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:41

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:437

AVIAMFDemixingInfo

Demixing Info Parameter Data as defined in section 3.8.2 of IAMF.

Definition: iamf.h:128

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:76

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

Underlying C type is AVDictionary*.

Definition: opt.h:290

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:241

AVIAMFLayer

A layer defining a Channel Layout in the Audio Element.

Definition: iamf.h:294

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:200

AV_IAMF_AMBISONICS_MODE_MONO

@ AV_IAMF_AMBISONICS_MODE_MONO

Definition: iamf.h:273

AV_OPT_TYPE_UINT

@ AV_OPT_TYPE_UINT

Underlying C type is unsigned int.

Definition: opt.h:335

AV_OPT_TYPE_CHLAYOUT

@ AV_OPT_TYPE_CHLAYOUT

Underlying C type is AVChannelLayout.

Definition: opt.h:331

error.h

AVIAMFSubmix

Submix layout as defined in section 3.7 of IAMF.

Definition: iamf.h:556

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:356

AVIAMFMixGain

Mix Gain Parameter Data as defined in section 3.8.1 of IAMF.

Definition: iamf.h:77

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:194

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

#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:340

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:357

AVIAMFMixPresentation

Information on how to render and mix one or more AVIAMFAudioElement to generate the final audio outpu...

Definition: iamf.h:613

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:208

AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE

@ AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE

Definition: iamf.h:346

AVIAMFSubmix::nb_layouts

unsigned int nb_layouts

Number of layouts in the submix.

Definition: iamf.h:587

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:81

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

Underlying C type is int.

Definition: opt.h:259

AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN

@ AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN

Subblocks are of struct type AVIAMFMixGain.

Definition: iamf.h:173

Windows::Graphics::DirectX::Direct3D11::p

IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p

Definition: vsrc_gfxcapture_winrt.hpp:53

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:572

AVIAMFAudioElement::demixing_info

AVIAMFParamDefinition * demixing_info

Demixing information used to reconstruct a scalable channel audio representation.

Definition: iamf.h:376

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

AVIAMFParamDefinitionType

Definition: iamf.h:169

AV_IAMF_SUBMIX_LAYOUT_TYPE_BINAURAL

@ AV_IAMF_SUBMIX_LAYOUT_TYPE_BINAURAL

The layout is binaural.

Definition: iamf.h:505

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

AV_IAMF_AMBISONICS_MODE_PROJECTION

@ AV_IAMF_AMBISONICS_MODE_PROJECTION

Definition: iamf.h:274

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

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

AV_OPT_TYPE_FLAGS

@ AV_OPT_TYPE_FLAGS

Underlying C type is unsigned int.

Definition: opt.h:255

AVIAMFSubmixElement

Submix element as defined in section 3.7 of IAMF.

Definition: iamf.h:446

AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL

@ AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL

Definition: iamf.h:345

AVIAMFParamDefinition::subblock_size

size_t subblock_size

Size in bytes of each element in the subblocks array.

Definition: iamf.h:204

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:383

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:622

AV_OPT_TYPE_CONST

@ AV_OPT_TYPE_CONST

Special option type for declaring named constants.

Definition: opt.h:299

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:614

AV_IAMF_PARAMETER_DEFINITION_DEMIXING

@ AV_IAMF_PARAMETER_DEFINITION_DEMIXING

Subblocks are of struct type AVIAMFDemixingInfo.

Definition: iamf.h:177

layer_options

static const AVOption layer_options[]

Definition: iamf.c:244

Generated on Tue Nov 18 2025 19:23:27 for FFmpeg by doxygen 1.8.17