FFmpeg
Loading...
Searching...
No Matches
mxfdec.c
Go to the documentation of this file.
1/*
2 * MXF demuxer.
3 * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot 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/*
23 * References
24 * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
25 * SMPTE 377M MXF File Format Specifications
26 * SMPTE 378M Operational Pattern 1a
27 * SMPTE 379M MXF Generic Container
28 * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
29 * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
30 * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
31 * SMPTE 2067-21 Interoperable Master Format — Application #2E
32 *
33 * Principle
34 * Search for Track numbers which will identify essence element KLV packets.
35 * Search for SourcePackage which define tracks which contains Track numbers.
36 * Material Package contains tracks with reference to SourcePackage tracks.
37 * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
38 * Assign Descriptors to correct Tracks.
39 *
40 * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
41 * Metadata parsing resolves Strong References to objects.
42 *
43 * Simple demuxer, only OP1A supported and some files might not work at all.
44 * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
45 */
46
47#include <inttypes.h>
48#include <time.h>
49
50#include "libavutil/aes.h"
51#include "libavutil/attributes.h"
52#include "libavutil/avstring.h"
53#include "libavutil/mastering_display_metadata.h"
54#include "libavutil/mathematics.h"
55#include "libavutil/mem.h"
56#include "libavcodec/bytestream.h"
57#include "libavcodec/defs.h"
58#include "libavcodec/internal.h"
59#include "libavutil/channel_layout.h"
60#include "libavutil/intreadwrite.h"
61#include "libavutil/parseutils.h"
62#include "libavutil/timecode.h"
63#include "libavutil/opt.h"
64#include "avformat.h"
65#include "avlanguage.h"
66#include "avio_internal.h"
67#include "demux.h"
68#include "internal.h"
69#include "mxf.h"
70
71#define MXF_MAX_CHUNK_SIZE (32 << 20)
72#define RUN_IN_MAX (65535+1) // S377m-2004 section 5.5 and S377-1-2009 section 6.5, the +1 is to be slightly more tolerant
73
79
80typedef enum {
81 OP1a = 1,
82 OP1b,
83 OP1c,
84 OP2a,
85 OP2b,
86 OP2c,
87 OP3a,
88 OP3b,
89 OP3c,
90 OPAtom,
91 OPSONYOpt, /* FATE sample, violates the spec in places */
92} MXFOP;
93
99
117
122
127
132
142
150
158
163
170
171typedef struct {
172 MXFMetadataSet meta;
173 char *name;
174 char *value;
175} MXFTaggedValue;
176
177typedef struct {
178 MXFMetadataSet meta;
179 MXFSequence *sequence; /* mandatory, and only one */
180 UID sequence_ref;
181 int track_id;
182 char *name;
183 uint8_t track_number[4];
184 AVRational edit_rate;
185 int intra_only;
186 uint64_t sample_count;
187 int64_t original_duration; /* st->duration in SampleRate/EditRate units */
188 int index_sid;
189 int body_sid;
190 MXFWrappingScheme wrapping;
191 int edit_units_per_packet; /* how many edit units to read at a time (PCM, ClipWrapped) */
192 int64_t origin;
193} MXFTrack;
194
195typedef struct MXFDescriptor {
196 MXFMetadataSet meta;
197 UID essence_container_ul;
198 UID essence_codec_ul;
199 UID codec_ul;
200 AVRational sample_rate;
201 AVRational aspect_ratio;
202 int width;
203 int height; /* Field height, not frame height */
204 int frame_layout; /* See MXFFrameLayout enum */
205 int video_line_map[2];
206#define MXF_FIELD_DOMINANCE_DEFAULT 0
207#define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */
208#define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */
209 int field_dominance;
210 int channels;
211 int bits_per_sample;
212 int64_t duration; /* ContainerDuration optional property */
213 unsigned int component_depth;
214 unsigned int black_ref_level;
215 unsigned int white_ref_level;
216 unsigned int color_range;
217 unsigned int horiz_subsampling;
218 unsigned int vert_subsampling;
219 UID *file_descriptors_refs;
220 int file_descriptors_count;
221 UID *sub_descriptors_refs;
222 int sub_descriptors_count;
223 int linked_track_id;
224 uint8_t *extradata;
225 int extradata_size;
226 enum AVPixelFormat pix_fmt;
227 UID color_primaries_ul;
228 UID color_trc_ul;
229 UID color_space_ul;
230 AVMasteringDisplayMetadata *mastering;
231 size_t mastering_size;
232 AVContentLightMetadata *coll;
233 size_t coll_size;
234} MXFDescriptor;
235
247
253
268
280
288
289/* decoded index table */
290typedef struct MXFIndexTable {
291 int index_sid;
292 int body_sid;
293 int nb_ptses; /* number of PTSes or total duration of index */
294 int64_t first_dts; /* DTS = EditUnit + first_dts */
295 int64_t *ptses; /* maps EditUnit -> PTS */
296 int nb_segments;
297 MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
298 AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
299 int8_t *offsets; /* temporal offsets for display order to stored order conversion */
300} MXFIndexTable;
301
327
328/* NOTE: klv_offset is not set (-1) for local keys */
329typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
330
337
338/* partial keys to match */
339static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
340static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
341static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
342static const uint8_t mxf_canopus_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };
343static const uint8_t mxf_system_item_key_cp[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
344static const uint8_t mxf_system_item_key_gc[] = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };
345static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
346static const uint8_t mxf_apple_coll_prefix[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01 };
347
348/* complete keys to match */
349static const uint8_t mxf_crypto_source_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x02,0x02,0x00,0x00,0x00 };
350static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
351static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
352static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
353static const uint8_t mxf_ffv1_extradata[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x04,0x01,0x06,0x0c,0x01,0x00,0x00,0x00 }; // FFV1InitializationMetadata
354static const uint8_t mxf_avid_project_name[] = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
355static const uint8_t mxf_jp2k_rsiz[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x01,0x00,0x00,0x00 };
356static const uint8_t mxf_indirect_value_utf16le[] = { 0x4c,0x00,0x02,0x10,0x01,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
357static const uint8_t mxf_indirect_value_utf16be[] = { 0x42,0x01,0x10,0x02,0x00,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
358static const uint8_t mxf_apple_coll_max_cll[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01,0x01 };
359static const uint8_t mxf_apple_coll_max_fall[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01,0x02 };
360
361static const uint8_t mxf_mca_label_dictionary_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x01,0x00,0x00,0x00 };
362static const uint8_t mxf_mca_tag_symbol[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x02,0x00,0x00,0x00 };
363static const uint8_t mxf_mca_tag_name[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x03,0x00,0x00,0x00 };
364static const uint8_t mxf_group_of_soundfield_groups_link_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x04,0x00,0x00,0x00 };
365static const uint8_t mxf_mca_link_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x05,0x00,0x00,0x00 };
366static const uint8_t mxf_mca_channel_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x04,0x0a,0x00,0x00,0x00,0x00 };
367static const uint8_t mxf_soundfield_group_link_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x06,0x00,0x00,0x00 };
368static const uint8_t mxf_mca_rfc5646_spoken_language[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0d,0x03,0x01,0x01,0x02,0x03,0x15,0x00,0x00 };
369
370static const uint8_t mxf_sub_descriptor[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x04,0x06,0x10,0x00,0x00 };
371
372static const uint8_t mxf_mastering_display_prefix[13] = { FF_MXF_MasteringDisplay_PREFIX };
379
380#define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
381
382static void mxf_free_metadataset(MXFMetadataSet **ctx, enum MXFMetadataSetType type)
383{
384 MXFIndexTableSegment *seg;
385 switch (type) {
386 case Descriptor:
387 case MultipleDescriptor:
388 av_freep(&((MXFDescriptor *)*ctx)->extradata);
389 av_freep(&((MXFDescriptor *)*ctx)->mastering);
390 av_freep(&((MXFDescriptor *)*ctx)->coll);
391 av_freep(&((MXFDescriptor *)*ctx)->file_descriptors_refs);
392 av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
393 break;
394 case FFV1SubDescriptor:
395 av_freep(&((MXFFFV1SubDescriptor *)*ctx)->extradata);
396 break;
397 case AudioChannelLabelSubDescriptor:
398 case SoundfieldGroupLabelSubDescriptor:
399 case GroupOfSoundfieldGroupsLabelSubDescriptor:
400 av_freep(&((MXFMCASubDescriptor *)*ctx)->language);
401 av_freep(&((MXFMCASubDescriptor *)*ctx)->group_of_soundfield_groups_link_id_refs);
402 break;
403 case Sequence:
404 av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
405 break;
406 case EssenceGroup:
407 av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
408 break;
409 case SourcePackage:
410 case MaterialPackage:
411 av_freep(&((MXFPackage *)*ctx)->tracks_refs);
412 av_freep(&((MXFPackage *)*ctx)->name);
413 av_freep(&((MXFPackage *)*ctx)->comment_refs);
414 break;
415 case TaggedValue:
416 av_freep(&((MXFTaggedValue *)*ctx)->name);
417 av_freep(&((MXFTaggedValue *)*ctx)->value);
418 break;
419 case Track:
420 av_freep(&((MXFTrack *)*ctx)->name);
421 break;
422 case IndexTableSegment:
423 seg = (MXFIndexTableSegment *)*ctx;
424 av_freep(&seg->temporal_offset_entries);
425 av_freep(&seg->flag_entries);
426 av_freep(&seg->stream_offset_entries);
427 break;
428 default:
429 break;
430 }
431 av_freep(ctx);
432}
433
434static int64_t klv_decode_ber_length(AVIOContext *pb, int *llen)
435{
436 uint64_t size = avio_r8(pb);
437 if (size & 0x80) { /* long form */
438 int bytes_num = size & 0x7f;
439 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
440 if (bytes_num > 8)
441 return AVERROR_INVALIDDATA;
442 if (llen)
443 *llen = bytes_num + 1;
444 size = 0;
445 while (bytes_num--)
446 size = size << 8 | avio_r8(pb);
447 } else if (llen) {
448 *llen = 1;
449 }
450 if (size > INT64_MAX)
451 return AVERROR_INVALIDDATA;
452 return size;
453}
454
455static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
456{
457 int i, b;
458 for (i = 0; i < size && !avio_feof(pb); i++) {
459 b = avio_r8(pb);
460 if (b == key[0])
461 i = 0;
462 else if (b != key[i])
463 i = -1;
464 }
465 return i == size;
466}
467
468// special case of mxf_read_sync for mxf_klv_key
469static int mxf_read_sync_klv(AVIOContext *pb)
470{
471 uint32_t key = avio_rb32(pb);
472 // key will never match mxf_klv_key on EOF
473 if (key == AV_RB32(mxf_klv_key))
474 return 1;
475
476 while (!avio_feof(pb)) {
477 key = (key << 8) | avio_r8(pb);
478 if (key == AV_RB32(mxf_klv_key))
479 return 1;
480 }
481 return 0;
482}
483
484static int klv_read_packet(MXFContext *mxf, KLVPacket *klv, AVIOContext *pb)
485{
486 int64_t length, pos;
487 int llen;
488
489 if (!mxf_read_sync_klv(pb))
490 return AVERROR_INVALIDDATA;
491 klv->offset = avio_tell(pb) - 4;
492 if (klv->offset < mxf->run_in)
493 return AVERROR_INVALIDDATA;
494
495 memcpy(klv->key, mxf_klv_key, 4);
496 int ret = ffio_read_size(pb, klv->key + 4, 12);
497 if (ret < 0)
498 return ret;
499 length = klv_decode_ber_length(pb, &llen);
500 if (length < 0)
501 return length;
502 klv->length = length;
503 if (klv->offset > INT64_MAX - 16 - llen)
504 return AVERROR_INVALIDDATA;
505
506 pos = klv->offset + 16 + llen;
507 if (pos > INT64_MAX - length)
508 return AVERROR_INVALIDDATA;
509 klv->next_klv = pos + length;
510 return 0;
511}
512
513static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
514{
515 for (int i = 0; i < s->nb_streams; i++) {
516 MXFTrack *track = s->streams[i]->priv_data;
517 /* SMPTE 379M 7.3 */
518 if (track && (!body_sid || !track->body_sid || track->body_sid == body_sid) && !memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
519 return i;
520 }
521 /* return 0 if only one stream, for OP Atom files with 0 as track number */
522 return s->nb_streams == 1 && s->streams[0]->priv_data ? 0 : -1;
523}
524
525static int find_body_sid_by_absolute_offset(MXFContext *mxf, int64_t offset)
526{
527 // we look for partition where the offset is placed
528 int a, b, m;
529 int64_t pack_ofs;
530
531 a = -1;
532 b = mxf->partitions_count;
533
534 while (b - a > 1) {
535 m = (a + b) >> 1;
536 pack_ofs = mxf->partitions[m].pack_ofs;
537 if (pack_ofs <= offset)
538 a = m;
539 else
540 b = m;
541 }
542
543 if (a == -1)
544 return 0;
545 return mxf->partitions[a].body_sid;
546}
547
548static int mxf_get_eia608_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt, int64_t length)
549{
550 int count = avio_rb16(s->pb);
551 int cdp_identifier, cdp_length, cdp_footer_id, ccdata_id, cc_count;
552 int line_num, sample_coding, sample_count;
553 int did, sdid, data_length;
554 int ret;
555
556 if (count > 1)
557 av_log(s, AV_LOG_WARNING, "unsupported multiple ANC packets (%d) per KLV packet\n", count);
558
559 for (int i = 0; i < count; i++) {
560 if (length < 6) {
561 av_log(s, AV_LOG_ERROR, "error reading s436m packet %"PRId64"\n", length);
562 return AVERROR_INVALIDDATA;
563 }
564 line_num = avio_rb16(s->pb);
565 avio_r8(s->pb); // wrapping type
566 sample_coding = avio_r8(s->pb);
567 sample_count = avio_rb16(s->pb);
568 length -= 6 + 8 + sample_count;
569 if (line_num != 9 && line_num != 11)
570 continue;
571 if (sample_coding == 7 || sample_coding == 8 || sample_coding == 9) {
572 av_log(s, AV_LOG_WARNING, "unsupported s436m 10 bit sample coding\n");
573 continue;
574 }
575 if (length < 0)
576 return AVERROR_INVALIDDATA;
577
578 avio_rb32(s->pb); // array count
579 avio_rb32(s->pb); // array elem size
580 did = avio_r8(s->pb);
581 sdid = avio_r8(s->pb);
582 data_length = avio_r8(s->pb);
583 if (did != 0x61 || sdid != 1) {
584 av_log(s, AV_LOG_WARNING, "unsupported did or sdid: %x %x\n", did, sdid);
585 continue;
586 }
587 cdp_identifier = avio_rb16(s->pb); // cdp id
588 if (cdp_identifier != 0x9669) {
589 av_log(s, AV_LOG_ERROR, "wrong cdp identifier %x\n", cdp_identifier);
590 return AVERROR_INVALIDDATA;
591 }
592 cdp_length = avio_r8(s->pb);
593 avio_r8(s->pb); // cdp_frame_rate
594 avio_r8(s->pb); // cdp_flags
595 avio_rb16(s->pb); // cdp_hdr_sequence_cntr
596 ccdata_id = avio_r8(s->pb); // ccdata_id
597 if (ccdata_id != 0x72) {
598 av_log(s, AV_LOG_ERROR, "wrong cdp data section %x\n", ccdata_id);
599 return AVERROR_INVALIDDATA;
600 }
601 cc_count = avio_r8(s->pb) & 0x1f;
602 ret = av_get_packet(s->pb, pkt, cc_count * 3);
603 if (ret < 0)
604 return ret;
605 if (cdp_length - 9 - 4 < cc_count * 3) {
606 av_log(s, AV_LOG_ERROR, "wrong cdp size %d cc count %d\n", cdp_length, cc_count);
607 return AVERROR_INVALIDDATA;
608 }
609 avio_skip(s->pb, data_length - 9 - 4 - cc_count * 3);
610 cdp_footer_id = avio_r8(s->pb);
611 if (cdp_footer_id != 0x74) {
612 av_log(s, AV_LOG_ERROR, "wrong cdp footer section %x\n", cdp_footer_id);
613 return AVERROR_INVALIDDATA;
614 }
615 avio_rb16(s->pb); // cdp_ftr_sequence_cntr
616 avio_r8(s->pb); // packet_checksum
617 break;
618 }
619
620 return 0;
621}
622
623/* XXX: use AVBitStreamFilter */
624static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
625{
626 const uint8_t *buf_ptr, *end_ptr;
627 uint8_t *data_ptr;
628
629 if (length > 61444) /* worst case PAL 1920 samples 8 channels */
630 return AVERROR_INVALIDDATA;
631 length = av_get_packet(pb, pkt, length);
632 if (length < 0)
633 return length;
634 data_ptr = pkt->data;
635 end_ptr = pkt->data + length;
636 buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
637
638 if (st->codecpar->ch_layout.nb_channels > 8)
639 return AVERROR_INVALIDDATA;
640
641 for (; end_ptr - buf_ptr >= st->codecpar->ch_layout.nb_channels * 4; ) {
642 for (int i = 0; i < st->codecpar->ch_layout.nb_channels; i++) {
643 uint32_t sample = bytestream_get_le32(&buf_ptr);
644 if (st->codecpar->bits_per_coded_sample == 24)
645 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
646 else
647 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
648 }
649 // always 8 channels stored SMPTE 331M
650 buf_ptr += 32 - st->codecpar->ch_layout.nb_channels * 4;
651 }
652 av_shrink_packet(pkt, data_ptr - pkt->data);
653 return 0;
654}
655
656static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
657{
658 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
659 MXFContext *mxf = s->priv_data;
660 AVIOContext *pb = s->pb;
661 int64_t end = avio_tell(pb) + klv->length;
662 int64_t size;
663 uint64_t orig_size;
664 uint64_t plaintext_size;
665 uint8_t ivec[16];
666 uint8_t tmpbuf[16];
667 int ret;
668 int index;
669 int body_sid;
670
671 if (!mxf->aesc && s->key && s->keylen == 16) {
672 mxf->aesc = av_aes_alloc();
673 if (!mxf->aesc)
674 return AVERROR(ENOMEM);
675 av_aes_init(mxf->aesc, s->key, 128, 1);
676 }
677 // crypto context
678 size = klv_decode_ber_length(pb, NULL);
679 if (size < 0)
680 return size;
681 avio_skip(pb, size);
682 // plaintext offset
683 klv_decode_ber_length(pb ,NULL);
684 plaintext_size = avio_rb64(pb);
685 // source klv key
686 klv_decode_ber_length(pb, NULL);
687 avio_read(pb, klv->key, 16);
688 if (!IS_KLV_KEY(klv, mxf_essence_element_key))
689 return AVERROR_INVALIDDATA;
690
691 body_sid = find_body_sid_by_absolute_offset(mxf, klv->offset);
692 index = mxf_get_stream_index(s, klv, body_sid);
693 if (index < 0)
694 return AVERROR_INVALIDDATA;
695 // source size
696 klv_decode_ber_length(pb, NULL);
697 orig_size = avio_rb64(pb);
698 if (orig_size < plaintext_size)
699 return AVERROR_INVALIDDATA;
700 // enc. code
701 size = klv_decode_ber_length(pb, NULL);
702 if (size < 32 || size - 32 < orig_size || (int)orig_size != orig_size)
703 return AVERROR_INVALIDDATA;
704 avio_read(pb, ivec, 16);
705 ret = ffio_read_size(pb, tmpbuf, 16);
706 if (ret < 16)
707 return ret;
708 if (mxf->aesc)
709 av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
710 if (memcmp(tmpbuf, checkv, 16))
711 av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
712 size -= 32;
713 size = av_get_packet(pb, pkt, size);
714 if (size < 0)
715 return size;
716 else if (size < plaintext_size)
717 return AVERROR_INVALIDDATA;
718 size -= plaintext_size;
719 if (mxf->aesc)
720 av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
721 &pkt->data[plaintext_size], size >> 4, ivec, 1);
722 av_shrink_packet(pkt, orig_size);
723 pkt->stream_index = index;
724 avio_skip(pb, end - avio_tell(pb));
725 return 0;
726}
727
728static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
729{
730 MXFContext *mxf = arg;
731 int item_num = avio_rb32(pb);
732 int item_len = avio_rb32(pb);
733
734 if (item_len != 18) {
735 avpriv_request_sample(pb, "Primer pack item length %d", item_len);
736 return AVERROR_PATCHWELCOME;
737 }
738 if (item_num > 65536 || item_num < 0) {
739 av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
740 return AVERROR_INVALIDDATA;
741 }
742 if (mxf->local_tags)
743 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
744 av_free(mxf->local_tags);
745 mxf->local_tags_count = 0;
746 mxf->local_tags = av_calloc(item_num, item_len);
747 if (!mxf->local_tags)
748 return AVERROR(ENOMEM);
749 mxf->local_tags_count = item_num;
750 avio_read(pb, mxf->local_tags, item_num*item_len);
751 return 0;
752}
753
754static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
755{
756 MXFContext *mxf = arg;
757 AVFormatContext *s = mxf->fc;
758 MXFPartition *partition, *tmp_part;
759 UID op;
760 uint64_t footer_partition;
761 uint32_t nb_essence_containers;
762 uint64_t this_partition;
763 int ret;
764
765 if (mxf->partitions_count >= INT_MAX / 2)
766 return AVERROR_INVALIDDATA;
767
768 av_assert0(klv_offset >= mxf->run_in);
769
770 tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
771 if (!tmp_part)
772 return AVERROR(ENOMEM);
773 mxf->partitions = tmp_part;
774
775 if (mxf->parsing_backward) {
776 /* insert the new partition pack in the middle
777 * this makes the entries in mxf->partitions sorted by offset */
778 memmove(&mxf->partitions[mxf->last_forward_partition+1],
779 &mxf->partitions[mxf->last_forward_partition],
780 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
781 partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
782 } else {
783 mxf->last_forward_partition++;
784 partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
785 }
786
787 memset(partition, 0, sizeof(*partition));
788 mxf->partitions_count++;
789 partition->pack_length = avio_tell(pb) - klv_offset + size;
790 partition->pack_ofs = klv_offset;
791
792 switch(uid[13]) {
793 case 2:
794 partition->type = Header;
795 break;
796 case 3:
797 partition->type = BodyPartition;
798 break;
799 case 4:
800 partition->type = Footer;
801 break;
802 default:
803 av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
804 return AVERROR_INVALIDDATA;
805 }
806
807 /* consider both footers to be closed (there is only Footer and CompleteFooter) */
808 partition->closed = partition->type == Footer || !(uid[14] & 1);
809 partition->complete = uid[14] > 2;
810 avio_skip(pb, 4);
811 partition->kag_size = avio_rb32(pb);
812 this_partition = avio_rb64(pb);
813 if (this_partition != klv_offset - mxf->run_in) {
814 av_log(mxf->fc, AV_LOG_ERROR,
815 "this_partition %"PRId64" mismatches %"PRId64"\n",
816 this_partition, klv_offset - mxf->run_in);
817 return AVERROR_INVALIDDATA;
818 }
819 partition->previous_partition = avio_rb64(pb);
820 footer_partition = avio_rb64(pb);
821 partition->header_byte_count = avio_rb64(pb);
822 partition->index_byte_count = avio_rb64(pb);
823 partition->index_sid = avio_rb32(pb);
824 partition->body_offset = avio_rb64(pb);
825 partition->body_sid = avio_rb32(pb);
826 if (partition->body_offset < 0)
827 return AVERROR_INVALIDDATA;
828
829 ret = ffio_read_size(pb, op, sizeof(UID));
830 if (ret < 0) {
831 av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
832 return ret;
833 }
834 nb_essence_containers = avio_rb32(pb);
835
836 if (partition->type == Header) {
837 char str[36];
838 snprintf(str, sizeof(str), "%08x.%08x.%08x.%08x", AV_RB32(&op[0]), AV_RB32(&op[4]), AV_RB32(&op[8]), AV_RB32(&op[12]));
839 av_dict_set(&s->metadata, "operational_pattern_ul", str, 0);
840 }
841
842 if (this_partition &&
843 partition->previous_partition == this_partition) {
844 av_log(mxf->fc, AV_LOG_ERROR,
845 "PreviousPartition equal to ThisPartition %"PRIx64"\n",
846 partition->previous_partition);
847 /* override with the actual previous partition offset */
848 if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
849 MXFPartition *prev =
850 mxf->partitions + mxf->last_forward_partition - 2;
851 partition->previous_partition = prev->pack_ofs - mxf->run_in;
852 }
853 /* if no previous body partition are found point to the header
854 * partition */
855 if (partition->previous_partition == this_partition)
856 partition->previous_partition = 0;
857 av_log(mxf->fc, AV_LOG_ERROR,
858 "Overriding PreviousPartition with %"PRIx64"\n",
859 partition->previous_partition);
860 }
861
862 /* some files don't have FooterPartition set in every partition */
863 if (footer_partition) {
864 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
865 av_log(mxf->fc, AV_LOG_ERROR,
866 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
867 mxf->footer_partition, footer_partition);
868 } else {
869 mxf->footer_partition = footer_partition;
870 }
871 }
872
873 av_log(mxf->fc, AV_LOG_TRACE,
874 "PartitionPack: ThisPartition = 0x%"PRIX64
875 ", PreviousPartition = 0x%"PRIX64", "
876 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
877 this_partition,
878 partition->previous_partition, footer_partition,
879 partition->index_sid, partition->body_sid);
880
881 /* sanity check PreviousPartition if set */
882 //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
883 if (partition->previous_partition &&
884 mxf->run_in + partition->previous_partition >= klv_offset) {
885 av_log(mxf->fc, AV_LOG_ERROR,
886 "PreviousPartition points to this partition or forward\n");
887 return AVERROR_INVALIDDATA;
888 }
889
890 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
891 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
892 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
893 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
894 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
895 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
896 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
897 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
898 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
899 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
900 else if (op[12] == 0x10) {
901 /* SMPTE 390m: "There shall be exactly one essence container"
902 * The following block deals with files that violate this, namely:
903 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
904 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
905 if (nb_essence_containers != 1) {
906 MXFOP mxfop = nb_essence_containers ? OP1a : OPAtom;
907
908 /* only nag once */
909 if (!mxf->op)
910 av_log(mxf->fc, AV_LOG_WARNING,
911 "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
912 nb_essence_containers,
913 mxfop == OP1a ? "OP1a" : "OPAtom");
914
915 mxf->op = mxfop;
916 } else
917 mxf->op = OPAtom;
918 } else {
919 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
920 mxf->op = OP1a;
921 }
922
923 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
924 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
925 partition->kag_size);
926
927 if (mxf->op == OPSONYOpt)
928 partition->kag_size = 512;
929 else
930 partition->kag_size = 1;
931
932 av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
933 }
934
935 return 0;
936}
937
938static uint64_t partition_score(MXFPartition *p)
939{
940 uint64_t score;
941 if (!p)
942 return 0;
943 if (p->type == Footer)
944 score = 5;
945 else if (p->complete)
946 score = 4;
947 else if (p->closed)
948 score = 3;
949 else
950 score = 1;
951 return (score << 60) | ((uint64_t)p->pack_ofs >> 4);
952}
953
954static int mxf_add_metadata_set(MXFContext *mxf, MXFMetadataSet **metadata_set, enum MXFMetadataSetType type)
955{
956 MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[type];
957 int ret;
958
959 // Index Table is special because it might be added manually without
960 // partition and we iterate through all instances of them. Also some files
961 // use the same Instance UID for different index tables...
962 if (type != IndexTableSegment) {
963 for (int i = 0; i < mg->metadata_sets_count; i++) {
964 if (!memcmp((*metadata_set)->uid, mg->metadata_sets[i]->uid, 16)) {
965 uint64_t old_s = mg->metadata_sets[i]->partition_score;
966 uint64_t new_s = (*metadata_set)->partition_score;
967 if (old_s > new_s) {
968 mxf_free_metadataset(metadata_set, type);
969 return 0;
970 }
971 }
972 }
973 }
974
975 ret = av_dynarray_add_nofree(&mg->metadata_sets, &mg->metadata_sets_count, *metadata_set);
976 if (ret < 0) {
977 mxf_free_metadataset(metadata_set, type);
978 return ret;
979 }
980 return 0;
981}
982
983static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
984{
985 MXFCryptoContext *cryptocontext = arg;
986 if (size != 16)
987 return AVERROR_INVALIDDATA;
988 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
989 avio_read(pb, cryptocontext->source_container_ul, 16);
990 return 0;
991}
992
993static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
994{
995 int64_t ret;
996 unsigned c = avio_rb32(pb);
997
998 //avio_read() used int
999 if (c > INT_MAX / sizeof(UID))
1000 return AVERROR_PATCHWELCOME;
1001 *count = c;
1002
1003 av_free(*refs);
1004 *refs = av_malloc_array(*count, sizeof(UID));
1005 if (!*refs) {
1006 *count = 0;
1007 return AVERROR(ENOMEM);
1008 }
1009 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
1010 ret = avio_read(pb, (uint8_t *)*refs, *count * sizeof(UID));
1011 if (ret != *count * sizeof(UID)) {
1012 *count = ret < 0 ? 0 : ret / sizeof(UID);
1013 return ret < 0 ? ret : AVERROR_INVALIDDATA;
1014 }
1015
1016 return 0;
1017}
1018
1019static inline int mxf_read_us_ascii_string(AVIOContext *pb, int size, char** str)
1020{
1021 int ret;
1022 size_t buf_size;
1023
1024 if (size < 0 || size > INT_MAX - 1)
1025 return AVERROR(EINVAL);
1026
1027 buf_size = size + 1;
1028 av_free(*str);
1029 *str = av_malloc(buf_size);
1030 if (!*str)
1031 return AVERROR(ENOMEM);
1032
1033 ret = avio_get_str(pb, size, *str, buf_size);
1034
1035 if (ret < 0) {
1036 av_freep(str);
1037 return ret;
1038 }
1039
1040 return ret;
1041}
1042
1043static inline int mxf_read_utf16_string(AVIOContext *pb, int size, char** str, int be)
1044{
1045 int ret;
1046 size_t buf_size;
1047
1048 if (size < 0 || size > INT_MAX/2)
1049 return AVERROR(EINVAL);
1050
1051 buf_size = size + size / 2 + 1;
1052 av_free(*str);
1053 *str = av_malloc(buf_size);
1054 if (!*str)
1055 return AVERROR(ENOMEM);
1056
1057 if (be)
1058 ret = avio_get_str16be(pb, size, *str, buf_size);
1059 else
1060 ret = avio_get_str16le(pb, size, *str, buf_size);
1061
1062 if (ret < 0) {
1063 av_freep(str);
1064 return ret;
1065 }
1066
1067 return ret;
1068}
1069
1070#define READ_STR16(type, big_endian) \
1071static int mxf_read_utf16 ## type ##_string(AVIOContext *pb, int size, char** str) \
1072{ \
1073return mxf_read_utf16_string(pb, size, str, big_endian); \
1074}
1075READ_STR16(be, 1)
1076READ_STR16(le, 0)
1077#undef READ_STR16
1078
1079static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1080{
1081 MXFContext *mxf = arg;
1082 switch (tag) {
1083 case 0x1901:
1084 if (mxf->packages_refs)
1085 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
1086 return mxf_read_strong_ref_array(pb, &mxf->packages_refs, &mxf->packages_count);
1087 case 0x1902:
1088 return mxf_read_strong_ref_array(pb, &mxf->essence_container_data_refs, &mxf->essence_container_data_count);
1089 }
1090 return 0;
1091}
1092
1093static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1094{
1095 MXFStructuralComponent *source_clip = arg;
1096 switch(tag) {
1097 case 0x0202:
1098 source_clip->duration = avio_rb64(pb);
1099 break;
1100 case 0x1201:
1101 source_clip->start_position = avio_rb64(pb);
1102 break;
1103 case 0x1101:
1104 /* UMID, only get last 16 bytes */
1105 avio_read(pb, source_clip->source_package_ul, 16);
1106 avio_read(pb, source_clip->source_package_uid, 16);
1107 break;
1108 case 0x1102:
1109 source_clip->source_track_id = avio_rb32(pb);
1110 break;
1111 }
1112 return 0;
1113}
1114
1115static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1116{
1117 MXFTimecodeComponent *mxf_timecode = arg;
1118 switch(tag) {
1119 case 0x1501:
1120 mxf_timecode->start_frame = avio_rb64(pb);
1121 break;
1122 case 0x1502:
1123 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
1124 break;
1125 case 0x1503:
1126 mxf_timecode->drop_frame = avio_r8(pb);
1127 break;
1128 }
1129 return 0;
1130}
1131
1132static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1133{
1134 MXFPulldownComponent *mxf_pulldown = arg;
1135 switch(tag) {
1136 case 0x0d01:
1137 avio_read(pb, mxf_pulldown->input_segment_ref, 16);
1138 break;
1139 }
1140 return 0;
1141}
1142
1143static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1144{
1145 MXFTrack *track = arg;
1146 switch(tag) {
1147 case 0x4801:
1148 track->track_id = avio_rb32(pb);
1149 break;
1150 case 0x4804:
1151 avio_read(pb, track->track_number, 4);
1152 break;
1153 case 0x4802:
1154 mxf_read_utf16be_string(pb, size, &track->name);
1155 break;
1156 case 0x4b01:
1157 track->edit_rate.num = avio_rb32(pb);
1158 track->edit_rate.den = avio_rb32(pb);
1159 break;
1160 case 0x4b02:
1161 track->origin = avio_rb64(pb);
1162 break;
1163 case 0x4803:
1164 avio_read(pb, track->sequence_ref, 16);
1165 break;
1166 }
1167 return 0;
1168}
1169
1170static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1171{
1172 MXFSequence *sequence = arg;
1173 switch(tag) {
1174 case 0x0202:
1175 sequence->duration = avio_rb64(pb);
1176 break;
1177 case 0x0201:
1178 avio_read(pb, sequence->data_definition_ul, 16);
1179 break;
1180 case 0x1001:
1181 return mxf_read_strong_ref_array(pb, &sequence->structural_components_refs,
1182 &sequence->structural_components_count);
1183 }
1184 return 0;
1185}
1186
1187static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1188{
1189 MXFEssenceGroup *essence_group = arg;
1190 switch (tag) {
1191 case 0x0202:
1192 essence_group->duration = avio_rb64(pb);
1193 break;
1194 case 0x0501:
1195 return mxf_read_strong_ref_array(pb, &essence_group->structural_components_refs,
1196 &essence_group->structural_components_count);
1197 }
1198 return 0;
1199}
1200
1201static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1202{
1203 MXFPackage *package = arg;
1204 switch(tag) {
1205 case 0x4403:
1206 return mxf_read_strong_ref_array(pb, &package->tracks_refs,
1207 &package->tracks_count);
1208 case 0x4401:
1209 /* UMID */
1210 avio_read(pb, package->package_ul, 16);
1211 avio_read(pb, package->package_uid, 16);
1212 break;
1213 case 0x4701:
1214 avio_read(pb, package->descriptor_ref, 16);
1215 break;
1216 case 0x4402:
1217 return mxf_read_utf16be_string(pb, size, &package->name);
1218 case 0x4406:
1219 return mxf_read_strong_ref_array(pb, &package->comment_refs,
1220 &package->comment_count);
1221 }
1222 return 0;
1223}
1224
1225static int mxf_read_essence_container_data(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1226{
1227 MXFEssenceContainerData *essence_data = arg;
1228 switch(tag) {
1229 case 0x2701:
1230 /* linked package umid UMID */
1231 avio_read(pb, essence_data->package_ul, 16);
1232 avio_read(pb, essence_data->package_uid, 16);
1233 break;
1234 case 0x3f06:
1235 essence_data->index_sid = avio_rb32(pb);
1236 break;
1237 case 0x3f07:
1238 essence_data->body_sid = avio_rb32(pb);
1239 break;
1240 }
1241 return 0;
1242}
1243
1244static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
1245{
1246 int i, length;
1247 uint32_t nb_index_entries;
1248
1249 if (segment->temporal_offset_entries)
1250 return AVERROR_INVALIDDATA;
1251
1252 nb_index_entries = avio_rb32(pb);
1253 if (nb_index_entries > INT_MAX)
1254 return AVERROR_INVALIDDATA;
1255 segment->nb_index_entries = nb_index_entries;
1256
1257 length = avio_rb32(pb);
1258 if(segment->nb_index_entries && length < 11)
1259 return AVERROR_INVALIDDATA;
1260
1261 if (!FF_ALLOC_TYPED_ARRAY(segment->temporal_offset_entries, segment->nb_index_entries) ||
1262 !FF_ALLOC_TYPED_ARRAY(segment->flag_entries , segment->nb_index_entries) ||
1263 !FF_ALLOC_TYPED_ARRAY(segment->stream_offset_entries , segment->nb_index_entries)) {
1264 av_freep(&segment->temporal_offset_entries);
1265 av_freep(&segment->flag_entries);
1266 return AVERROR(ENOMEM);
1267 }
1268
1269 for (i = 0; i < segment->nb_index_entries; i++) {
1270 if(avio_feof(pb))
1271 return AVERROR_INVALIDDATA;
1272 segment->temporal_offset_entries[i] = avio_r8(pb);
1273 avio_r8(pb); /* KeyFrameOffset */
1274 segment->flag_entries[i] = avio_r8(pb);
1275 segment->stream_offset_entries[i] = avio_rb64(pb);
1276 avio_skip(pb, length - 11);
1277 }
1278 return 0;
1279}
1280
1281static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1282{
1283 MXFIndexTableSegment *segment = arg;
1284 switch(tag) {
1285 case 0x3F05:
1286 segment->edit_unit_byte_count = avio_rb32(pb);
1287 av_log(NULL, AV_LOG_TRACE, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
1288 break;
1289 case 0x3F06:
1290 segment->index_sid = avio_rb32(pb);
1291 av_log(NULL, AV_LOG_TRACE, "IndexSID %d\n", segment->index_sid);
1292 break;
1293 case 0x3F07:
1294 segment->body_sid = avio_rb32(pb);
1295 av_log(NULL, AV_LOG_TRACE, "BodySID %d\n", segment->body_sid);
1296 break;
1297 case 0x3F0A:
1298 av_log(NULL, AV_LOG_TRACE, "IndexEntryArray found\n");
1299 return mxf_read_index_entry_array(pb, segment);
1300 case 0x3F0B:
1301 segment->index_edit_rate.num = avio_rb32(pb);
1302 segment->index_edit_rate.den = avio_rb32(pb);
1303 if (segment->index_edit_rate.num <= 0 ||
1304 segment->index_edit_rate.den <= 0)
1305 return AVERROR_INVALIDDATA;
1306 av_log(NULL, AV_LOG_TRACE, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
1307 segment->index_edit_rate.den);
1308 break;
1309 case 0x3F0C:
1310 segment->index_start_position = avio_rb64(pb);
1311 av_log(NULL, AV_LOG_TRACE, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
1312 break;
1313 case 0x3F0D:
1314 segment->index_duration = avio_rb64(pb);
1315 av_log(NULL, AV_LOG_TRACE, "IndexDuration %"PRId64"\n", segment->index_duration);
1316 break;
1317 }
1318 return 0;
1319}
1320
1321static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
1322{
1323 int code, value, ofs = 0;
1324 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
1325
1326 do {
1327 code = avio_r8(pb);
1328 value = avio_r8(pb);
1329 av_log(NULL, AV_LOG_TRACE, "pixel layout: code %#x\n", code);
1330
1331 if (ofs <= 14) {
1332 layout[ofs++] = code;
1333 layout[ofs++] = value;
1334 } else
1335 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
1336 } while (code != 0); /* SMPTE 377M E.2.46 */
1337
1338 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
1339}
1340
1341static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1342{
1343 MXFDescriptor *descriptor = arg;
1344 int entry_count, entry_size;
1345
1346 switch(tag) {
1347 case 0x3F01:
1348 return mxf_read_strong_ref_array(pb, &descriptor->file_descriptors_refs,
1349 &descriptor->file_descriptors_count);
1350 case 0x3002: /* ContainerDuration */
1351 descriptor->duration = avio_rb64(pb);
1352 break;
1353 case 0x3004:
1354 avio_read(pb, descriptor->essence_container_ul, 16);
1355 break;
1356 case 0x3005:
1357 avio_read(pb, descriptor->codec_ul, 16);
1358 break;
1359 case 0x3006:
1360 descriptor->linked_track_id = avio_rb32(pb);
1361 break;
1362 case 0x3201: /* PictureEssenceCoding */
1363 avio_read(pb, descriptor->essence_codec_ul, 16);
1364 break;
1365 case 0x3203:
1366 descriptor->width = avio_rb32(pb);
1367 break;
1368 case 0x3202:
1369 descriptor->height = avio_rb32(pb);
1370 break;
1371 case 0x320C:
1372 descriptor->frame_layout = avio_r8(pb);
1373 break;
1374 case 0x320D:
1375 entry_count = avio_rb32(pb);
1376 entry_size = avio_rb32(pb);
1377 if (entry_size == 4) {
1378 if (entry_count > 0)
1379 descriptor->video_line_map[0] = avio_rb32(pb);
1380 else
1381 descriptor->video_line_map[0] = 0;
1382 if (entry_count > 1)
1383 descriptor->video_line_map[1] = avio_rb32(pb);
1384 else
1385 descriptor->video_line_map[1] = 0;
1386 } else
1387 av_log(NULL, AV_LOG_WARNING, "VideoLineMap element size %d currently not supported\n", entry_size);
1388 break;
1389 case 0x320E:
1390 descriptor->aspect_ratio.num = avio_rb32(pb);
1391 descriptor->aspect_ratio.den = avio_rb32(pb);
1392 break;
1393 case 0x3210:
1394 avio_read(pb, descriptor->color_trc_ul, 16);
1395 break;
1396 case 0x3212:
1397 descriptor->field_dominance = avio_r8(pb);
1398 break;
1399 case 0x3219:
1400 avio_read(pb, descriptor->color_primaries_ul, 16);
1401 break;
1402 case 0x321A:
1403 avio_read(pb, descriptor->color_space_ul, 16);
1404 break;
1405 case 0x3301:
1406 descriptor->component_depth = avio_rb32(pb);
1407 break;
1408 case 0x3302:
1409 descriptor->horiz_subsampling = avio_rb32(pb);
1410 break;
1411 case 0x3304:
1412 descriptor->black_ref_level = avio_rb32(pb);
1413 break;
1414 case 0x3305:
1415 descriptor->white_ref_level = avio_rb32(pb);
1416 break;
1417 case 0x3306:
1418 descriptor->color_range = avio_rb32(pb);
1419 break;
1420 case 0x3308:
1421 descriptor->vert_subsampling = avio_rb32(pb);
1422 break;
1423 case 0x3D03:
1424 descriptor->sample_rate.num = avio_rb32(pb);
1425 descriptor->sample_rate.den = avio_rb32(pb);
1426 break;
1427 case 0x3D06: /* SoundEssenceCompression */
1428 avio_read(pb, descriptor->essence_codec_ul, 16);
1429 break;
1430 case 0x3D07:
1431 descriptor->channels = avio_rb32(pb);
1432 break;
1433 case 0x3D01:
1434 descriptor->bits_per_sample = avio_rb32(pb);
1435 break;
1436 case 0x3401:
1437 mxf_read_pixel_layout(pb, descriptor);
1438 break;
1439 default:
1440 /* Private uid used by SONY C0023S01.mxf */
1441 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
1442 if (descriptor->extradata)
1443 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1444 av_free(descriptor->extradata);
1445 descriptor->extradata_size = 0;
1446 descriptor->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
1447 if (!descriptor->extradata)
1448 return AVERROR(ENOMEM);
1449 descriptor->extradata_size = size;
1450 avio_read(pb, descriptor->extradata, size);
1451 }
1452 if (IS_KLV_KEY(uid, mxf_jp2k_rsiz)) {
1453 uint32_t rsiz = avio_rb16(pb);
1454 if (rsiz == AV_PROFILE_JPEG2000_DCINEMA_2K ||
1455 rsiz == AV_PROFILE_JPEG2000_DCINEMA_4K)
1456 descriptor->pix_fmt = AV_PIX_FMT_XYZ12;
1457 }
1458 if (IS_KLV_KEY(uid, mxf_mastering_display_prefix)) {
1459 if (!descriptor->mastering) {
1460 descriptor->mastering = av_mastering_display_metadata_alloc_size(&descriptor->mastering_size);
1461 if (!descriptor->mastering)
1462 return AVERROR(ENOMEM);
1463 }
1464 if (IS_KLV_KEY(uid, mxf_mastering_display_uls[0])) {
1465 for (int i = 0; i < 3; i++) {
1466 /* Order: large x, large y, other (i.e. RGB) */
1467 descriptor->mastering->display_primaries[i][0] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1468 descriptor->mastering->display_primaries[i][1] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1469 }
1470 /* Check we have seen mxf_mastering_display_white_point_chromaticity */
1471 if (descriptor->mastering->white_point[0].den != 0)
1472 descriptor->mastering->has_primaries = 1;
1473 }
1474 if (IS_KLV_KEY(uid, mxf_mastering_display_uls[1])) {
1475 descriptor->mastering->white_point[0] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1476 descriptor->mastering->white_point[1] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1477 /* Check we have seen mxf_mastering_display_primaries */
1478 if (descriptor->mastering->display_primaries[0][0].den != 0)
1479 descriptor->mastering->has_primaries = 1;
1480 }
1481 if (IS_KLV_KEY(uid, mxf_mastering_display_uls[2])) {
1482 descriptor->mastering->max_luminance = av_make_q(avio_rb32(pb), FF_MXF_MASTERING_LUMA_DEN);
1483 /* Check we have seen mxf_mastering_display_minimum_luminance */
1484 if (descriptor->mastering->min_luminance.den != 0)
1485 descriptor->mastering->has_luminance = 1;
1486 }
1487 if (IS_KLV_KEY(uid, mxf_mastering_display_uls[3])) {
1488 descriptor->mastering->min_luminance = av_make_q(avio_rb32(pb), FF_MXF_MASTERING_LUMA_DEN);
1489 /* Check we have seen mxf_mastering_display_maximum_luminance */
1490 if (descriptor->mastering->max_luminance.den != 0)
1491 descriptor->mastering->has_luminance = 1;
1492 }
1493 }
1494 if (IS_KLV_KEY(uid, mxf_apple_coll_prefix)) {
1495 if (!descriptor->coll) {
1496 descriptor->coll = av_content_light_metadata_alloc(&descriptor->coll_size);
1497 if (!descriptor->coll)
1498 return AVERROR(ENOMEM);
1499 }
1500 if (IS_KLV_KEY(uid, mxf_apple_coll_max_cll)) {
1501 descriptor->coll->MaxCLL = avio_rb16(pb);
1502 }
1503 if (IS_KLV_KEY(uid, mxf_apple_coll_max_fall)) {
1504 descriptor->coll->MaxFALL = avio_rb16(pb);
1505 }
1506 }
1507
1508 if (IS_KLV_KEY(uid, mxf_sub_descriptor))
1509 return mxf_read_strong_ref_array(pb, &descriptor->sub_descriptors_refs, &descriptor->sub_descriptors_count);
1510
1511 break;
1512 }
1513 return 0;
1514}
1515
1516static int mxf_read_mca_sub_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1517{
1518 MXFMCASubDescriptor *mca_sub_descriptor = arg;
1519
1520 if (IS_KLV_KEY(uid, mxf_mca_label_dictionary_id))
1521 avio_read(pb, mca_sub_descriptor->mca_label_dictionary_id, 16);
1522
1523 if (IS_KLV_KEY(uid, mxf_mca_link_id))
1524 avio_read(pb, mca_sub_descriptor->mca_link_id, 16);
1525
1526 if (IS_KLV_KEY(uid, mxf_soundfield_group_link_id))
1527 avio_read(pb, mca_sub_descriptor->soundfield_group_link_id, 16);
1528
1529 if (IS_KLV_KEY(uid, mxf_group_of_soundfield_groups_link_id))
1530 return mxf_read_strong_ref_array(pb, &mca_sub_descriptor->group_of_soundfield_groups_link_id_refs, &mca_sub_descriptor->group_of_soundfield_groups_link_id_count);
1531
1532 if (IS_KLV_KEY(uid, mxf_mca_channel_id))
1533 mca_sub_descriptor->mca_channel_id = avio_rb32(pb);
1534
1535 if (IS_KLV_KEY(uid, mxf_mca_rfc5646_spoken_language))
1536 return mxf_read_us_ascii_string(pb, size, &mca_sub_descriptor->language);
1537
1538 return 0;
1539}
1540
1541static int mxf_read_ffv1_sub_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1542{
1543 MXFFFV1SubDescriptor *ffv1_sub_descriptor = arg;
1544
1545 if (IS_KLV_KEY(uid, mxf_ffv1_extradata) && size <= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ) {
1546 if (ffv1_sub_descriptor->extradata)
1547 av_log(NULL, AV_LOG_WARNING, "Duplicate ffv1_extradata\n");
1548 av_free(ffv1_sub_descriptor->extradata);
1549 ffv1_sub_descriptor->extradata_size = 0;
1550 ffv1_sub_descriptor->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
1551 if (!ffv1_sub_descriptor->extradata)
1552 return AVERROR(ENOMEM);
1553 ffv1_sub_descriptor->extradata_size = size;
1554 avio_read(pb, ffv1_sub_descriptor->extradata, size);
1555 }
1556
1557 return 0;
1558}
1559
1560static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
1561{
1562 MXFTaggedValue *tagged_value = arg;
1563 uint8_t key[17];
1564 int ret;
1565
1566 if (size <= 17)
1567 return 0;
1568
1569 ret = ffio_read_size(pb, key, 17);
1570 if (ret < 0)
1571 return ret;
1572 /* TODO: handle other types of of indirect values */
1573 if (memcmp(key, mxf_indirect_value_utf16le, 17) == 0) {
1574 return mxf_read_utf16le_string(pb, size - 17, &tagged_value->value);
1575 } else if (memcmp(key, mxf_indirect_value_utf16be, 17) == 0) {
1576 return mxf_read_utf16be_string(pb, size - 17, &tagged_value->value);
1577 }
1578 return 0;
1579}
1580
1581static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1582{
1583 MXFTaggedValue *tagged_value = arg;
1584 switch (tag){
1585 case 0x5001:
1586 return mxf_read_utf16be_string(pb, size, &tagged_value->name);
1587 case 0x5003:
1588 return mxf_read_indirect_value(tagged_value, pb, size);
1589 }
1590 return 0;
1591}
1592
1593/*
1594 * Match an uid independently of the version byte and up to len common bytes
1595 * Returns: boolean
1596 */
1597static int mxf_match_uid(const UID key, const uint8_t uid_prefix[], int len)
1598{
1599 int i;
1600 for (i = 0; i < len; i++) {
1601 if (i != 7 && key[i] != uid_prefix[i])
1602 return 0;
1603 }
1604 return 1;
1605}
1606
1607static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1608{
1609 while (uls->uid[0]) {
1610 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1611 break;
1612 uls++;
1613 }
1614 return uls;
1615}
1616
1617static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1618{
1619 MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[type];
1620
1621 if (!strong_ref)
1622 return NULL;
1623 for (int i = mg->metadata_sets_count - 1; i >= 0; i--)
1624 if (!memcmp(*strong_ref, mg->metadata_sets[i]->uid, 16))
1625 return mg->metadata_sets[i];
1626
1627 return NULL;
1628}
1629
1630static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1631 // video essence container uls
1632 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000, NULL, 14, J2KWrap },
1633 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x10,0x60,0x01 }, 14, AV_CODEC_ID_H264, NULL, 15 }, /* H.264 */
1634 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x11,0x01,0x00 }, 14, AV_CODEC_ID_DNXHD, NULL, 14 }, /* VC-3 */
1635 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x1e,0x01,0x00 }, 14, AV_CODEC_ID_DNXUC, NULL, 14 }, /* DNxUncompressed / SMPTE RDD 50 */
1636 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x12,0x01,0x00 }, 14, AV_CODEC_ID_VC1, NULL, 14 }, /* VC-1 */
1637 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x14,0x01,0x00 }, 14, AV_CODEC_ID_TIFF, NULL, 14 }, /* TIFF */
1638 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x15,0x01,0x00 }, 14, AV_CODEC_ID_DIRAC, NULL, 14 }, /* VC-2 */
1639 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1b,0x01,0x00 }, 14, AV_CODEC_ID_CFHD, NULL, 14 }, /* VC-5 */
1640 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1c,0x01,0x00 }, 14, AV_CODEC_ID_PRORES, NULL, 14 }, /* ProRes */
1641 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO, NULL, 15 }, /* MPEG-ES */
1642 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x04,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO, NULL, 15, D10D11Wrap }, /* SMPTE D-10 mapping */
1643 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x23,0x01,0x00 }, 14, AV_CODEC_ID_FFV1, NULL, 14 },
1644 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO, NULL, 15 }, /* DV 625 25mbps */
1645 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO, NULL, 15, RawVWrap }, /* uncompressed picture */
1646 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15, AV_CODEC_ID_HQ_HQA },
1647 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15, AV_CODEC_ID_HQX },
1648 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x15,0x00,0x04,0x02,0x10,0x00,0x01 }, 16, AV_CODEC_ID_HEVC, NULL, 15 }, /* Canon XF-HEVC */
1649 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1650 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1651};
1652
1653/* EC ULs for intra-only formats */
1654static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1655 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x00,0x00 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* MXF-GC SMPTE D-10 mappings */
1656 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1657};
1658
1659/* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1660static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1661 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x00,0x00 }, 14, AV_CODEC_ID_H264 }, /* H.264/MPEG-4 AVC Intra Profiles */
1662 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG 2000 code stream */
1663 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1664};
1665
1666/* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1667static const MXFCodecUL mxf_intra_only_picture_coded_width[] = {
1668 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1669 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1670 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1671 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1672 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, 0 },
1673};
1674
1675static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1676 // sound essence container uls
1677 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14, AV_CODEC_ID_PCM_S16LE, NULL, 14, RawAWrap }, /* BWF */
1678 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14, AV_CODEC_ID_MP2, NULL, 15 }, /* MPEG-ES */
1679 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14, AV_CODEC_ID_PCM_S16LE, NULL, 13 }, /* D-10 Mapping 50Mbps PAL Extended Template */
1680 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4F }, 14, AV_CODEC_ID_PCM_S16LE }, /* 0001GL00.MXF.A1.mxf_opatom.mxf */
1681 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x03,0x04,0x02,0x02,0x02,0x03,0x03,0x01,0x00 }, 14, AV_CODEC_ID_AAC }, /* MPEG-2 AAC ADTS (legacy) */
1682 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x16,0x00,0x00 }, 14, AV_CODEC_ID_AAC, NULL, 14 }, /* AAC ADIF (SMPTE 381-4) */
1683 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x17,0x00,0x00 }, 14, AV_CODEC_ID_AAC, NULL, 14 }, /* AAC ADTS (SMPTE 381-4) */
1684 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x18,0x00,0x00 }, 14, AV_CODEC_ID_AAC, NULL, 14 }, /* AAC LATM/LOAS (SMPTE 381-4) */
1685 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1686};
1687
1688static const MXFCodecUL mxf_data_essence_container_uls[] = {
1689 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0d,0x00,0x00 }, 16, AV_CODEC_ID_NONE, "vbi_smpte_436M", 11 },
1690 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, AV_CODEC_ID_SMPTE_436M_ANC, "vbi_vanc_smpte_436M", 11 },
1691 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x13,0x01,0x01 }, 16, AV_CODEC_ID_TTML },
1692 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1693};
1694
1700
1701static const MXFChannelOrderingUL mxf_channel_ordering[] = {
1702 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x01,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left
1703 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x02,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right
1704 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x03,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center
1705 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x04,0x00,0x00,0x00,0x00 }, AV_CHAN_LOW_FREQUENCY, AV_AUDIO_SERVICE_TYPE_MAIN }, // Low Frequency Effects
1706 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x05,0x00,0x00,0x00,0x00 }, AV_CHAN_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Surround
1707 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x06,0x00,0x00,0x00,0x00 }, AV_CHAN_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Surround
1708 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x07,0x00,0x00,0x00,0x00 }, AV_CHAN_SIDE_SURROUND_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Side Surround
1709 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x08,0x00,0x00,0x00,0x00 }, AV_CHAN_SIDE_SURROUND_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Side Surround
1710 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x09,0x00,0x00,0x00,0x00 }, AV_CHAN_BACK_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Rear Surround
1711 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0a,0x00,0x00,0x00,0x00 }, AV_CHAN_BACK_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Rear Surround
1712 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0b,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_LEFT_OF_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Center
1713 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0c,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_RIGHT_OF_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Center
1714 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0d,0x00,0x00,0x00,0x00 }, AV_CHAN_BACK_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Surround
1715 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0e,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED }, // Hearing impaired audio channel
1716 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x0f,0x00,0x00,0x00,0x00 }, AV_CHAN_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED }, // Visually impaired narrative audio channel
1717 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x20,0x03,0x00,0x00,0x00 }, AV_CHAN_STEREO_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Total
1718 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x20,0x04,0x00,0x00,0x00 }, AV_CHAN_STEREO_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Total
1719 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x01,0x00,0x00 }, AV_CHAN_TOP_FRONT_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Height
1720 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x02,0x00,0x00 }, AV_CHAN_TOP_FRONT_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Height
1721 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x03,0x00,0x00 }, AV_CHAN_TOP_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Height
1722 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x04,0x00,0x00 }, AV_CHAN_TOP_SURROUND_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Surround Height
1723 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x05,0x00,0x00 }, AV_CHAN_TOP_SURROUND_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Surround Height
1724 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x06,0x00,0x00 }, AV_CHAN_TOP_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Side Surround Height
1725 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x07,0x00,0x00 }, AV_CHAN_TOP_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Side Surround Height
1726 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x08,0x00,0x00 }, AV_CHAN_TOP_BACK_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Rear Surround Height
1727 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x09,0x00,0x00 }, AV_CHAN_TOP_BACK_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Rear Surround Height
1728 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0a,0x00,0x00 }, AV_CHAN_TOP_SIDE_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Top Surround
1729 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0b,0x00,0x00 }, AV_CHAN_TOP_SIDE_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Top Surround
1730 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0c,0x00,0x00 }, AV_CHAN_TOP_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Top Surround
1731 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0d,0x00,0x00 }, AV_CHAN_LOW_FREQUENCY, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Front Subwoofer
1732 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0e,0x00,0x00 }, AV_CHAN_LOW_FREQUENCY_2, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Front Subwoofer
1733 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x0f,0x00,0x00 }, AV_CHAN_TOP_BACK_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Rear Height
1734 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x10,0x00,0x00 }, AV_CHAN_BACK_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Rear
1735 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x11,0x00,0x00 }, AV_CHAN_BOTTOM_FRONT_LEFT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Left Below
1736 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x12,0x00,0x00 }, AV_CHAN_BOTTOM_FRONT_RIGHT, AV_AUDIO_SERVICE_TYPE_MAIN }, // Right Below
1737 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0d,0x03,0x02,0x01,0x30,0x01,0x13,0x00,0x00 }, AV_CHAN_BOTTOM_FRONT_CENTER, AV_AUDIO_SERVICE_TYPE_MAIN }, // Center Below
1738 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_AUDIO_SERVICE_TYPE_NB },
1739};
1740
1741static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
1742{
1743 int val;
1744 const MXFCodecUL *codec_ul;
1745
1746 codec_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1747 if (!codec_ul->uid[0])
1748 codec_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1749 if (!codec_ul->uid[0])
1750 codec_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
1751 if (!codec_ul->uid[0] || !codec_ul->wrapping_indicator_pos)
1752 return UnknownWrapped;
1753
1754 val = (*essence_container_ul)[codec_ul->wrapping_indicator_pos];
1755 switch (codec_ul->wrapping_indicator_type) {
1756 case RawVWrap:
1757 val = val % 4;
1758 break;
1759 case RawAWrap:
1760 if (val == 0x03 || val == 0x04)
1761 val -= 0x02;
1762 break;
1763 case D10D11Wrap:
1764 if (val == 0x02)
1765 val = 0x01;
1766 break;
1767 case J2KWrap:
1768 if (val != 0x02)
1769 val = 0x01;
1770 break;
1771 }
1772 if (val == 0x01)
1773 return FrameWrapped;
1774 if (val == 0x02)
1775 return ClipWrapped;
1776 return UnknownWrapped;
1777}
1778
1779static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1780{
1781 int i, j, nb_segments = 0;
1782 MXFIndexTableSegment **unsorted_segments;
1783 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1784 MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[IndexTableSegment];
1785
1786 /* count number of segments, allocate arrays and copy unsorted segments */
1787 nb_segments = mg->metadata_sets_count;
1788 if (!nb_segments)
1789 return AVERROR_INVALIDDATA;
1790
1791 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1792 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1793 av_freep(sorted_segments);
1794 av_free(unsorted_segments);
1795 return AVERROR(ENOMEM);
1796 }
1797
1798 for (i = nb_segments = 0; i < mg->metadata_sets_count; i++) {
1799 MXFIndexTableSegment *s = (MXFIndexTableSegment*)mg->metadata_sets[i];
1800 if (s->edit_unit_byte_count || s->nb_index_entries)
1801 unsorted_segments[nb_segments++] = s;
1802 else
1803 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1804 s->index_sid, s->index_start_position);
1805 }
1806
1807 if (!nb_segments) {
1808 av_freep(sorted_segments);
1809 av_free(unsorted_segments);
1810 return AVERROR_INVALIDDATA;
1811 }
1812
1813 *nb_sorted_segments = 0;
1814
1815 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1816 for (i = 0; i < nb_segments; i++) {
1817 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1818 uint64_t best_index_duration = 0;
1819
1820 for (j = 0; j < nb_segments; j++) {
1821 MXFIndexTableSegment *s = unsorted_segments[j];
1822
1823 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1824 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1825 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1826 */
1827 if ((i == 0 ||
1828 s->body_sid > last_body_sid ||
1829 s->body_sid == last_body_sid && s->index_sid > last_index_sid ||
1830 s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1831 (best == -1 ||
1832 s->body_sid < best_body_sid ||
1833 s->body_sid == best_body_sid && s->index_sid < best_index_sid ||
1834 s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position < best_index_start ||
1835 s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position == best_index_start && s->index_duration > best_index_duration)) {
1836 best = j;
1837 best_body_sid = s->body_sid;
1838 best_index_sid = s->index_sid;
1839 best_index_start = s->index_start_position;
1840 best_index_duration = s->index_duration;
1841 }
1842 }
1843
1844 /* no suitable entry found -> we're done */
1845 if (best == -1)
1846 break;
1847
1848 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1849 last_body_sid = best_body_sid;
1850 last_index_sid = best_index_sid;
1851 last_index_start = best_index_start;
1852 }
1853
1854 av_free(unsorted_segments);
1855
1856 return 0;
1857}
1858
1859/**
1860 * Computes the absolute file offset of the given essence container offset
1861 */
1862static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
1863{
1864 MXFPartition *last_p = NULL;
1865 int a, b, m, m0;
1866
1867 if (offset < 0)
1868 return AVERROR(EINVAL);
1869
1870 a = -1;
1871 b = mxf->partitions_count;
1872
1873 while (b - a > 1) {
1874 m0 = m = (a + b) >> 1;
1875
1876 while (m < b && mxf->partitions[m].body_sid != body_sid)
1877 m++;
1878
1879 if (m < b && mxf->partitions[m].body_offset <= offset)
1880 a = m;
1881 else
1882 b = m0;
1883 }
1884
1885 if (a >= 0)
1886 last_p = &mxf->partitions[a];
1887
1888 if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1889 *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1890 if (partition_out)
1891 *partition_out = last_p;
1892 return 0;
1893 }
1894
1895 av_log(mxf->fc, AV_LOG_ERROR,
1896 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1897 offset, body_sid);
1898
1899 return AVERROR_INVALIDDATA;
1900}
1901
1902/**
1903 * Returns the end position of the essence container with given BodySID, or zero if unknown
1904 */
1905static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1906{
1907 for (int x = mxf->partitions_count - 1; x >= 0; x--) {
1908 MXFPartition *p = &mxf->partitions[x];
1909
1910 if (p->body_sid != body_sid)
1911 continue;
1912
1913 if (!p->essence_length)
1914 return 0;
1915
1916 return p->essence_offset + p->essence_length;
1917 }
1918
1919 return 0;
1920}
1921
1922/* EditUnit -> absolute offset */
1923static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, AVRational edit_rate, int64_t *edit_unit_out, int64_t *offset_out, MXFPartition **partition_out, int nag)
1924{
1925 int i = 0, dir = 0;
1926 int64_t index_duration, index_end;
1927 MXFIndexTableSegment *first_segment, *last_segment;
1928
1929 if (!index_table->nb_segments) {
1930 av_log(mxf->fc, AV_LOG_ERROR, "no index table segments\n");
1931 return AVERROR_INVALIDDATA;
1932 }
1933
1934 edit_unit = av_rescale_q(edit_unit, index_table->segments[0]->index_edit_rate, edit_rate);
1935
1936 first_segment = index_table->segments[0];
1937 last_segment = index_table->segments[index_table->nb_segments - 1];
1938
1939 // clamp to actual range of index
1940 index_end = av_sat_add64(last_segment->index_start_position, last_segment->index_duration);
1941 edit_unit = FFMAX(FFMIN(edit_unit, index_end), first_segment->index_start_position);
1942 if (edit_unit < 0)
1943 return AVERROR_PATCHWELCOME;
1944
1945 // guess which table segment this edit unit is in
1946 // saturation is fine since it's just a guess
1947 // if the guess is wrong we revert to a linear search
1948 index_duration = av_sat_sub64(index_end, first_segment->index_start_position);
1949
1950 // compute the guess, taking care not to cause overflow or division by zero
1951 if (index_duration > 0 && edit_unit <= INT64_MAX / index_table->nb_segments) {
1952 // a simple linear guesstimate
1953 // this is accurate to within +-1 when partitions are generated at a constant rate like mxfenc does
1954 int64_t i64 = index_table->nb_segments * edit_unit / index_duration;
1955 // clamp and downcast to 32-bit
1956 i = FFMAX(0, FFMIN(index_table->nb_segments - 1, i64));
1957 }
1958
1959 for (; i >= 0 && i < index_table->nb_segments; i += dir) {
1960 MXFIndexTableSegment *s = index_table->segments[i];
1961
1962 if (s->index_start_position <= edit_unit && edit_unit < s->index_start_position + s->index_duration) {
1963 int64_t index = edit_unit - s->index_start_position;
1964 int64_t offset_temp = s->offset;
1965
1966 if (s->edit_unit_byte_count) {
1967 if (index > INT64_MAX / s->edit_unit_byte_count ||
1968 s->edit_unit_byte_count * index > INT64_MAX - offset_temp)
1969 return AVERROR_INVALIDDATA;
1970
1971 offset_temp += s->edit_unit_byte_count * index;
1972 } else {
1973 if (s->nb_index_entries == 2 * s->index_duration + 1)
1974 index *= 2; /* Avid index */
1975
1976 if (index < 0 || index >= s->nb_index_entries) {
1977 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1978 index_table->index_sid, s->index_start_position);
1979 return AVERROR_INVALIDDATA;
1980 }
1981
1982 offset_temp = s->stream_offset_entries[index];
1983 }
1984
1985 if (edit_unit_out)
1986 *edit_unit_out = av_rescale_q(edit_unit, edit_rate, s->index_edit_rate);
1987
1988 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out, partition_out);
1989 } else if (dir == 0) {
1990 // scan backwards if the segment is earlier than the current IndexStartPosition
1991 // else scan forwards
1992 if (edit_unit < s->index_start_position) {
1993 dir = -1;
1994 } else {
1995 dir = 1;
1996 }
1997 }
1998 }
1999
2000 if (nag)
2001 av_log(mxf->fc, AV_LOG_ERROR, "failed to map EditUnit %"PRId64" in IndexSID %i to an offset\n", edit_unit, index_table->index_sid);
2002
2003 return AVERROR_INVALIDDATA;
2004}
2005
2006static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
2007{
2008 int i, j, x;
2009 int8_t max_temporal_offset = -128;
2010 uint8_t *flags;
2011
2012 /* first compute how many entries we have */
2013 for (i = 0; i < index_table->nb_segments; i++) {
2014 MXFIndexTableSegment *s = index_table->segments[i];
2015
2016 if (!s->nb_index_entries) {
2017 index_table->nb_ptses = 0;
2018 return 0; /* no TemporalOffsets */
2019 }
2020
2021 if (s->index_duration > INT_MAX - index_table->nb_ptses) {
2022 index_table->nb_ptses = 0;
2023 av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration is too large\n", s->index_sid);
2024 return 0;
2025 }
2026
2027 if (s->nb_index_entries != s->index_duration &&
2028 s->nb_index_entries != s->index_duration + 1 && /* Avid index */
2029 s->nb_index_entries != s->index_duration * 2 + 1) {
2030 index_table->nb_ptses = 0;
2031 av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration does not match nb_index_entries\n", s->index_sid);
2032 return 0;
2033 }
2034
2035 index_table->nb_ptses += s->index_duration;
2036 }
2037
2038 /* paranoid check */
2039 if (index_table->nb_ptses <= 0)
2040 return 0;
2041
2042 if (!(index_table->ptses = av_malloc_array(index_table->nb_ptses, sizeof(int64_t))) ||
2043 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
2044 !(index_table->offsets = av_malloc_array(index_table->nb_ptses, sizeof(int8_t))) ||
2045 !(flags = av_malloc_array(index_table->nb_ptses, sizeof(uint8_t)))) {
2046 av_freep(&index_table->ptses);
2047 av_freep(&index_table->fake_index);
2048 av_freep(&index_table->offsets);
2049 return AVERROR(ENOMEM);
2050 }
2051
2052 /* we may have a few bad TemporalOffsets
2053 * make sure the corresponding PTSes don't have the bogus value 0 */
2054 for (x = 0; x < index_table->nb_ptses; x++)
2055 index_table->ptses[x] = AV_NOPTS_VALUE;
2056
2057 /**
2058 * We have this:
2059 *
2060 * x TemporalOffset
2061 * 0: 0
2062 * 1: 1
2063 * 2: 1
2064 * 3: -2
2065 * 4: 1
2066 * 5: 1
2067 * 6: -2
2068 *
2069 * We want to transform it into this:
2070 *
2071 * x DTS PTS
2072 * 0: -1 0
2073 * 1: 0 3
2074 * 2: 1 1
2075 * 3: 2 2
2076 * 4: 3 6
2077 * 5: 4 4
2078 * 6: 5 5
2079 *
2080 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
2081 * then settings ffstream(mxf)->first_dts = -max(TemporalOffset[x]).
2082 * The latter makes DTS <= PTS.
2083 */
2084 for (i = x = 0; i < index_table->nb_segments; i++) {
2085 MXFIndexTableSegment *s = index_table->segments[i];
2086 int index_delta = 1;
2087 int n = s->nb_index_entries;
2088
2089 if (s->nb_index_entries == 2 * s->index_duration + 1)
2090 index_delta = 2; /* Avid index */
2091 if (s->nb_index_entries == index_delta * s->index_duration + 1)
2092 /* ignore the last entry - it's the size of the essence container in Avid */
2093 n--;
2094
2095 for (j = 0; j < n; j += index_delta, x++) {
2096 int offset = s->temporal_offset_entries[j] / index_delta;
2097 int index = x + offset;
2098
2099 if (x >= index_table->nb_ptses) {
2100 av_log(mxf->fc, AV_LOG_ERROR,
2101 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
2102 s->nb_index_entries, s->index_duration);
2103 break;
2104 }
2105
2106 flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
2107
2108 if (index < 0 || index >= index_table->nb_ptses) {
2109 av_log(mxf->fc, AV_LOG_ERROR,
2110 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
2111 x, offset, index);
2112 continue;
2113 }
2114
2115 index_table->offsets[x] = offset;
2116 index_table->ptses[index] = x;
2117 max_temporal_offset = FFMAX(max_temporal_offset, offset);
2118 }
2119 }
2120
2121 /* calculate the fake index table in display order */
2122 for (x = 0; x < index_table->nb_ptses; x++) {
2123 index_table->fake_index[x].timestamp = x;
2124 if (index_table->ptses[x] != AV_NOPTS_VALUE)
2125 index_table->fake_index[index_table->ptses[x]].flags = flags[x];
2126 }
2127 av_freep(&flags);
2128
2129 index_table->first_dts = -max_temporal_offset;
2130
2131 return 0;
2132}
2133
2134/**
2135 * Sorts and collects index table segments into index tables.
2136 * Also computes PTSes if possible.
2137 */
2138static int mxf_compute_index_tables(MXFContext *mxf)
2139{
2140 int ret, nb_sorted_segments;
2141 MXFIndexTableSegment **sorted_segments = NULL;
2142
2143 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
2144 nb_sorted_segments <= 0) {
2145 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
2146 return 0;
2147 }
2148
2149 /* sanity check and count unique BodySIDs/IndexSIDs */
2150 for (int i = 0; i < nb_sorted_segments; i++) {
2151 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
2152 mxf->nb_index_tables++;
2153 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
2154 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
2155 ret = AVERROR_INVALIDDATA;
2156 goto finish_decoding_index;
2157 }
2158 }
2159
2160 mxf->index_tables = av_calloc(mxf->nb_index_tables,
2161 sizeof(*mxf->index_tables));
2162 if (!mxf->index_tables) {
2163 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
2164 ret = AVERROR(ENOMEM);
2165 goto finish_decoding_index;
2166 }
2167
2168 /* distribute sorted segments to index tables */
2169 for (int i = 0, j = 0; i < nb_sorted_segments; i++) {
2170 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
2171 /* next IndexSID */
2172 j++;
2173 }
2174
2175 mxf->index_tables[j].nb_segments++;
2176 }
2177
2178 for (int i = 0, j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
2179 MXFIndexTable *t = &mxf->index_tables[j];
2180 MXFTrack *mxf_track = NULL;
2181 int64_t offset_temp = 0;
2182
2183 t->segments = av_calloc(t->nb_segments, sizeof(*t->segments));
2184 if (!t->segments) {
2185 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
2186 " pointer array\n");
2187 ret = AVERROR(ENOMEM);
2188 goto finish_decoding_index;
2189 }
2190
2191 if (sorted_segments[i]->index_start_position)
2192 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
2193 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
2194
2195 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
2196 t->index_sid = sorted_segments[i]->index_sid;
2197 t->body_sid = sorted_segments[i]->body_sid;
2198
2199 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
2200 goto finish_decoding_index;
2201
2202 for (int k = 0; k < mxf->fc->nb_streams; k++) {
2203 MXFTrack *track = mxf->fc->streams[k]->priv_data;
2204 if (track && track->index_sid == t->index_sid) {
2205 mxf_track = track;
2206 break;
2207 }
2208 }
2209
2210 /* fix zero IndexDurations and compute segment offsets */
2211 for (int k = 0; k < t->nb_segments; k++) {
2212 MXFIndexTableSegment *s = t->segments[k];
2213
2214 if (!t->segments[k]->index_edit_rate.num || !t->segments[k]->index_edit_rate.den) {
2215 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has invalid IndexEditRate\n",
2216 t->index_sid, k);
2217 if (mxf_track)
2218 t->segments[k]->index_edit_rate = mxf_track->edit_rate;
2219 }
2220
2221 s->offset = offset_temp;
2222
2223 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
2224 if (s->edit_unit_byte_count && (s->index_duration > INT64_MAX / s->edit_unit_byte_count ||
2225 s->edit_unit_byte_count * s->index_duration > INT64_MAX - offset_temp)) {
2226 ret = AVERROR_INVALIDDATA;
2227 goto finish_decoding_index;
2228 }
2229
2230 offset_temp += t->segments[k]->edit_unit_byte_count * t->segments[k]->index_duration;
2231
2232 if (t->segments[k]->index_duration)
2233 continue;
2234
2235 if (t->nb_segments > 1)
2236 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
2237 t->index_sid, k);
2238
2239 if (!mxf_track) {
2240 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
2241 break;
2242 }
2243
2244 /* assume the first stream's duration is reasonable
2245 * leave index_duration = 0 on further segments in case we have any (unlikely)
2246 */
2247 t->segments[k]->index_duration = mxf_track->original_duration;
2248 break;
2249 }
2250 }
2251
2252 ret = 0;
2253finish_decoding_index:
2254 av_free(sorted_segments);
2255 return ret;
2256}
2257
2258static int mxf_is_st_422(const UID *essence_container_ul) {
2259 static const uint8_t st_422_essence_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c };
2260
2261 return essence_container_ul && mxf_match_uid(*essence_container_ul, st_422_essence_container_ul,
2262 sizeof(st_422_essence_container_ul));
2263}
2264
2272
2273static void mxf_umid_to_str(const UID ul, const UID uid,
2274 char str[2 + sizeof(UID) * 4 + 1])
2275{
2276 snprintf(str, 2 + sizeof(UID) * 4 + 1, "0x");
2277 ff_data_to_hex(str + 2, ul, sizeof(UID), 0);
2278 ff_data_to_hex(str + 2 + 2 * sizeof(UID), uid, sizeof(UID), 0);
2279}
2280
2281static int mxf_version_to_str(uint16_t major, uint16_t minor, uint16_t tertiary,
2282 uint16_t patch, uint16_t release, char **str)
2283{
2284 *str = av_asprintf("%d.%d.%d.%d.%d", major, minor, tertiary, patch, release);
2285 if (!*str)
2286 return AVERROR(ENOMEM);
2287 return 0;
2288}
2289
2290static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
2291{
2292 char str[2 + 4 * sizeof(UID) + 1];
2293 if (!package)
2294 return 0;
2295 mxf_umid_to_str(package->package_ul, package->package_uid, str);
2296 av_dict_set(pm, key, str, 0);
2297 return 0;
2298}
2299
2300static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
2301{
2302 char buf[AV_TIMECODE_STR_SIZE];
2303 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
2304
2305 return 0;
2306}
2307
2308static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
2309{
2310 MXFTimecodeComponent *timecode;
2311 MXFPulldownComponent *pulldown;
2312
2313 timecode = mxf_resolve_strong_ref(mxf, strong_ref, TimecodeComponent);
2314 if (timecode)
2315 return timecode;
2316
2317 pulldown = mxf_resolve_strong_ref(mxf, strong_ref, PulldownComponent);
2318 if (pulldown)
2319 return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
2320
2321 return NULL;
2322}
2323
2324static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
2325{
2326 MXFPackage *package = NULL;
2327 int i;
2328
2329 for (i = 0; i < mxf->packages_count; i++) {
2330 package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
2331 if (!package)
2332 continue;
2333
2334 if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
2335 return package;
2336 }
2337 return NULL;
2338}
2339
2340static MXFDescriptor* mxf_resolve_descriptor(MXFContext *mxf, UID *strong_ref, int track_id)
2341{
2342 MXFDescriptor *descriptor = mxf_resolve_strong_ref(mxf, strong_ref, Descriptor);
2343 if (descriptor)
2344 return descriptor;
2345
2346 descriptor = mxf_resolve_strong_ref(mxf, strong_ref, MultipleDescriptor);
2347 if (descriptor) {
2348 for (int i = 0; i < descriptor->file_descriptors_count; i++) {
2349 MXFDescriptor *file_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->file_descriptors_refs[i], Descriptor);
2350
2351 if (!file_descriptor) {
2352 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve file descriptor strong ref\n");
2353 continue;
2354 }
2355 if (file_descriptor->linked_track_id == track_id) {
2356 return file_descriptor;
2357 }
2358 }
2359 }
2360
2361 return NULL;
2362}
2363
2364static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
2365{
2366 MXFStructuralComponent *component = NULL;
2367 MXFPackage *package = NULL;
2368 MXFDescriptor *descriptor = NULL;
2369 MXFEssenceGroup *essence_group;
2370 int i;
2371
2372 component = mxf_resolve_strong_ref(mxf, strong_ref, SourceClip);
2373 if (component)
2374 return component;
2375
2376 essence_group = mxf_resolve_strong_ref(mxf, strong_ref, EssenceGroup);
2377 if (!essence_group)
2378 return NULL;
2379
2380 /* essence groups contains multiple representations of the same media,
2381 this return the first components with a valid Descriptor typically index 0 */
2382 for (i =0; i < essence_group->structural_components_count; i++){
2383 component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
2384 if (!component)
2385 continue;
2386
2387 if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
2388 continue;
2389
2390 descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
2391 if (descriptor)
2392 return component;
2393 }
2394
2395 return NULL;
2396}
2397
2398static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
2399{
2400 MXFTaggedValue *tag;
2401 int i;
2402 char *key = NULL;
2403
2404 for (i = 0; i < package->comment_count; i++) {
2405 tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
2406 if (!tag || !tag->name || !tag->value)
2407 continue;
2408
2409 key = av_asprintf("comment_%s", tag->name);
2410 if (!key)
2411 return AVERROR(ENOMEM);
2412
2413 av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
2414 }
2415 return 0;
2416}
2417
2418static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
2419{
2420 MXFPackage *physical_package = NULL;
2421 MXFTrack *physical_track = NULL;
2422 MXFStructuralComponent *sourceclip = NULL;
2423 MXFTimecodeComponent *mxf_tc = NULL;
2424 int i, j, k;
2425 AVTimecode tc;
2426 int flags;
2427 int64_t start_position;
2428
2429 for (i = 0; i < source_track->sequence->structural_components_count; i++) {
2430 sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
2431 if (!sourceclip)
2432 continue;
2433
2434 if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
2435 break;
2436
2437 mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
2438
2439 /* the name of physical source package is name of the reel or tape */
2440 if (physical_package->name && physical_package->name[0])
2441 av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
2442
2443 /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
2444 * to the start_frame of the timecode component located on one of the tracks of the physical source package.
2445 */
2446 for (j = 0; j < physical_package->tracks_count; j++) {
2447 if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
2448 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2449 continue;
2450 }
2451
2452 if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
2453 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2454 continue;
2455 }
2456
2457 if (physical_track->edit_rate.num <= 0 ||
2458 physical_track->edit_rate.den <= 0) {
2459 av_log(mxf->fc, AV_LOG_WARNING,
2460 "Invalid edit rate (%d/%d) found on structural"
2461 " component #%d, defaulting to 25/1\n",
2462 physical_track->edit_rate.num,
2463 physical_track->edit_rate.den, i);
2464 physical_track->edit_rate = (AVRational){25, 1};
2465 }
2466
2467 for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
2468 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
2469 continue;
2470
2471 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2472 /* scale sourceclip start_position to match physical track edit rate */
2473 start_position = av_rescale_q(sourceclip->start_position,
2474 physical_track->edit_rate,
2475 source_track->edit_rate);
2476
2477 if (av_sat_add64(start_position, mxf_tc->start_frame) != start_position + (uint64_t)mxf_tc->start_frame)
2478 return AVERROR_INVALIDDATA;
2479
2480 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
2481 mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
2482 return 0;
2483 }
2484 }
2485 }
2486 }
2487
2488 return 0;
2489}
2490
2491static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
2492{
2493 MXFStructuralComponent *component = NULL;
2494 const MXFCodecUL *codec_ul = NULL;
2495 MXFPackage tmp_package;
2496 AVStream *st;
2497 int j;
2498
2499 for (j = 0; j < track->sequence->structural_components_count; j++) {
2500 component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
2501 if (!component)
2502 continue;
2503 break;
2504 }
2505 if (!component)
2506 return 0;
2507
2508 st = avformat_new_stream(mxf->fc, NULL);
2509 if (!st) {
2510 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
2511 return AVERROR(ENOMEM);
2512 }
2513
2514 st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
2515 st->codecpar->codec_id = AV_CODEC_ID_NONE;
2516 st->id = track->track_id;
2517
2518 memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
2519 memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
2520 mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
2521 if (track->name && track->name[0])
2522 av_dict_set(&st->metadata, "track_name", track->name, 0);
2523
2524 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
2525 av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
2526 return 0;
2527}
2528
2529static enum AVColorRange mxf_get_color_range(MXFContext *mxf, MXFDescriptor *descriptor)
2530{
2531 if (descriptor->black_ref_level || descriptor->white_ref_level || descriptor->color_range) {
2532 /* CDCI range metadata */
2533 if (!descriptor->component_depth)
2534 return AVCOL_RANGE_UNSPECIFIED;
2535 if (descriptor->black_ref_level == 0 && descriptor->component_depth < 31 &&
2536 descriptor->white_ref_level == ((1<<descriptor->component_depth) - 1) &&
2537 (descriptor->color_range == (1<<descriptor->component_depth) ||
2538 descriptor->color_range == ((1<<descriptor->component_depth) - 1)))
2539 return AVCOL_RANGE_JPEG;
2540 if (descriptor->component_depth >= 8 && descriptor->component_depth < 31 &&
2541 descriptor->black_ref_level == (1 <<(descriptor->component_depth - 4)) &&
2542 descriptor->white_ref_level == (235<<(descriptor->component_depth - 8)) &&
2543 descriptor->color_range == ((14<<(descriptor->component_depth - 4)) + 1))
2544 return AVCOL_RANGE_MPEG;
2545 avpriv_request_sample(mxf->fc, "Unrecognized CDCI color range (color diff range %d, b %d, w %d, depth %d)",
2546 descriptor->color_range, descriptor->black_ref_level,
2547 descriptor->white_ref_level, descriptor->component_depth);
2548 }
2549
2550 return AVCOL_RANGE_UNSPECIFIED;
2551}
2552
2553static int is_pcm(enum AVCodecID codec_id)
2554{
2555 /* we only care about "normal" PCM codecs until we get samples */
2556 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2557}
2558
2559static int set_language(AVFormatContext *s, const char *rfc5646, AVDictionary **met)
2560{
2561 // language abbr should contain at least 2 chars
2562 if (rfc5646 && strlen(rfc5646) > 1) {
2563 char primary_tag[4] =
2564 {rfc5646[0], rfc5646[1], rfc5646[2] != '-' ? rfc5646[2] : '\0', '\0'};
2565
2566 const char *iso6392 = ff_convert_lang_to(primary_tag,
2567 AV_LANG_ISO639_2_BIBL);
2568 if (iso6392)
2569 return(av_dict_set(met, "language", iso6392, 0));
2570 }
2571 return 0;
2572}
2573
2574static MXFMCASubDescriptor *find_mca_link_id(MXFContext *mxf, enum MXFMetadataSetType type, UID *mca_link_id)
2575{
2576 MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[type];
2577 for (int k = 0; k < mg->metadata_sets_count; k++) {
2578 MXFMCASubDescriptor *group = (MXFMCASubDescriptor*)mg->metadata_sets[k];
2579 if (!memcmp(&group->mca_link_id, mca_link_id, 16))
2580 return group;
2581 }
2582 return NULL;
2583}
2584
2585static void parse_ffv1_sub_descriptor(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
2586{
2587 for (int i = 0; i < descriptor->sub_descriptors_count; i++) {
2588 MXFFFV1SubDescriptor *ffv1_sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], FFV1SubDescriptor);
2589 if (ffv1_sub_descriptor == NULL)
2590 continue;
2591
2592 descriptor->extradata = ffv1_sub_descriptor->extradata;
2593 descriptor->extradata_size = ffv1_sub_descriptor->extradata_size;
2594 ffv1_sub_descriptor->extradata = NULL;
2595 ffv1_sub_descriptor->extradata_size = 0;
2596 break;
2597 }
2598}
2599
2600static int parse_mca_labels(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
2601{
2602 AVChannelLayout *ch_layout = &st->codecpar->ch_layout;
2603 char *language = NULL;
2604 int ambigous_language = 0;
2605 enum AVAudioServiceType service_type = AV_AUDIO_SERVICE_TYPE_NB;
2606 int ambigous_service_type = 0;
2607 int ret;
2608
2609 for (int i = 0; i < descriptor->sub_descriptors_count; i++) {
2610 char *channel_language;
2611
2612 MXFMCASubDescriptor *label = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], AudioChannelLabelSubDescriptor);
2613 if (label == NULL)
2614 continue;
2615
2616 if (ch_layout->order == AV_CHANNEL_ORDER_UNSPEC) {
2617 av_channel_layout_uninit(ch_layout);
2618 ret = av_channel_layout_custom_init(ch_layout, descriptor->channels);
2619 if (ret < 0)
2620 return ret;
2621 }
2622
2623 for (const MXFChannelOrderingUL* channel_ordering = mxf_channel_ordering; channel_ordering->uid[0]; channel_ordering++) {
2624 if (IS_KLV_KEY(channel_ordering->uid, label->mca_label_dictionary_id)) {
2625 int target_channel = label->mca_channel_id;
2626 if (target_channel == 0 && descriptor->channels == 1)
2627 target_channel = 1;
2628 if (target_channel <= 0 || target_channel > descriptor->channels) {
2629 av_log(mxf->fc, AV_LOG_ERROR, "AudioChannelLabelSubDescriptor has invalid MCA channel ID %d\n", target_channel);
2630 return AVERROR_INVALIDDATA;
2631 }
2632 ch_layout->u.map[target_channel - 1].id = channel_ordering->channel;
2633 if (service_type == AV_AUDIO_SERVICE_TYPE_NB)
2634 service_type = channel_ordering->service_type;
2635 else if (service_type != channel_ordering->service_type)
2636 ambigous_service_type = 1;
2637 break;
2638 }
2639 }
2640
2641 channel_language = label->language;
2642 if (!channel_language) {
2643 MXFMCASubDescriptor *group = find_mca_link_id(mxf, SoundfieldGroupLabelSubDescriptor, &label->soundfield_group_link_id);
2644 if (group) {
2645 channel_language = group->language;
2646 if (!channel_language && group->group_of_soundfield_groups_link_id_count) {
2647 MXFMCASubDescriptor *supergroup = find_mca_link_id(mxf, GroupOfSoundfieldGroupsLabelSubDescriptor,
2648 group->group_of_soundfield_groups_link_id_refs);
2649 if (supergroup)
2650 channel_language = supergroup->language;
2651 }
2652 }
2653 }
2654 if (channel_language) {
2655 if (language && strcmp(language, channel_language))
2656 ambigous_language = 1;
2657 else
2658 language = channel_language;
2659 }
2660 }
2661
2662 if (language && !ambigous_language) {
2663 ret = set_language(mxf->fc, language, &st->metadata);
2664 if (ret < 0)
2665 return ret;
2666 }
2667
2668 if (service_type != AV_AUDIO_SERVICE_TYPE_NB && service_type != AV_AUDIO_SERVICE_TYPE_MAIN && !ambigous_service_type) {
2669 enum AVAudioServiceType *ast;
2670 AVPacketSideData *side_data = av_packet_side_data_new(&st->codecpar->coded_side_data,
2671 &st->codecpar->nb_coded_side_data,
2672 AV_PKT_DATA_AUDIO_SERVICE_TYPE,
2673 sizeof(*ast), 0);
2674 if (!side_data)
2675 return AVERROR(ENOMEM);
2676 ast = (enum AVAudioServiceType*)side_data->data;
2677 *ast = service_type;
2678 }
2679
2680 ret = av_channel_layout_retype(ch_layout, 0, AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL);
2681 if (ret < 0)
2682 return ret;
2683
2684 return 0;
2685}
2686
2687static int mxf_parse_structural_metadata(MXFContext *mxf)
2688{
2689 MXFPackage *material_package = NULL;
2690 int k, ret;
2691
2692 /* TODO: handle multiple material packages (OP3x) */
2693 for (int i = 0; i < mxf->packages_count; i++) {
2694 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2695 if (material_package) break;
2696 }
2697 if (!material_package) {
2698 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2699 return AVERROR_INVALIDDATA;
2700 }
2701
2702 mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2703 if (material_package->name && material_package->name[0])
2704 av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2705 mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2706
2707 for (int i = 0; i < material_package->tracks_count; i++) {
2708 MXFPackage *source_package = NULL;
2709 MXFTrack *material_track = NULL;
2710 MXFTrack *source_track = NULL;
2711 MXFTrack *temp_track = NULL;
2712 MXFDescriptor *descriptor = NULL;
2713 MXFStructuralComponent *component = NULL;
2714 MXFTimecodeComponent *mxf_tc = NULL;
2715 UID *essence_container_ul = NULL;
2716 const MXFCodecUL *codec_ul = NULL;
2717 const MXFCodecUL *container_ul = NULL;
2718 const MXFCodecUL *pix_fmt_ul = NULL;
2719 AVStream *st;
2720 FFStream *sti;
2721 AVTimecode tc;
2722 int flags;
2723
2724 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2725 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2726 continue;
2727 }
2728
2729 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2730 mxf_tc = (MXFTimecodeComponent*)component;
2731 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2732 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2733 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2734 }
2735 }
2736
2737 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2738 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2739 continue;
2740 }
2741
2742 for (int j = 0; j < material_track->sequence->structural_components_count; j++) {
2743 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2744 if (!component)
2745 continue;
2746
2747 mxf_tc = (MXFTimecodeComponent*)component;
2748 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2749 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2750 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2751 break;
2752 }
2753 }
2754
2755 /* TODO: handle multiple source clips, only finds first valid source clip */
2756 if(material_track->sequence->structural_components_count > 1)
2757 av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2758 material_track->track_id, material_track->sequence->structural_components_count);
2759
2760 for (int j = 0; j < material_track->sequence->structural_components_count; j++) {
2761 component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2762 if (!component)
2763 continue;
2764
2765 source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2766 if (!source_package) {
2767 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2768 continue;
2769 }
2770 for (k = 0; k < source_package->tracks_count; k++) {
2771 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2772 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2773 ret = AVERROR_INVALIDDATA;
2774 goto fail_and_free;
2775 }
2776 if (temp_track->track_id == component->source_track_id) {
2777 source_track = temp_track;
2778 break;
2779 }
2780 }
2781 if (!source_track) {
2782 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2783 break;
2784 }
2785
2786 for (k = 0; k < mxf->essence_container_data_count; k++) {
2787 MXFEssenceContainerData *essence_data;
2788
2789 if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2790 av_log(mxf->fc, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2791 continue;
2792 }
2793 if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2794 source_track->body_sid = essence_data->body_sid;
2795 source_track->index_sid = essence_data->index_sid;
2796 break;
2797 }
2798 }
2799
2800 if(source_track && component)
2801 break;
2802 }
2803 if (!source_track || !component || !source_package) {
2804 if((ret = mxf_add_metadata_stream(mxf, material_track)))
2805 goto fail_and_free;
2806 continue;
2807 }
2808
2809 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2810 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2811 ret = AVERROR_INVALIDDATA;
2812 goto fail_and_free;
2813 }
2814
2815 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2816 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2817 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2818 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2819 continue;
2820 }
2821
2822 st = avformat_new_stream(mxf->fc, NULL);
2823 if (!st) {
2824 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2825 ret = AVERROR(ENOMEM);
2826 goto fail_and_free;
2827 }
2828 sti = ffstream(st);
2829 st->id = material_track->track_id;
2830 st->priv_data = source_track;
2831
2832 descriptor = mxf_resolve_descriptor(mxf, &source_package->descriptor_ref, source_track->track_id);
2833
2834 /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2835 * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2836 if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2837 source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2838 else
2839 source_track->original_duration = st->duration = component->duration;
2840
2841 if (st->duration == -1)
2842 st->duration = AV_NOPTS_VALUE;
2843 st->start_time = component->start_position;
2844 if (material_track->edit_rate.num <= 0 ||
2845 material_track->edit_rate.den <= 0) {
2846 av_log(mxf->fc, AV_LOG_WARNING,
2847 "Invalid edit rate (%d/%d) found on stream #%d, "
2848 "defaulting to 25/1\n",
2849 material_track->edit_rate.num,
2850 material_track->edit_rate.den, st->index);
2851 material_track->edit_rate = (AVRational){25, 1};
2852 }
2853 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2854
2855 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2856 * the former is accessible via st->priv_data */
2857 source_track->edit_rate = material_track->edit_rate;
2858
2859 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
2860 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2861 st->codecpar->codec_type = codec_ul->id;
2862
2863 if (!descriptor) {
2864 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2865 continue;
2866 }
2867 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
2868 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2869 essence_container_ul = &descriptor->essence_container_ul;
2870 source_track->wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_kind(essence_container_ul);
2871 if (source_track->wrapping == UnknownWrapped)
2872 av_log(mxf->fc, AV_LOG_INFO, "wrapping of stream %d is unknown\n", st->index);
2873 /* HACK: replacing the original key with mxf_encrypted_essence_container
2874 * is not allowed according to s429-6, try to find correct information anyway */
2875 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2876 MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[CryptoContext];
2877 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2878 if (mg->metadata_sets_count) {
2879 MXFMetadataSet *metadata = mg->metadata_sets[0];
2880 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2881 }
2882 }
2883
2884 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2885 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2886 st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2887 if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2888 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2889 st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2890 }
2891
2892 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2893 avcodec_get_name(st->codecpar->codec_id));
2894 for (k = 0; k < 16; k++) {
2895 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2896 descriptor->essence_codec_ul[k]);
2897 if (!(k+1 & 19) || k == 5)
2898 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2899 }
2900 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2901
2902 mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2903 if (source_package->name && source_package->name[0])
2904 av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2905 if (material_track->name && material_track->name[0])
2906 av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2907
2908 mxf_parse_physical_source_package(mxf, source_track, st);
2909
2910 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2911 source_track->intra_only = mxf_is_intra_only(descriptor);
2912 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2913 if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2914 st->codecpar->codec_id = container_ul->id;
2915 st->codecpar->width = descriptor->width;
2916 st->codecpar->height = descriptor->height; /* Field height, not frame height */
2917 switch (descriptor->frame_layout) {
2918 case FullFrame:
2919 st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2920 break;
2921 case OneField:
2922 /* Every other line is stored and needs to be duplicated. */
2923 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2924 break; /* The correct thing to do here is fall through, but by breaking we might be
2925 able to decode some streams at half the vertical resolution, rather than not al all.
2926 It's also for compatibility with the old behavior. */
2927 case MixedFields:
2928 break;
2929 case SegmentedFrame:
2930 st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2931 av_fallthrough;
2932 case SeparateFields:
2933 av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2934 descriptor->video_line_map[0], descriptor->video_line_map[1],
2935 descriptor->field_dominance);
2936 if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2937 /* Detect coded field order from VideoLineMap:
2938 * (even, even) => bottom field coded first
2939 * (even, odd) => top field coded first
2940 * (odd, even) => top field coded first
2941 * (odd, odd) => bottom field coded first
2942 */
2943 if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2944 switch (descriptor->field_dominance) {
2945 case MXF_FIELD_DOMINANCE_DEFAULT:
2946 case MXF_FIELD_DOMINANCE_FF:
2947 st->codecpar->field_order = AV_FIELD_TT;
2948 break;
2949 case MXF_FIELD_DOMINANCE_FL:
2950 st->codecpar->field_order = AV_FIELD_TB;
2951 break;
2952 default:
2953 avpriv_request_sample(mxf->fc,
2954 "Field dominance %d support",
2955 descriptor->field_dominance);
2956 }
2957 } else {
2958 switch (descriptor->field_dominance) {
2959 case MXF_FIELD_DOMINANCE_DEFAULT:
2960 case MXF_FIELD_DOMINANCE_FF:
2961 st->codecpar->field_order = AV_FIELD_BB;
2962 break;
2963 case MXF_FIELD_DOMINANCE_FL:
2964 st->codecpar->field_order = AV_FIELD_BT;
2965 break;
2966 default:
2967 avpriv_request_sample(mxf->fc,
2968 "Field dominance %d support",
2969 descriptor->field_dominance);
2970 }
2971 }
2972 }
2973 /* Turn field height into frame height. */
2974 st->codecpar->height *= 2;
2975 break;
2976 default:
2977 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2978 }
2979
2980 if (mxf_is_st_422(essence_container_ul)) {
2981 switch ((*essence_container_ul)[14]) {
2982 case 2: /* Cn: Clip- wrapped Picture Element */
2983 case 3: /* I1: Interlaced Frame, 1 field/KLV */
2984 case 4: /* I2: Interlaced Frame, 2 fields/KLV */
2985 case 6: /* P1: Frame- wrapped Picture Element */
2986 st->avg_frame_rate = source_track->edit_rate;
2987 st->r_frame_rate = st->avg_frame_rate;
2988 break;
2989 case 5: /* F1: Field-wrapped Picture Element */
2990 st->avg_frame_rate = av_mul_q(av_make_q(2, 1), source_track->edit_rate);
2991 st->r_frame_rate = st->avg_frame_rate;
2992 break;
2993 default:
2994 break;
2995 }
2996 }
2997
2998 if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2999 switch (descriptor->essence_codec_ul[14]) {
3000 case 1: st->codecpar->codec_tag = MKTAG('a','p','c','o'); break;
3001 case 2: st->codecpar->codec_tag = MKTAG('a','p','c','s'); break;
3002 case 3: st->codecpar->codec_tag = MKTAG('a','p','c','n'); break;
3003 case 4: st->codecpar->codec_tag = MKTAG('a','p','c','h'); break;
3004 case 5: st->codecpar->codec_tag = MKTAG('a','p','4','h'); break;
3005 case 6: st->codecpar->codec_tag = MKTAG('a','p','4','x'); break;
3006 }
3007 }
3008
3009 if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
3010 st->codecpar->format = descriptor->pix_fmt;
3011 if (st->codecpar->format == AV_PIX_FMT_NONE) {
3012 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
3013 &descriptor->essence_codec_ul);
3014 st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
3015 if (st->codecpar->format== AV_PIX_FMT_NONE) {
3016 st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
3017 &descriptor->essence_codec_ul)->id;
3018 if (!st->codecpar->codec_tag) {
3019 /* support files created before RP224v10 by defaulting to UYVY422
3020 if subsampling is 4:2:2 and component depth is 8-bit */
3021 if (descriptor->horiz_subsampling == 2 &&
3022 descriptor->vert_subsampling == 1 &&
3023 descriptor->component_depth == 8) {
3024 st->codecpar->format = AV_PIX_FMT_UYVY422;
3025 }
3026 }
3027 }
3028 }
3029 }
3030 sti->need_parsing = AVSTREAM_PARSE_HEADERS;
3031 if (material_track->origin) {
3032 av_dict_set_int(&st->metadata, "material_track_origin", material_track->origin, 0);
3033 }
3034 if (source_track->origin) {
3035 av_dict_set_int(&st->metadata, "source_track_origin", source_track->origin, 0);
3036 }
3037 if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
3038 sti->display_aspect_ratio = descriptor->aspect_ratio;
3039 st->codecpar->color_range = mxf_get_color_range(mxf, descriptor);
3040 st->codecpar->color_primaries = mxf_get_codec_ul(ff_mxf_color_primaries_uls, &descriptor->color_primaries_ul)->id;
3041 st->codecpar->color_trc = mxf_get_codec_ul(ff_mxf_color_trc_uls, &descriptor->color_trc_ul)->id;
3042 st->codecpar->color_space = mxf_get_codec_ul(ff_mxf_color_space_uls, &descriptor->color_space_ul)->id;
3043 if (descriptor->mastering) {
3044 if (!av_packet_side_data_add(&st->codecpar->coded_side_data, &st->codecpar->nb_coded_side_data,
3045 AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
3046 (uint8_t *)descriptor->mastering, descriptor->mastering_size, 0)) {
3047 ret = AVERROR(ENOMEM);
3048 goto fail_and_free;
3049 }
3050 descriptor->mastering = NULL;
3051 }
3052 if (descriptor->coll) {
3053 if (!av_packet_side_data_add(&st->codecpar->coded_side_data, &st->codecpar->nb_coded_side_data,
3054 AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
3055 (uint8_t *)descriptor->coll, descriptor->coll_size, 0)) {
3056 ret = AVERROR(ENOMEM);
3057 goto fail_and_free;
3058 }
3059 descriptor->coll = NULL;
3060 }
3061 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3062 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
3063 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
3064 if (st->codecpar->codec_id == AV_CODEC_ID_NONE || (st->codecpar->codec_id == AV_CODEC_ID_PCM_ALAW && (enum AVCodecID)container_ul->id != AV_CODEC_ID_NONE))
3065 st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
3066 st->codecpar->ch_layout.nb_channels = descriptor->channels;
3067
3068 if (descriptor->sample_rate.den > 0) {
3069 st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
3070 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
3071 } else {
3072 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
3073 "found for stream #%d, time base forced to 1/48000\n",
3074 descriptor->sample_rate.num, descriptor->sample_rate.den,
3075 st->index);
3076 avpriv_set_pts_info(st, 64, 1, 48000);
3077 }
3078
3079 /* if duration is set, rescale it from EditRate to SampleRate */
3080 if (st->duration != AV_NOPTS_VALUE)
3081 st->duration = av_rescale_q(st->duration,
3082 av_inv_q(material_track->edit_rate),
3083 st->time_base);
3084
3085 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
3086 if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
3087 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
3088 st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
3089 else if (descriptor->bits_per_sample == 32)
3090 st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
3091 } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
3092 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
3093 st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
3094 else if (descriptor->bits_per_sample == 32)
3095 st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
3096 } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
3097 sti->need_parsing = AVSTREAM_PARSE_FULL;
3098 } else if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
3099 sti->need_parsing = AVSTREAM_PARSE_FULL;
3100 }
3101 st->codecpar->bits_per_coded_sample = av_get_bits_per_sample(st->codecpar->codec_id);
3102
3103 if (descriptor->channels <= 0 || descriptor->channels >= FF_SANE_NB_CHANNELS) {
3104 av_log(mxf->fc, AV_LOG_ERROR, "Invalid number of channels %d, must be less than %d\n", descriptor->channels, FF_SANE_NB_CHANNELS);
3105 return AVERROR_INVALIDDATA;
3106 }
3107
3108 ret = parse_mca_labels(mxf, source_track, descriptor, st);
3109 if (ret < 0)
3110 return ret;
3111 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
3112 enum AVMediaType type;
3113 container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
3114 if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
3115 st->codecpar->codec_id = container_ul->id;
3116 type = avcodec_get_type(st->codecpar->codec_id);
3117 if (type == AVMEDIA_TYPE_SUBTITLE)
3118 st->codecpar->codec_type = type;
3119 if (container_ul->desc)
3120 av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
3121 if (mxf->eia608_extract && st->codecpar->codec_id == AV_CODEC_ID_SMPTE_436M_ANC) {
3122 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
3123 st->codecpar->codec_id = AV_CODEC_ID_EIA_608;
3124 }
3125 }
3126 if (!descriptor->extradata)
3127 parse_ffv1_sub_descriptor(mxf, source_track, descriptor, st);
3128 if (descriptor->extradata) {
3129 if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
3130 memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
3131 }
3132 } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
3133 int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
3134 &descriptor->essence_codec_ul)->id;
3135 if (coded_width)
3136 st->codecpar->width = coded_width;
3137 ret = ff_generate_avci_extradata(st);
3138 if (ret < 0)
3139 return ret;
3140 }
3141 if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && source_track->wrapping != FrameWrapped) {
3142 /* TODO: decode timestamps */
3143 sti->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
3144 }
3145 }
3146
3147 for (int i = 0; i < mxf->fc->nb_streams; i++) {
3148 MXFTrack *track1 = mxf->fc->streams[i]->priv_data;
3149 if (track1 && track1->body_sid) {
3150 for (int j = i + 1; j < mxf->fc->nb_streams; j++) {
3151 MXFTrack *track2 = mxf->fc->streams[j]->priv_data;
3152 if (track2 && track1->body_sid == track2->body_sid && track1->wrapping != track2->wrapping) {
3153 if (track1->wrapping == UnknownWrapped)
3154 track1->wrapping = track2->wrapping;
3155 else if (track2->wrapping == UnknownWrapped)
3156 track2->wrapping = track1->wrapping;
3157 else
3158 av_log(mxf->fc, AV_LOG_ERROR, "stream %d and stream %d have the same BodySID (%d) "
3159 "with different wrapping\n", i, j, track1->body_sid);
3160 }
3161 }
3162 }
3163 }
3164
3165 ret = 0;
3166fail_and_free:
3167 return ret;
3168}
3169
3170static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
3171{
3172 struct tm time = { 0 };
3173 int msecs;
3174 time.tm_year = (timestamp >> 48) - 1900;
3175 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
3176 time.tm_mday = (timestamp >> 32 & 0xFF);
3177 time.tm_hour = (timestamp >> 24 & 0xFF);
3178 time.tm_min = (timestamp >> 16 & 0xFF);
3179 time.tm_sec = (timestamp >> 8 & 0xFF);
3180 msecs = (timestamp & 0xFF) * 4;
3181
3182 /* Clip values for legacy reasons. Maybe we should return error instead? */
3183 time.tm_mon = av_clip(time.tm_mon, 0, 11);
3184 time.tm_mday = av_clip(time.tm_mday, 1, 31);
3185 time.tm_hour = av_clip(time.tm_hour, 0, 23);
3186 time.tm_min = av_clip(time.tm_min, 0, 59);
3187 time.tm_sec = av_clip(time.tm_sec, 0, 59);
3188 msecs = av_clip(msecs, 0, 999);
3189
3190 return (int64_t)av_timegm(&time) * 1000000 + msecs * 1000;
3191}
3192
3193#define SET_STR_METADATA(pb, name, str) do { \
3194 if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
3195 return ret; \
3196 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
3197} while (0)
3198
3199#define SET_VERSION_METADATA(pb, name, major, minor, tertiary, patch, release, str) do { \
3200 major = avio_rb16(pb); \
3201 minor = avio_rb16(pb); \
3202 tertiary = avio_rb16(pb); \
3203 patch = avio_rb16(pb); \
3204 release = avio_rb16(pb); \
3205 if ((ret = mxf_version_to_str(major, minor, tertiary, patch, release, &str)) < 0) \
3206 return ret; \
3207 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
3208} while (0)
3209
3210#define SET_UID_METADATA(pb, name, var, str) do { \
3211 char uuid_str[2 * AV_UUID_LEN + 4 + 1]; \
3212 avio_read(pb, var, 16); \
3213 av_uuid_unparse(uid, uuid_str); \
3214 av_dict_set(&s->metadata, name, uuid_str, 0); \
3215} while (0)
3216
3217#define SET_TS_METADATA(pb, name, var, str) do { \
3218 var = avio_rb64(pb); \
3219 if (var && (ret = ff_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var))) < 0) \
3220 return ret; \
3221} while (0)
3222
3223static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
3224{
3225 MXFContext *mxf = arg;
3226 AVFormatContext *s = mxf->fc;
3227 int ret;
3228 UID uid = { 0 };
3229 char *str = NULL;
3230 uint64_t ts;
3231 uint16_t major, minor, tertiary, patch, release;
3232 switch (tag) {
3233 case 0x3C01:
3234 SET_STR_METADATA(pb, "company_name", str);
3235 break;
3236 case 0x3C02:
3237 SET_STR_METADATA(pb, "product_name", str);
3238 break;
3239 case 0x3C03:
3240 SET_VERSION_METADATA(pb, "product_version_num", major, minor, tertiary, patch, release, str);
3241 break;
3242 case 0x3C04:
3243 SET_STR_METADATA(pb, "product_version", str);
3244 break;
3245 case 0x3C05:
3246 SET_UID_METADATA(pb, "product_uid", uid, str);
3247 break;
3248 case 0x3C06:
3249 SET_TS_METADATA(pb, "modification_date", ts, str);
3250 break;
3251 case 0x3C07:
3252 SET_VERSION_METADATA(pb, "toolkit_version_num", major, minor, tertiary, patch, release, str);
3253 break;
3254 case 0x3C08:
3255 SET_STR_METADATA(pb, "application_platform", str);
3256 break;
3257 case 0x3C09:
3258 SET_UID_METADATA(pb, "generation_uid", uid, str);
3259 break;
3260 case 0x3C0A:
3261 SET_UID_METADATA(pb, "uid", uid, str);
3262 break;
3263 }
3264 return 0;
3265}
3266
3267static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
3268{
3269 MXFContext *mxf = arg;
3270 AVFormatContext *s = mxf->fc;
3271 int ret;
3272 char *str = NULL;
3273
3274 if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
3275 SET_STR_METADATA(pb, "project_name", str);
3276 }
3277 return 0;
3278}
3279
3280static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
3281 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
3282 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
3283 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
3284 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
3285 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
3286 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
3287 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
3288 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
3289 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
3290 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
3291 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
3292 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
3293 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
3294 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage },
3295 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
3296 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
3297 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
3298 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
3299 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
3300 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
3301 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
3302 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x42,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Generic Sound */
3303 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
3304 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
3305 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
3306 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
3307 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
3308 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5b,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* VBI - SMPTE 436M */
3309 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5c,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* VANC/VBI - SMPTE 436M */
3310 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
3311 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x64,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* DC Timed Text Descriptor */
3312 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6b,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), AudioChannelLabelSubDescriptor },
3313 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6c,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), SoundfieldGroupLabelSubDescriptor },
3314 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6d,0x00 }, mxf_read_mca_sub_descriptor, sizeof(MXFMCASubDescriptor), GroupOfSoundfieldGroupsLabelSubDescriptor },
3315 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x81,0x03 }, mxf_read_ffv1_sub_descriptor, sizeof(MXFFFV1SubDescriptor), FFV1SubDescriptor },
3316 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
3317 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
3318 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
3319 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
3320 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
3321 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
3322 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
3323 { { 0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x01,0x02,0x10,0x01,0x00,0x00,0x00 } }, /* KLV fill, skip */
3324};
3325
3326static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type, MXFPartition *partition)
3327{
3328 ctx->partition_score = partition_score(partition);
3329 switch (type){
3330 case MultipleDescriptor:
3331 case Descriptor:
3332 ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
3333 ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
3334 break;
3335 default:
3336 break;
3337 }
3338 return 0;
3339}
3340
3341static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
3342{
3343 AVIOContext *pb = mxf->fc->pb;
3344 uint64_t klv_end = avio_tell(pb) + klv->length;
3345 MXFMetadataSet *meta;
3346 void *ctx;
3347
3348 if (ctx_size) {
3349 meta = av_mallocz(ctx_size);
3350 if (!meta)
3351 return AVERROR(ENOMEM);
3352 ctx = meta;
3353 mxf_metadataset_init(meta, type, mxf->current_partition);
3354 } else {
3355 meta = NULL;
3356 ctx = mxf;
3357 }
3358 while (avio_tell(pb) + 4ULL < klv_end && !avio_feof(pb)) {
3359 int ret;
3360 int tag = avio_rb16(pb);
3361 int size = avio_rb16(pb); /* KLV specified by 0x53 */
3362 int64_t next = avio_tell(pb);
3363 UID uid = {0};
3364 if (next < 0 || next > INT64_MAX - size) {
3365 if (meta) {
3366 mxf_free_metadataset(&meta, type);
3367 }
3368 return next < 0 ? next : AVERROR_INVALIDDATA;
3369 }
3370 next += size;
3371
3372 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
3373 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
3374 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
3375 continue;
3376 }
3377 if (tag > 0x7FFF) { /* dynamic tag */
3378 int i;
3379 for (i = 0; i < mxf->local_tags_count; i++) {
3380 int local_tag = AV_RB16(mxf->local_tags+i*18);
3381 if (local_tag == tag) {
3382 memcpy(uid, mxf->local_tags+i*18+2, 16);
3383 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
3384 PRINT_KEY(mxf->fc, "uid", uid);
3385 }
3386 }
3387 }
3388 if (meta && tag == 0x3C0A) {
3389 avio_read(pb, meta->uid, 16);
3390 } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
3391 if (meta) {
3392 mxf_free_metadataset(&meta, type);
3393 }
3394 return ret;
3395 }
3396
3397 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
3398 * it extending past the end of the KLV though (zzuf5.mxf). */
3399 if (avio_tell(pb) > klv_end) {
3400 if (meta) {
3401 mxf_free_metadataset(&meta, type);
3402 }
3403
3404 av_log(mxf->fc, AV_LOG_ERROR,
3405 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
3406 tag, klv->offset);
3407 return AVERROR_INVALIDDATA;
3408 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
3409 avio_seek(pb, next, SEEK_SET);
3410 }
3411 return meta ? mxf_add_metadata_set(mxf, &meta, type) : 0;
3412}
3413
3414/**
3415 * Matches any partition pack key, in other words:
3416 * - HeaderPartition
3417 * - BodyPartition
3418 * - FooterPartition
3419 * @return non-zero if the key is a partition pack key, zero otherwise
3420 */
3421static int mxf_is_partition_pack_key(UID key)
3422{
3423 //NOTE: this is a little lax since it doesn't constraint key[14]
3424 return !memcmp(key, mxf_header_partition_pack_key, 13) &&
3425 key[13] >= 2 && key[13] <= 4;
3426}
3427
3428/**
3429 * Parses a metadata KLV
3430 * @return <0 on error, 0 otherwise
3431 */
3432static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
3433 int ctx_size, enum MXFMetadataSetType type)
3434{
3435 AVFormatContext *s = mxf->fc;
3436 int res;
3437 if (klv.key[5] == 0x53) {
3438 res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
3439 } else {
3440 uint64_t next = avio_tell(s->pb) + klv.length;
3441 res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
3442
3443 /* only seek forward, else this can loop for a long time */
3444 if (avio_tell(s->pb) > next) {
3445 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
3446 klv.offset);
3447 return AVERROR_INVALIDDATA;
3448 }
3449
3450 avio_seek(s->pb, next, SEEK_SET);
3451 }
3452 if (res < 0) {
3453 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
3454 return res;
3455 }
3456 return 0;
3457}
3458
3459/**
3460 * Seeks to the previous partition and parses it, if possible
3461 * @return <= 0 if we should stop parsing, > 0 if we should keep going
3462 */
3463static int mxf_seek_to_previous_partition(MXFContext *mxf)
3464{
3465 AVIOContext *pb = mxf->fc->pb;
3466 KLVPacket klv;
3467 int64_t current_partition_ofs;
3468 int ret;
3469
3470 if (!mxf->current_partition ||
3471 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
3472 return 0; /* we've parsed all partitions */
3473
3474 /* seek to previous partition */
3475 current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
3476 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
3477 mxf->current_partition = NULL;
3478
3479 av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
3480
3481 /* Make sure this is actually a PartitionPack, and if so parse it.
3482 * See deadlock2.mxf
3483 */
3484 if ((ret = klv_read_packet(mxf, &klv, pb)) < 0) {
3485 av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
3486 return ret;
3487 }
3488
3489 if (!mxf_is_partition_pack_key(klv.key)) {
3490 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
3491 return AVERROR_INVALIDDATA;
3492 }
3493
3494 /* We can't just check ofs >= current_partition_ofs because PreviousPartition
3495 * can point to just before the current partition, causing klv_read_packet()
3496 * to sync back up to it. See deadlock3.mxf
3497 */
3498 if (klv.offset >= current_partition_ofs) {
3499 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
3500 PRIx64 " indirectly points to itself\n", current_partition_ofs);
3501 return AVERROR_INVALIDDATA;
3502 }
3503
3504 if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
3505 return ret;
3506
3507 return 1;
3508}
3509
3510/**
3511 * Called when essence is encountered
3512 * @return <= 0 if we should stop parsing, > 0 if we should keep going
3513 */
3514static int mxf_parse_handle_essence(MXFContext *mxf)
3515{
3516 AVIOContext *pb = mxf->fc->pb;
3517 int64_t ret;
3518
3519 if (mxf->parsing_backward) {
3520 return mxf_seek_to_previous_partition(mxf);
3521 } else {
3522 if (!mxf->footer_partition) {
3523 av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
3524 return 0;
3525 }
3526
3527 av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
3528
3529 /* remember where we were so we don't end up seeking further back than this */
3530 mxf->last_forward_tell = avio_tell(pb);
3531
3532 if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
3533 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
3534 return -1;
3535 }
3536
3537 /* seek to FooterPartition and parse backward */
3538 if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
3539 av_log(mxf->fc, AV_LOG_ERROR,
3540 "failed to seek to FooterPartition @ 0x%" PRIx64
3541 " (%"PRId64") - partial file?\n",
3542 mxf->run_in + mxf->footer_partition, ret);
3543 return ret;
3544 }
3545
3546 mxf->current_partition = NULL;
3547 mxf->parsing_backward = 1;
3548 }
3549
3550 return 1;
3551}
3552
3553/**
3554 * Called when the next partition or EOF is encountered
3555 * @return <= 0 if we should stop parsing, > 0 if we should keep going
3556 */
3561
3562static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
3563{
3564 for (int i = 0; i < s->nb_streams; i++) {
3565 MXFTrack *track = s->streams[i]->priv_data;
3566 if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
3567 return track->wrapping;
3568 }
3569 return UnknownWrapped;
3570}
3571
3572/**
3573 * Figures out the proper offset and length of the essence container in each partition
3574 */
3575static void mxf_compute_essence_containers(AVFormatContext *s)
3576{
3577 MXFContext *mxf = s->priv_data;
3578 int x;
3579
3580 for (x = 0; x < mxf->partitions_count; x++) {
3581 MXFPartition *p = &mxf->partitions[x];
3582 MXFWrappingScheme wrapping;
3583
3584 if (!p->body_sid)
3585 continue; /* BodySID == 0 -> no essence */
3586
3587 /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
3588 * otherwise we point essence_offset at the key of the first essence KLV.
3589 */
3590
3591 wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
3592
3593 if (wrapping == ClipWrapped) {
3594 p->essence_offset = p->first_essence_klv.next_klv - p->first_essence_klv.length;
3595 p->essence_length = p->first_essence_klv.length;
3596 } else {
3597 p->essence_offset = p->first_essence_klv.offset;
3598
3599 /* essence container spans to the next partition */
3600 if (x < mxf->partitions_count - 1)
3601 p->essence_length = mxf->partitions[x+1].pack_ofs - mxf->run_in - p->essence_offset;
3602
3603 if (p->essence_length < 0) {
3604 /* next ThisPartition < essence_offset */
3605 p->essence_length = 0;
3606 av_log(mxf->fc, AV_LOG_ERROR,
3607 "partition %i: bad ThisPartition = %"PRIX64"\n",
3608 x+1, mxf->partitions[x+1].pack_ofs - mxf->run_in);
3609 }
3610 }
3611 }
3612}
3613
3614static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
3615{
3616 int i;
3617 for (i = 0; i < mxf->nb_index_tables; i++)
3618 if (mxf->index_tables[i].index_sid == index_sid)
3619 return &mxf->index_tables[i];
3620 return NULL;
3621}
3622
3623/**
3624 * Deal with the case where for some audio atoms EditUnitByteCount is
3625 * very small (2, 4..). In those cases we should read more than one
3626 * sample per call to mxf_read_packet().
3627 */
3628static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
3629{
3630 MXFTrack *track = st->priv_data;
3631 MXFIndexTable *t;
3632
3633 if (!track)
3634 return;
3635 track->edit_units_per_packet = 1;
3636 if (track->wrapping != ClipWrapped)
3637 return;
3638
3639 t = mxf_find_index_table(mxf, track->index_sid);
3640
3641 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
3642 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
3643 !is_pcm(st->codecpar->codec_id) ||
3644 !t ||
3645 t->nb_segments != 1 ||
3646 t->segments[0]->edit_unit_byte_count >= 32)
3647 return;
3648
3649 /* arbitrarily default to 48 kHz PAL audio frame size */
3650 /* TODO: We could compute this from the ratio between the audio
3651 * and video edit rates for 48 kHz NTSC we could use the
3652 * 1802-1802-1802-1802-1801 pattern. */
3653 track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
3654}
3655
3656/**
3657 * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
3658 */
3659static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
3660{
3661 MXFTrack *track = st->priv_data;
3662 MXFIndexTableSegment *segment = NULL;
3663 MXFPartition *p = NULL;
3664 int essence_partition_count = 0;
3665 int edit_unit_byte_count = 0;
3666 int i, ret;
3667 MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[IndexTableSegment];
3668
3669 if (!track || track->wrapping != ClipWrapped)
3670 return 0;
3671
3672 /* check if track already has an IndexTableSegment */
3673 for (i = 0; i < mg->metadata_sets_count; i++) {
3674 MXFIndexTableSegment *s = (MXFIndexTableSegment*)mg->metadata_sets[i];
3675 if (s->body_sid == track->body_sid)
3676 return 0;
3677 }
3678
3679 /* find the essence partition */
3680 for (i = 0; i < mxf->partitions_count; i++) {
3681 /* BodySID == 0 -> no essence */
3682 if (mxf->partitions[i].body_sid != track->body_sid)
3683 continue;
3684
3685 p = &mxf->partitions[i];
3686 essence_partition_count++;
3687 }
3688
3689 /* only handle files with a single essence partition */
3690 if (essence_partition_count != 1)
3691 return 0;
3692
3693 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && is_pcm(st->codecpar->codec_id)) {
3694 edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) *
3695 st->codecpar->ch_layout.nb_channels) >> 3;
3696 } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
3697 edit_unit_byte_count = p->first_essence_klv.length / st->duration;
3698 }
3699
3700 if (edit_unit_byte_count <= 0)
3701 return 0;
3702
3703 av_log(mxf->fc, AV_LOG_WARNING, "guessing index for stream %d using edit unit byte count %d\n", st->index, edit_unit_byte_count);
3704
3705 if (!(segment = av_mallocz(sizeof(*segment))))
3706 return AVERROR(ENOMEM);
3707
3708 if ((ret = mxf_add_metadata_set(mxf, (MXFMetadataSet**)&segment, IndexTableSegment)))
3709 return ret;
3710
3711 /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
3712 * using the same SID for index is forbidden in MXF. */
3713 if (!track->index_sid)
3714 track->index_sid = track->body_sid;
3715
3716 /* stream will be treated as small EditUnitByteCount */
3717 segment->edit_unit_byte_count = edit_unit_byte_count;
3718 segment->index_start_position = 0;
3719 segment->index_duration = st->duration;
3720 segment->index_edit_rate = av_inv_q(st->time_base);
3721 segment->index_sid = track->index_sid;
3722 segment->body_sid = p->body_sid;
3723 return 0;
3724}
3725
3726static void mxf_read_random_index_pack(AVFormatContext *s)
3727{
3728 MXFContext *mxf = s->priv_data;
3729 uint32_t length;
3730 int64_t file_size, max_rip_length, min_rip_length;
3731 KLVPacket klv;
3732
3733 if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
3734 return;
3735
3736 file_size = avio_size(s->pb);
3737
3738 /* S377m says to check the RIP length for "silly" values, without defining "silly".
3739 * The limit below assumes a file with nothing but partition packs and a RIP.
3740 * Before changing this, consider that a muxer may place each sample in its own partition.
3741 *
3742 * 105 is the size of the smallest possible PartitionPack
3743 * 12 is the size of each RIP entry
3744 * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3745 */
3746 max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3747 max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3748
3749 /* We're only interested in RIPs with at least two entries.. */
3750 min_rip_length = 16+1+24+4;
3751
3752 /* See S377m section 11 */
3753 avio_seek(s->pb, file_size - 4, SEEK_SET);
3754 length = avio_rb32(s->pb);
3755
3756 if (length < min_rip_length || length > max_rip_length)
3757 goto end;
3758 avio_seek(s->pb, file_size - length, SEEK_SET);
3759 if (klv_read_packet(mxf, &klv, s->pb) < 0 ||
3760 !IS_KLV_KEY(klv.key, ff_mxf_random_index_pack_key))
3761 goto end;
3762 if (klv.next_klv != file_size || klv.length <= 4 || (klv.length - 4) % 12) {
3763 av_log(s, AV_LOG_WARNING, "Invalid RIP KLV length\n");
3764 goto end;
3765 }
3766
3767 avio_skip(s->pb, klv.length - 12);
3768 mxf->footer_partition = avio_rb64(s->pb);
3769
3770 /* sanity check */
3771 if (mxf->run_in + mxf->footer_partition >= file_size) {
3772 av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3773 mxf->footer_partition = 0;
3774 }
3775
3776end:
3777 avio_seek(s->pb, mxf->run_in, SEEK_SET);
3778}
3779
3780static int mxf_read_header(AVFormatContext *s)
3781{
3782 MXFContext *mxf = s->priv_data;
3783 KLVPacket klv;
3784 int64_t essence_offset = 0;
3785 int ret;
3786 int64_t run_in;
3787
3788 mxf->last_forward_tell = INT64_MAX;
3789
3790 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
3791 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3792 return AVERROR_INVALIDDATA;
3793 }
3794 avio_seek(s->pb, -14, SEEK_CUR);
3795 mxf->fc = s;
3796 run_in = avio_tell(s->pb);
3797 if (run_in < 0 || run_in > RUN_IN_MAX)
3798 return AVERROR_INVALIDDATA;
3799 mxf->run_in = run_in;
3800
3801 mxf_read_random_index_pack(s);
3802
3803 while (!avio_feof(s->pb)) {
3804 size_t x;
3805
3806 ret = klv_read_packet(mxf, &klv, s->pb);
3807 if (ret < 0 || IS_KLV_KEY(klv.key, ff_mxf_random_index_pack_key)) {
3808 if (ret >= 0 && avio_size(s->pb) > klv.next_klv)
3809 av_log(s, AV_LOG_WARNING, "data after the RandomIndexPack, assuming end of file\n");
3810 /* EOF - seek to previous partition or stop */
3811 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3812 break;
3813 else
3814 continue;
3815 }
3816
3817 PRINT_KEY(s, "read header", klv.key);
3818 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3819 if (mxf_match_uid(klv.key, mxf_encrypted_triplet_key, sizeof(mxf_encrypted_triplet_key)) ||
3820 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3821 IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3822 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
3823 IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
3824 IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
3825
3826 if (!mxf->current_partition) {
3827 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3828 return AVERROR_INVALIDDATA;
3829 }
3830
3831 if (!mxf->current_partition->first_essence_klv.offset)
3832 mxf->current_partition->first_essence_klv = klv;
3833
3834 if (!essence_offset)
3835 essence_offset = klv.offset;
3836
3837 /* seek to footer, previous partition or stop */
3838 if (mxf_parse_handle_essence(mxf) <= 0)
3839 break;
3840 continue;
3841 } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3842 /* next partition pack - keep going, seek to previous partition or stop */
3843 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3844 break;
3845 else if (mxf->parsing_backward)
3846 continue;
3847 /* we're still parsing forward. proceed to parsing this partition pack */
3848 }
3849
3850 for (x = 0; x < FF_ARRAY_ELEMS(mxf_metadata_read_table); x++) {
3851 const MXFMetadataReadTableEntry *metadata = &mxf_metadata_read_table[x];
3852 if (IS_KLV_KEY(klv.key, metadata->key)) {
3853 if (metadata->read) {
3854 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3855 return ret;
3856 } else {
3857 avio_skip(s->pb, klv.length);
3858 }
3859 break;
3860 }
3861 }
3862 if (x >= FF_ARRAY_ELEMS(mxf_metadata_read_table)) {
3863 av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3864 UID_ARG(klv.key));
3865 avio_skip(s->pb, klv.length);
3866 }
3867 }
3868 /* FIXME avoid seek */
3869 if (!essence_offset) {
3870 av_log(s, AV_LOG_ERROR, "no essence\n");
3871 return AVERROR_INVALIDDATA;
3872 }
3873 avio_seek(s->pb, essence_offset, SEEK_SET);
3874
3875 /* we need to do this before computing the index tables
3876 * to be able to fill in zero IndexDurations with st->duration */
3877 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3878 return ret;
3879
3880 for (int i = 0; i < s->nb_streams; i++)
3881 mxf_handle_missing_index_segment(mxf, s->streams[i]);
3882
3883 if ((ret = mxf_compute_index_tables(mxf)) < 0)
3884 return ret;
3885
3886 if (mxf->nb_index_tables > 1) {
3887 /* TODO: look up which IndexSID to use via EssenceContainerData */
3888 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3889 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3890 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3891 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3892 return AVERROR_INVALIDDATA;
3893 }
3894
3895 mxf_compute_essence_containers(s);
3896
3897 for (int i = 0; i < s->nb_streams; i++)
3898 mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
3899
3900 return 0;
3901}
3902
3903/* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3904static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3905{
3906 int64_t a, b, m, offset;
3907 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3908
3909 if (!t || track->original_duration <= 0)
3910 return -1;
3911
3912 a = -1;
3913 b = track->original_duration;
3914 while (b - 1 > a) {
3915 m = (a + (uint64_t)b) >> 1;
3916 if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3917 return -1;
3918 if (offset < current_offset)
3919 a = m;
3920 else
3921 b = m;
3922 }
3923
3924 *edit_unit_out = b;
3925
3926 return 0;
3927}
3928
3929static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st,
3930 int64_t edit_unit)
3931{
3932 MXFTrack *track = st->priv_data;
3933 AVRational time_base = av_inv_q(track->edit_rate);
3934 AVRational sample_rate = av_inv_q(st->time_base);
3935
3936 // For non-audio sample_count equals current edit unit
3937 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
3938 return edit_unit;
3939
3940 if ((sample_rate.num / sample_rate.den) == 48000) {
3941 return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3942 } else {
3943 int64_t remainder = (sample_rate.num * (int64_t) time_base.num) %
3944 ( time_base.den * (int64_t)sample_rate.den);
3945 if (remainder)
3946 av_log(mxf->fc, AV_LOG_WARNING,
3947 "seeking detected on stream #%d with time base (%d/%d) and "
3948 "sample rate (%d/%d), audio pts won't be accurate.\n",
3949 st->index, time_base.num, time_base.den,
3950 sample_rate.num, sample_rate.den);
3951 return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3952 }
3953}
3954
3955/**
3956 * Make sure track->sample_count is correct based on what offset we're currently at.
3957 * Also determine the next edit unit (or packet) offset.
3958 * @return next_ofs if OK, <0 on error
3959 */
3960static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3961{
3962 int64_t next_ofs = -1;
3963 MXFTrack *track = st->priv_data;
3964 int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3965 int64_t new_edit_unit;
3966 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3967
3968 if (!t || track->wrapping == UnknownWrapped || edit_unit > INT64_MAX - track->edit_units_per_packet)
3969 return -1;
3970
3971 if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3972 (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3973 av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3974 return -1;
3975 }
3976
3977 /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3978 if (next_ofs > current_offset)
3979 return next_ofs;
3980
3981 if (!resync) {
3982 av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3983 return -1;
3984 }
3985
3986 if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3987 av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3988 return -1;
3989 }
3990
3991 new_edit_unit--;
3992 track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3993 av_log(mxf->fc, AV_LOG_WARNING, "edit unit sync lost on stream %d, jumping from %"PRId64" to %"PRId64"\n", st->index, edit_unit, new_edit_unit);
3994
3995 return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3996}
3997
3998static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3999 AVPacket *pkt)
4000{
4001 AVStream *st = mxf->fc->streams[pkt->stream_index];
4002 MXFTrack *track = st->priv_data;
4003 int64_t bits_per_sample = par->bits_per_coded_sample;
4004
4005 if (!bits_per_sample)
4006 bits_per_sample = av_get_bits_per_sample(par->codec_id);
4007
4008 pkt->pts = track->sample_count;
4009
4010 if (par->ch_layout.nb_channels <= 0 ||
4011 bits_per_sample <= 0 ||
4012 par->ch_layout.nb_channels * (int64_t)bits_per_sample < 8)
4013 track->sample_count = mxf_compute_sample_count(mxf, st, av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate)) + 1);
4014 else
4015 track->sample_count += pkt->size / (par->ch_layout.nb_channels * (int64_t)bits_per_sample / 8);
4016
4017 return 0;
4018}
4019
4020static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
4021{
4022 AVCodecParameters *par = st->codecpar;
4023 MXFTrack *track = st->priv_data;
4024
4025 if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
4026 /* see if we have an index table to derive timestamps from */
4027 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
4028
4029 if (t && track->sample_count < t->nb_ptses) {
4030 pkt->dts = track->sample_count + t->first_dts;
4031 pkt->pts = t->ptses[track->sample_count];
4032 } else if (track->intra_only) {
4033 /* intra-only -> PTS = EditUnit.
4034 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
4035 pkt->pts = track->sample_count;
4036 }
4037 track->sample_count++;
4038 } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
4039 int ret = mxf_set_audio_pts(mxf, par, pkt);
4040 if (ret < 0)
4041 return ret;
4042 } else if (track) {
4043 pkt->dts = pkt->pts = track->sample_count;
4044 pkt->duration = 1;
4045 track->sample_count++;
4046 }
4047 return 0;
4048}
4049
4050static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
4051{
4052 KLVPacket klv;
4053 MXFContext *mxf = s->priv_data;
4054 int ret;
4055
4056 while (1) {
4057 int64_t max_data_size;
4058 int64_t pos = avio_tell(s->pb);
4059
4060 if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
4061 mxf->current_klv_data = (KLVPacket){{0}};
4062 ret = klv_read_packet(mxf, &klv, s->pb);
4063 if (ret < 0)
4064 break;
4065 // klv.key[0..3] == mxf_klv_key from here forward
4066 max_data_size = klv.length;
4067 pos = klv.next_klv - klv.length;
4068 PRINT_KEY(s, "read packet", klv.key);
4069 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
4070 if (mxf_match_uid(klv.key, mxf_encrypted_triplet_key, sizeof(mxf_encrypted_triplet_key))) {
4071 ret = mxf_decrypt_triplet(s, pkt, &klv);
4072 if (ret < 0) {
4073 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
4074 return ret;
4075 }
4076 return 0;
4077 }
4078 } else {
4079 klv = mxf->current_klv_data;
4080 max_data_size = klv.next_klv - pos;
4081 }
4082 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
4083 IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
4084 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
4085 int body_sid = find_body_sid_by_absolute_offset(mxf, klv.offset);
4086 int index = mxf_get_stream_index(s, &klv, body_sid);
4087 int64_t next_ofs;
4088 AVStream *st;
4089 MXFTrack *track;
4090
4091 if (index < 0) {
4092 av_log(s, AV_LOG_ERROR,
4093 "error getting stream index %"PRIu32"\n",
4094 AV_RB32(klv.key + 12));
4095 goto skip;
4096 }
4097
4098 st = s->streams[index];
4099 track = st->priv_data;
4100
4101 if (s->streams[index]->discard == AVDISCARD_ALL)
4102 goto skip;
4103
4104 next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
4105
4106 if (track->wrapping != FrameWrapped) {
4107 int64_t size;
4108
4109 if (next_ofs <= 0) {
4110 // If we have no way to packetize the data, then return it in chunks...
4111 if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
4112 ffstream(st)->need_parsing = AVSTREAM_PARSE_FULL;
4113 avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
4114 }
4115 size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
4116 } else {
4117 if ((size = next_ofs - pos) <= 0) {
4118 av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
4119 mxf->current_klv_data = (KLVPacket){{0}};
4120 return AVERROR_INVALIDDATA;
4121 }
4122 // We must not overread, because the next edit unit might be in another KLV
4123 if (size > max_data_size)
4124 size = max_data_size;
4125 }
4126
4127 mxf->current_klv_data = klv;
4128 klv.offset = pos;
4129 klv.length = size;
4130 klv.next_klv = klv.offset + klv.length;
4131 }
4132
4133 /* check for 8 channels AES3 element */
4134 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
4135 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
4136 pkt, klv.length);
4137 if (ret < 0) {
4138 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
4139 mxf->current_klv_data = (KLVPacket){{0}};
4140 return ret;
4141 }
4142 } else if (mxf->eia608_extract &&
4143 s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
4144 ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
4145 if (ret < 0) {
4146 mxf->current_klv_data = (KLVPacket){{0}};
4147 return ret;
4148 }
4149 } else {
4150 ret = av_get_packet(s->pb, pkt, klv.length);
4151 if (ret < 0) {
4152 mxf->current_klv_data = (KLVPacket){{0}};
4153 return ret;
4154 }
4155 }
4156 pkt->stream_index = index;
4157 pkt->pos = klv.offset;
4158
4159 ret = mxf_set_pts(mxf, st, pkt);
4160 if (ret < 0) {
4161 mxf->current_klv_data = (KLVPacket){{0}};
4162 return ret;
4163 }
4164
4165 /* seek for truncated packets */
4166 avio_seek(s->pb, klv.next_klv, SEEK_SET);
4167
4168 return 0;
4169 } else {
4170 skip:
4171 avio_skip(s->pb, max_data_size);
4172 mxf->current_klv_data = (KLVPacket){{0}};
4173 }
4174 }
4175 return avio_feof(s->pb) ? AVERROR_EOF : ret;
4176}
4177
4178static int mxf_read_close(AVFormatContext *s)
4179{
4180 MXFContext *mxf = s->priv_data;
4181
4182 av_freep(&mxf->packages_refs);
4183 av_freep(&mxf->essence_container_data_refs);
4184
4185 for (int i = 0; i < s->nb_streams; i++)
4186 s->streams[i]->priv_data = NULL;
4187
4188 for (int type = 0; type < FF_ARRAY_ELEMS(mxf->metadata_set_groups); type++) {
4189 MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[type];
4190 for (int i = 0; i < mg->metadata_sets_count; i++)
4191 mxf_free_metadataset(mg->metadata_sets + i, type);
4192 mg->metadata_sets_count = 0;
4193 av_freep(&mg->metadata_sets);
4194 }
4195 av_freep(&mxf->partitions);
4196 av_freep(&mxf->aesc);
4197 av_freep(&mxf->local_tags);
4198
4199 if (mxf->index_tables) {
4200 for (int i = 0; i < mxf->nb_index_tables; i++) {
4201 av_freep(&mxf->index_tables[i].segments);
4202 av_freep(&mxf->index_tables[i].ptses);
4203 av_freep(&mxf->index_tables[i].fake_index);
4204 av_freep(&mxf->index_tables[i].offsets);
4205 }
4206 }
4207 av_freep(&mxf->index_tables);
4208
4209 return 0;
4210}
4211
4212static int mxf_probe(const AVProbeData *p) {
4213 const uint8_t *bufp = p->buf;
4214 const uint8_t *end = p->buf + FFMIN(p->buf_size, RUN_IN_MAX + 1 + sizeof(mxf_header_partition_pack_key));
4215
4216 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
4217 return 0;
4218
4219 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
4220 end -= sizeof(mxf_header_partition_pack_key);
4221
4222 for (; bufp < end;) {
4223 if (!((bufp[13] - 1) & 0xF2)){
4224 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
4225 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
4226 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
4227 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
4228 return bufp == p->buf ? AVPROBE_SCORE_MAX : AVPROBE_SCORE_MAX - 1;
4229 bufp ++;
4230 } else
4231 bufp += 10;
4232 }
4233
4234 return 0;
4235}
4236
4237/* rudimentary byte seek */
4238/* XXX: use MXF Index */
4239static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
4240{
4241 AVStream *st = s->streams[stream_index];
4242 int64_t seconds;
4243 MXFContext* mxf = s->priv_data;
4244 int64_t seekpos;
4245 int ret;
4246 MXFIndexTable *t;
4247 MXFTrack *source_track = st->priv_data;
4248
4249 if (!source_track)
4250 return 0;
4251
4252 /* if audio then truncate sample_time to EditRate */
4253 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
4254 sample_time = av_rescale_q(sample_time, st->time_base,
4255 av_inv_q(source_track->edit_rate));
4256
4257 if (mxf->nb_index_tables <= 0) {
4258 if (!s->bit_rate)
4259 return AVERROR_INVALIDDATA;
4260 if (sample_time < 0)
4261 sample_time = 0;
4262 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
4263
4264 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
4265 if (seekpos < 0)
4266 return seekpos;
4267
4268 avpriv_update_cur_dts(s, st, sample_time);
4269 mxf->current_klv_data = (KLVPacket){{0}};
4270 } else {
4271 MXFPartition *partition;
4272
4273 t = &mxf->index_tables[0];
4274 if (t->index_sid != source_track->index_sid) {
4275 int i;
4276 /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
4277 for (i = 0; i < s->nb_streams; i++) {
4278 MXFTrack *new_source_track = s->streams[i]->priv_data;
4279 if (new_source_track && new_source_track->index_sid == t->index_sid) {
4280 sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
4281 source_track = new_source_track;
4282 st = s->streams[i];
4283 break;
4284 }
4285 }
4286 if (i == s->nb_streams)
4287 return AVERROR_INVALIDDATA;
4288 }
4289
4290 /* clamp above zero, else ff_index_search_timestamp() returns negative
4291 * this also means we allow seeking before the start */
4292 sample_time = FFMAX(sample_time, 0);
4293
4294 if (t->fake_index) {
4295 /* The first frames may not be keyframes in presentation order, so
4296 * we have to advance the target to be able to find the first
4297 * keyframe backwards... */
4298 if (!(flags & AVSEEK_FLAG_ANY) &&
4299 (flags & AVSEEK_FLAG_BACKWARD) &&
4300 t->ptses[0] != AV_NOPTS_VALUE &&
4301 sample_time < t->ptses[0] &&
4302 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
4303 sample_time = t->ptses[0];
4304
4305 /* behave as if we have a proper index */
4306 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
4307 return sample_time;
4308 /* get the stored order index from the display order index */
4309 sample_time += t->offsets[sample_time];
4310 } else {
4311 /* no IndexEntryArray (one or more CBR segments)
4312 * make sure we don't seek past the end */
4313 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
4314 }
4315
4316 if (source_track->wrapping == UnknownWrapped)
4317 av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
4318
4319 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
4320 return ret;
4321
4322 avpriv_update_cur_dts(s, st, sample_time);
4323 if (source_track->wrapping == ClipWrapped) {
4324 KLVPacket klv = partition->first_essence_klv;
4325 if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
4326 av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
4327 return AVERROR_INVALIDDATA;
4328 }
4329 mxf->current_klv_data = klv;
4330 } else {
4331 mxf->current_klv_data = (KLVPacket){{0}};
4332 }
4333 avio_seek(s->pb, seekpos, SEEK_SET);
4334 }
4335
4336 // Update all tracks sample count
4337 for (int i = 0; i < s->nb_streams; i++) {
4338 AVStream *cur_st = s->streams[i];
4339 MXFTrack *cur_track = cur_st->priv_data;
4340 if (cur_track) {
4341 int64_t track_edit_unit = sample_time;
4342 if (st != cur_st)
4343 mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
4344 cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
4345 }
4346 }
4347 return 0;
4348}
4349
4350static const AVOption options[] = {
4351 { "eia608_extract", "extract eia 608 captions from s436m track",
4352 offsetof(MXFContext, eia608_extract), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
4353 AV_OPT_FLAG_DECODING_PARAM },
4354 { NULL },
4355};
4356
4357static const AVClass demuxer_class = {
4358 .class_name = "mxf",
4359 .item_name = av_default_item_name,
4360 .option = options,
4361 .version = LIBAVUTIL_VERSION_INT,
4362 .category = AV_CLASS_CATEGORY_DEMUXER,
4363};
4364
4365const FFInputFormat ff_mxf_demuxer = {
4366 .p.name = "mxf",
4367 .p.long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
4368 .p.flags = AVFMT_SEEK_TO_PTS | AVFMT_NOGENSEARCH,
4369 .p.priv_class = &demuxer_class,
4370 .priv_data_size = sizeof(MXFContext),
4371 .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,
4372 .read_probe = mxf_probe,
4373 .read_header = mxf_read_header,
4374 .read_packet = mxf_read_packet,
4375 .read_close = mxf_read_close,
4376 .read_seek = mxf_read_seek,
4377};
val
static double val(void *priv, double ch)
Definition aeval.c:77
ff_mxf_demuxer
const FFInputFormat ff_mxf_demuxer
Definition mxfdec.c:4365
demuxer_class
static const AVClass demuxer_class
Definition apngdec.c:418
set_language
static void set_language(AVFormatContext *s, const char *rfc1766, AVDictionary **met)
Definition asfdec_o.c:687
int32_t
int32_t
Definition audioconvert.c:56
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition avassert.h:42
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition avformat.c:834
avformat.h
Main libavformat public API header.
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition avformat.h:628
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition avformat.h:483
AVFMT_NOGENSEARCH
#define AVFMT_NOGENSEARCH
Format does not allow to fall back on generic search.
Definition avformat.h:505
AVSEEK_FLAG_ANY
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition avformat.h:2618
av_get_packet
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition utils.c:98
AVFMT_SEEK_TO_PTS
#define AVFMT_SEEK_TO_PTS
Seeking is based on PTS.
Definition avformat.h:520
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
seek backward
Definition avformat.h:2616
AVSTREAM_PARSE_TIMESTAMPS
@ AVSTREAM_PARSE_TIMESTAMPS
full parsing and interpolation of timestamps for frames not starting on a packet boundary
Definition avformat.h:613
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition avformat.h:612
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition avformat.h:611
avio_get_str16be
int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen)
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition aviobuf.c:236
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition avio.h:41
avio_rb64
uint64_t avio_rb64(AVIOContext *s)
Definition aviobuf.c:911
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition aviobuf.c:326
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition aviobuf.c:749
avio_get_str16le
int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a UTF-16 string from pb and convert it to UTF-8.
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition aviobuf.c:349
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition avio.h:494
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition aviobuf.c:321
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition aviobuf.c:615
avio_get_str
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
Definition aviobuf.c:869
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition aviobuf.c:764
avio_r8
int avio_r8(AVIOContext *s)
Definition aviobuf.c:606
avio_internal.h
ffio_read_size
int ffio_read_size(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition aviobuf.c:665
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition avio_read_callback.c:42
ff_convert_lang_to
const char * ff_convert_lang_to(const char *lang, enum AVLangCodespace target_codespace)
Convert a language code to a target codespace.
Definition avlanguage.c:741
AV_LANG_ISO639_2_BIBL
@ AV_LANG_ISO639_2_BIBL
Definition avlanguage.h:28
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition avstring.c:115
skip
static void BS_FUNC skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition bitstream_template.h:383
read
static uint32_t BS_FUNC read(BSCTX *bc, unsigned int n)
Return n bits from the buffer, n has to be in the 0-32 range.
Definition bitstream_template.h:239
metadata
static int FUNC metadata(CodedBitstreamContext *ctx, RWContext *rw, APVRawMetadata *current)
Definition cbs_apv_syntax_template.c:497
flags
#define flags(name, subs,...)
Definition cbs_h264.c:74
i
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
s
#define s(width, name)
Definition cbs_vp9.c:198
read_probe
static int read_probe(const AVProbeData *p)
Definition cdg.c:30
channel_layout.h
Public libavutil channel layout APIs header.
av_sat_sub64
#define av_sat_sub64
Definition common.h:142
av_sat_add64
#define av_sat_add64
Definition common.h:139
av_clip
#define av_clip
Definition common.h:100
NULL
#define NULL
Definition coverity.c:32
int64_t
long long int64_t
Definition coverity.c:34
defs.h
Misc types and constants that do not belong anywhere else.
AV_PROFILE_JPEG2000_DCINEMA_2K
#define AV_PROFILE_JPEG2000_DCINEMA_2K
Definition defs.h:151
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition defs.h:51
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition defs.h:214
AV_FIELD_BB
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
Definition defs.h:215
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition defs.h:213
AV_FIELD_BT
@ AV_FIELD_BT
Bottom coded first, top displayed first.
Definition defs.h:217
AV_FIELD_TB
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition defs.h:216
AV_PROFILE_JPEG2000_DCINEMA_4K
#define AV_PROFILE_JPEG2000_DCINEMA_4K
Definition defs.h:152
AVAudioServiceType
AVAudioServiceType
Definition defs.h:235
AV_AUDIO_SERVICE_TYPE_MAIN
@ AV_AUDIO_SERVICE_TYPE_MAIN
Definition defs.h:236
AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
@ AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
Definition defs.h:239
AV_AUDIO_SERVICE_TYPE_NB
@ AV_AUDIO_SERVICE_TYPE_NB
Not part of ABI.
Definition defs.h:245
AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
@ AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
Definition defs.h:238
FF_INFMT_FLAG_INIT_CLEANUP
#define FF_INFMT_FLAG_INIT_CLEANUP
For an FFInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition demux.h:35
ff_index_search_timestamp
int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries, int64_t wanted_timestamp, int flags)
Internal version of av_index_search_timestamp.
Definition seek.c:132
ff_generate_avci_extradata
int ff_generate_avci_extradata(AVStream *st)
Generate standard extradata for AVC-Intra based on width/height and field order.
Definition demux_utils.c:205
avpriv_update_cur_dts
void avpriv_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
Update cur_dts of all streams based on the given timestamp and AVStream.
Definition seek.c:37
pkt
static AVPacket * pkt
Definition demux_decode.c:55
value
double value
Definition eval.c:102
key
const char * key
Definition ffmpeg_mux_init.c:2985
read_header
static int read_header(FFV1Context *f, RangeCoder *c)
Definition ffv1dec.c:578
sample
#define sample
Definition flacdsp_template.c:44
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
Definition opt.h:355
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition opt.h:326
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition utils.c:556
avcodec_get_type
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
Get the type of the given codec.
Definition codec_desc.c:3916
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition utils.c:421
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition codec_id.h:47
AV_CODEC_ID_DIRAC
@ AV_CODEC_ID_DIRAC
Definition codec_id.h:166
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition codec_id.h:343
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition codec_id.h:63
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition codec_id.h:330
AV_CODEC_ID_TTML
@ AV_CODEC_ID_TTML
Definition codec_id.h:590
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition codec_id.h:77
AV_CODEC_ID_CFHD
@ AV_CODEC_ID_CFHD
Definition codec_id.h:262
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition codec_id.h:48
AV_CODEC_ID_JPEG2000
@ AV_CODEC_ID_JPEG2000
Definition codec_id.h:138
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition codec_id.h:331
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition codec_id.h:342
AV_CODEC_ID_PCM_S24DAUD
@ AV_CODEC_ID_PCM_S24DAUD
Definition codec_id.h:346
AV_CODEC_ID_FFV1
@ AV_CODEC_ID_FFV1
Definition codec_id.h:83
AV_CODEC_ID_PCM_S32LE
@ AV_CODEC_ID_PCM_S32LE
Definition codec_id.h:338
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition codec_id.h:120
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition codec_id.h:337
AV_CODEC_ID_EIA_608
@ AV_CODEC_ID_EIA_608
Definition codec_id.h:576
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition codec_id.h:453
AV_CODEC_ID_HQX
@ AV_CODEC_ID_HQX
Definition codec_id.h:235
AV_CODEC_ID_DVVIDEO
@ AV_CODEC_ID_DVVIDEO
Definition codec_id.h:74
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition codec_id.h:223
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition codec_id.h:455
AV_CODEC_ID_PRORES
@ AV_CODEC_ID_PRORES
Definition codec_id.h:198
AV_CODEC_ID_SMPTE_436M_ANC
@ AV_CODEC_ID_SMPTE_436M_ANC
Definition codec_id.h:610
AV_CODEC_ID_TIFF
@ AV_CODEC_ID_TIFF
Definition codec_id.h:146
AV_CODEC_ID_PCM_S32BE
@ AV_CODEC_ID_PCM_S32BE
Definition codec_id.h:339
AV_CODEC_ID_DNXHD
@ AV_CODEC_ID_DNXHD
Definition codec_id.h:149
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition codec_id.h:52
AV_CODEC_ID_HQ_HQA
@ AV_CODEC_ID_HQ_HQA
Definition codec_id.h:237
AV_CODEC_ID_DNXUC
@ AV_CODEC_ID_DNXUC
Definition codec_id.h:320
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
Definition defs.h:40
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition defs.h:232
av_packet_side_data_new
AVPacketSideData * av_packet_side_data_new(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, size_t size, int flags)
Allocate a new packet side data.
Definition packet.c:620
av_packet_side_data_add
AVPacketSideData * av_packet_side_data_add(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, void *data, size_t size, int flags)
Wrap existing data as packet side data.
Definition packet.c:613
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition packet.h:219
AV_PKT_DATA_AUDIO_SERVICE_TYPE
@ AV_PKT_DATA_AUDIO_SERVICE_TYPE
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.
Definition packet.h:117
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition packet.h:232
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition packet.c:113
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
av_aes_alloc
struct AVAES * av_aes_alloc(void)
Allocate an AVAES context.
Definition aes.c:37
av_aes_init
int av_aes_init(AVAES *a, const uint8_t *key, int key_bits, int decrypt)
Initialize an AVAES context.
Definition aes.c:231
av_aes_crypt
void av_aes_crypt(AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt)
Encrypt or decrypt a buffer using a previously initialized context.
Definition aes.c:171
av_channel_layout_retype
int av_channel_layout_retype(AVChannelLayout *channel_layout, enum AVChannelOrder order, int flags)
Change the AVChannelOrder of a channel layout.
Definition channel_layout.c:887
AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL
#define AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL
The specified retype target order is ignored and the simplest possible (canonical) order is used for ...
Definition channel_layout.h:721
av_channel_layout_custom_init
int av_channel_layout_custom_init(AVChannelLayout *channel_layout, int nb_channels)
Initialize a custom channel layout with the specified number of channels.
Definition channel_layout.c:233
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition channel_layout.c:443
AVChannel
AVChannel
Definition channel_layout.h:47
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition channel_layout.h:119
AV_CHAN_LOW_FREQUENCY
@ AV_CHAN_LOW_FREQUENCY
Definition channel_layout.h:53
AV_CHAN_BACK_RIGHT
@ AV_CHAN_BACK_RIGHT
Definition channel_layout.h:55
AV_CHAN_TOP_SURROUND_RIGHT
@ AV_CHAN_TOP_SURROUND_RIGHT
-110 degrees, Rvs, TpRS
Definition channel_layout.h:85
AV_CHAN_FRONT_RIGHT_OF_CENTER
@ AV_CHAN_FRONT_RIGHT_OF_CENTER
Definition channel_layout.h:57
AV_CHAN_FRONT_LEFT
@ AV_CHAN_FRONT_LEFT
Definition channel_layout.h:50
AV_CHAN_SIDE_SURROUND_RIGHT
@ AV_CHAN_SIDE_SURROUND_RIGHT
-90 degrees, Rss, SiR
Definition channel_layout.h:83
AV_CHAN_TOP_BACK_LEFT
@ AV_CHAN_TOP_BACK_LEFT
Definition channel_layout.h:65
AV_CHAN_TOP_FRONT_RIGHT
@ AV_CHAN_TOP_FRONT_RIGHT
Definition channel_layout.h:64
AV_CHAN_FRONT_RIGHT
@ AV_CHAN_FRONT_RIGHT
Definition channel_layout.h:51
AV_CHAN_BACK_CENTER
@ AV_CHAN_BACK_CENTER
Definition channel_layout.h:58
AV_CHAN_TOP_SIDE_RIGHT
@ AV_CHAN_TOP_SIDE_RIGHT
Definition channel_layout.h:78
AV_CHAN_FRONT_CENTER
@ AV_CHAN_FRONT_CENTER
Definition channel_layout.h:52
AV_CHAN_TOP_SURROUND_LEFT
@ AV_CHAN_TOP_SURROUND_LEFT
+110 degrees, Lvs, TpLS
Definition channel_layout.h:84
AV_CHAN_SIDE_RIGHT
@ AV_CHAN_SIDE_RIGHT
Definition channel_layout.h:60
AV_CHAN_SIDE_SURROUND_LEFT
@ AV_CHAN_SIDE_SURROUND_LEFT
+90 degrees, Lss, SiL
Definition channel_layout.h:82
AV_CHAN_FRONT_LEFT_OF_CENTER
@ AV_CHAN_FRONT_LEFT_OF_CENTER
Definition channel_layout.h:56
AV_CHAN_LOW_FREQUENCY_2
@ AV_CHAN_LOW_FREQUENCY_2
Definition channel_layout.h:76
AV_CHAN_TOP_BACK_CENTER
@ AV_CHAN_TOP_BACK_CENTER
Definition channel_layout.h:66
AV_CHAN_BACK_LEFT
@ AV_CHAN_BACK_LEFT
Definition channel_layout.h:54
AV_CHAN_SIDE_LEFT
@ AV_CHAN_SIDE_LEFT
Definition channel_layout.h:59
AV_CHAN_BOTTOM_FRONT_CENTER
@ AV_CHAN_BOTTOM_FRONT_CENTER
Definition channel_layout.h:79
AV_CHAN_TOP_FRONT_LEFT
@ AV_CHAN_TOP_FRONT_LEFT
Definition channel_layout.h:62
AV_CHAN_TOP_BACK_RIGHT
@ AV_CHAN_TOP_BACK_RIGHT
Definition channel_layout.h:67
AV_CHAN_BOTTOM_FRONT_RIGHT
@ AV_CHAN_BOTTOM_FRONT_RIGHT
Definition channel_layout.h:81
AV_CHAN_STEREO_RIGHT
@ AV_CHAN_STEREO_RIGHT
See above.
Definition channel_layout.h:71
AV_CHAN_TOP_SIDE_LEFT
@ AV_CHAN_TOP_SIDE_LEFT
Definition channel_layout.h:77
AV_CHAN_BOTTOM_FRONT_LEFT
@ AV_CHAN_BOTTOM_FRONT_LEFT
Definition channel_layout.h:80
AV_CHAN_TOP_CENTER
@ AV_CHAN_TOP_CENTER
Definition channel_layout.h:61
AV_CHAN_STEREO_LEFT
@ AV_CHAN_STEREO_LEFT
Stereo downmix.
Definition channel_layout.h:69
AV_CHAN_TOP_FRONT_CENTER
@ AV_CHAN_TOP_FRONT_CENTER
Definition channel_layout.h:63
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition dict.c:86
AV_DICT_DONT_STRDUP_KEY
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that's been allocated with av_malloc() or another memory allocation function.
Definition dict.h:77
av_dict_set_int
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set() that converts the value to a string and stores it.
Definition dict.c:177
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition error.h:64
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition error.h:61
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition error.h:57
AVERROR
#define AVERROR(e)
Definition error.h:45
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition log.h:236
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition log.h:231
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition log.h:216
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition log.h:226
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition log.h:221
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition log.c:241
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition rational.c:80
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition rational.h:71
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition rational.h:159
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
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition mathematics.c:142
av_dynarray_add_nofree
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition mem.c:313
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition mem.c:217
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition utils.c:28
AVMediaType
AVMediaType
Definition avutil.h:198
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition avutil.h:201
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition avutil.h:203
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition avutil.h:200
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition avutil.h:202
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition avutil.h:247
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition version.h:85
index
int index
Definition gxfenc.c:90
a
int a
Definition h264pred_template.c:416
type
cl_device_type type
Definition hwcontext_opencl.c:213
b
#define b
Definition input.c:43
AV_RN32
#define AV_RN32(p)
Definition intreadwrite.h:360
AV_RB32
#define AV_RB32(p)
Definition intreadwrite.h:412
AV_RN16
#define AV_RN16(p)
Definition intreadwrite.h:356
AV_RB16
#define AV_RB16(p)
Definition intreadwrite.h:398
offset
unsigned offset
Definition libaomenc.c:763
op
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
Definition anm.c:76
internal.h
common internal api header.
FF_SANE_NB_CHANNELS
#define FF_SANE_NB_CHANNELS
Definition internal.h:37
arg
const char * arg
Definition jacosubdec.c:65
resync
static int resync(AVFormatContext *s)
Definition flvdec.c:1167
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition internal.h:365
ff_data_to_hex
char * ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase)
Write hexadecimal string corresponding to given binary data.
Definition utils.c:464
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition utils.c:237
attributes.h
Macro definitions for various function/variable attributes.
av_fallthrough
#define av_fallthrough
Definition attributes.h:67
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition internal.h:88
FF_ALLOC_TYPED_ARRAY
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition internal.h:71
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition libcdio.c:143
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition libcdio.c:151
AV_CLASS_CATEGORY_DEMUXER
@ AV_CLASS_CATEGORY_DEMUXER
Definition log.h:33
FFMIN
#define FFMIN(a, b)
Definition macros.h:49
MKTAG
#define MKTAG(a, b, c, d)
Definition macros.h:55
FFMAX
#define FFMAX(a, b)
Definition macros.h:47
av_content_light_metadata_alloc
AVContentLightMetadata * av_content_light_metadata_alloc(size_t *size)
Allocate an AVContentLightMetadata structure and set its fields to default values.
Definition mastering_display_metadata.c:73
av_mastering_display_metadata_alloc_size
AVMasteringDisplayMetadata * av_mastering_display_metadata_alloc_size(size_t *size)
Allocate an AVMasteringDisplayMetadata structure and set its fields to default values.
Definition mastering_display_metadata.c:44
mastering_display_metadata.h
layout
uint64_t layout
Definition mediacodecdec_common.c:155
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition mem.c:264
mem.h
Memory handling functions.
tag
uint32_t tag
Definition movenc.c:2073
ff_mxf_data_definition_uls
const MXFCodecUL ff_mxf_data_definition_uls[]
SMPTE RP224 http://www.smpte-ra.org/mdd/index.html.
Definition mxf.c:31
ff_mxf_random_index_pack_key
const uint8_t ff_mxf_random_index_pack_key[16]
Definition mxf.c:26
ff_mxf_pixel_format_uls
const MXFCodecUL ff_mxf_pixel_format_uls[]
Definition mxf.c:87
ff_mxf_color_space_uls
const MXFCodecUL ff_mxf_color_space_uls[]
Definition mxf.c:134
ff_mxf_color_trc_uls
const MXFCodecUL ff_mxf_color_trc_uls[]
Definition mxf.c:113
ff_mxf_decode_pixel_layout
int ff_mxf_decode_pixel_layout(const char pixel_layout[16], enum AVPixelFormat *pix_fmt)
Definition mxf.c:178
ff_mxf_codec_tag_uls
const MXFCodecUL ff_mxf_codec_tag_uls[]
Definition mxf.c:93
ff_mxf_codec_uls
const MXFCodecUL ff_mxf_codec_uls[]
Definition mxf.c:40
ff_mxf_color_primaries_uls
const MXFCodecUL ff_mxf_color_primaries_uls[]
Definition mxf.c:98
J2KWrap
@ J2KWrap
Definition mxf.h:86
RawAWrap
@ RawAWrap
Definition mxf.h:84
RawVWrap
@ RawVWrap
Definition mxf.h:85
D10D11Wrap
@ D10D11Wrap
Definition mxf.h:83
FF_MXF_MasteringDisplayMinimumLuminance
#define FF_MXF_MasteringDisplayMinimumLuminance
Definition mxf.h:100
UID_ARG
#define UID_ARG(x)
Definition mxf.h:132
PRINT_KEY
#define PRINT_KEY(pc, s, x)
Definition mxf.h:155
FF_MXF_MasteringDisplayPrimaries
#define FF_MXF_MasteringDisplayPrimaries
Definition mxf.h:97
FF_MXF_MasteringDisplayWhitePointChromaticity
#define FF_MXF_MasteringDisplayWhitePointChromaticity
Definition mxf.h:98
FF_MXF_MASTERING_CHROMA_DEN
#define FF_MXF_MASTERING_CHROMA_DEN
Definition mxf.h:102
FF_MXF_MASTERING_LUMA_DEN
#define FF_MXF_MASTERING_LUMA_DEN
Definition mxf.h:103
FF_MXF_MasteringDisplay_PREFIX
#define FF_MXF_MasteringDisplay_PREFIX
Definition mxf.h:96
MixedFields
@ MixedFields
Definition mxf.h:65
SegmentedFrame
@ SegmentedFrame
Definition mxf.h:66
OneField
@ OneField
Definition mxf.h:64
FullFrame
@ FullFrame
Definition mxf.h:62
SeparateFields
@ SeparateFields
Definition mxf.h:63
UID
AVUUID UID
Definition mxf.h:30
FF_MXF_MasteringDisplayMaximumLuminance
#define FF_MXF_MasteringDisplayMaximumLuminance
Definition mxf.h:99
MXFMetadataSetType
MXFMetadataSetType
Definition mxf.h:32
Sequence
@ Sequence
Definition mxf.h:38
MultipleDescriptor
@ MultipleDescriptor
Definition mxf.h:39
SoundfieldGroupLabelSubDescriptor
@ SoundfieldGroupLabelSubDescriptor
Definition mxf.h:54
MaterialPackage
@ MaterialPackage
Definition mxf.h:33
SourceClip
@ SourceClip
Definition mxf.h:35
IndexTableSegment
@ IndexTableSegment
Definition mxf.h:47
MetadataSetTypeNB
@ MetadataSetTypeNB
Definition mxf.h:58
FFV1SubDescriptor
@ FFV1SubDescriptor
Definition mxf.h:56
TaggedValue
@ TaggedValue
Definition mxf.h:50
AudioChannelLabelSubDescriptor
@ AudioChannelLabelSubDescriptor
Definition mxf.h:53
EssenceContainerData
@ EssenceContainerData
Definition mxf.h:48
SourcePackage
@ SourcePackage
Definition mxf.h:34
EssenceGroup
@ EssenceGroup
Definition mxf.h:49
Descriptor
@ Descriptor
Definition mxf.h:40
PulldownComponent
@ PulldownComponent
Definition mxf.h:37
GroupOfSoundfieldGroupsLabelSubDescriptor
@ GroupOfSoundfieldGroupsLabelSubDescriptor
Definition mxf.h:55
TimecodeComponent
@ TimecodeComponent
Definition mxf.h:36
PRIxUID
#define PRIxUID
Definition mxf.h:126
mxf_read_package
static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:1201
mxf_encrypted_essence_container
static const uint8_t mxf_encrypted_essence_container[]
Definition mxfdec.c:351
mxf_read_mca_sub_descriptor
static int mxf_read_mca_sub_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:1516
mxf_read_partition_pack
static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:754
klv_decode_ber_length
static int64_t klv_decode_ber_length(AVIOContext *pb, int *llen)
Definition mxfdec.c:434
mxf_set_pts
static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
Definition mxfdec.c:4020
mxf_read_cryptographic_context
static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:983
mxf_free_metadataset
static void mxf_free_metadataset(MXFMetadataSet **ctx, enum MXFMetadataSetType type)
Definition mxfdec.c:382
mxf_compute_ptses_fake_index
static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
Definition mxfdec.c:2006
mxf_canopus_essence_element_key
static const uint8_t mxf_canopus_essence_element_key[]
Definition mxfdec.c:342
mxf_picture_essence_container_uls
static const MXFCodecUL mxf_picture_essence_container_uls[]
Definition mxfdec.c:1630
mxf_timestamp_to_int64
static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
Definition mxfdec.c:3170
mxf_intra_only_essence_container_uls
static const MXFCodecUL mxf_intra_only_essence_container_uls[]
Definition mxfdec.c:1654
mxf_read_essence_container_data
static int mxf_read_essence_container_data(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:1225
mxf_channel_ordering
static const MXFChannelOrderingUL mxf_channel_ordering[]
Definition mxfdec.c:1701
mxf_read_source_clip
static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:1093
mxf_soundfield_group_link_id
static const uint8_t mxf_soundfield_group_link_id[]
Definition mxfdec.c:367
find_mca_link_id
static MXFMCASubDescriptor * find_mca_link_id(MXFContext *mxf, enum MXFMetadataSetType type, UID *mca_link_id)
Definition mxfdec.c:2574
mxf_read_pixel_layout
static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
Definition mxfdec.c:1321
mxf_find_index_table
static MXFIndexTable * mxf_find_index_table(MXFContext *mxf, int index_sid)
Definition mxfdec.c:3614
mxf_sub_descriptor
static const uint8_t mxf_sub_descriptor[]
Definition mxfdec.c:370
parse_ffv1_sub_descriptor
static void parse_ffv1_sub_descriptor(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
Definition mxfdec.c:2585
mxf_metadata_read_table
static const MXFMetadataReadTableEntry mxf_metadata_read_table[]
Definition mxfdec.c:3280
mxf_read_preface_metadata
static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:3267
mxf_add_metadata_stream
static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
Definition mxfdec.c:2491
mxf_crypto_source_container_ul
static const uint8_t mxf_crypto_source_container_ul[]
Definition mxfdec.c:349
mxf_read_tagged_value
static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:1581
mxf_apple_coll_max_fall
static const uint8_t mxf_apple_coll_max_fall[]
Definition mxfdec.c:359
mxf_add_metadata_set
static int mxf_add_metadata_set(MXFContext *mxf, MXFMetadataSet **metadata_set, enum MXFMetadataSetType type)
Definition mxfdec.c:954
mxf_parse_physical_source_package
static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
Definition mxfdec.c:2418
MXF_FIELD_DOMINANCE_FF
#define MXF_FIELD_DOMINANCE_FF
Definition mxfdec.c:207
mxf_decrypt_triplet
static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
Definition mxfdec.c:656
mxf_parse_structural_metadata
static int mxf_parse_structural_metadata(MXFContext *mxf)
Definition mxfdec.c:2687
mxf_mca_tag_name
static const uint8_t mxf_mca_tag_name[]
Definition mxfdec.c:363
mxf_read_seek
static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
Definition mxfdec.c:4239
mxf_set_current_edit_unit
static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
Make sure track->sample_count is correct based on what offset we're currently at.
Definition mxfdec.c:3960
mxf_klv_key
static const uint8_t mxf_klv_key[]
Definition mxfdec.c:345
MXFOP
MXFOP
Definition mxfdec.c:80
OPSONYOpt
@ OPSONYOpt
Definition mxfdec.c:91
OP1b
@ OP1b
Definition mxfdec.c:82
OP3c
@ OP3c
Definition mxfdec.c:89
OP2a
@ OP2a
Definition mxfdec.c:84
OP2b
@ OP2b
Definition mxfdec.c:85
OP1c
@ OP1c
Definition mxfdec.c:83
OPAtom
@ OPAtom
Definition mxfdec.c:90
OP3b
@ OP3b
Definition mxfdec.c:88
OP3a
@ OP3a
Definition mxfdec.c:87
OP2c
@ OP2c
Definition mxfdec.c:86
OP1a
@ OP1a
Definition mxfdec.c:81
mxf_encrypted_triplet_key
static const uint8_t mxf_encrypted_triplet_key[]
Definition mxfdec.c:350
mxf_edit_unit_absolute_offset
static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, AVRational edit_rate, int64_t *edit_unit_out, int64_t *offset_out, MXFPartition **partition_out, int nag)
Definition mxfdec.c:1923
mxf_header_partition_pack_key
static const uint8_t mxf_header_partition_pack_key[]
Definition mxfdec.c:339
MXF_FIELD_DOMINANCE_DEFAULT
#define MXF_FIELD_DOMINANCE_DEFAULT
Definition mxfdec.c:206
mxf_get_sorted_table_segments
static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
Definition mxfdec.c:1779
mxf_intra_only_picture_coded_width
static const MXFCodecUL mxf_intra_only_picture_coded_width[]
Definition mxfdec.c:1667
mxf_data_essence_container_uls
static const MXFCodecUL mxf_data_essence_container_uls[]
Definition mxfdec.c:1688
mxf_read_primer_pack
static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:728
SET_TS_METADATA
#define SET_TS_METADATA(pb, name, var, str)
Definition mxfdec.c:3217
mxf_read_local_tags
static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
Definition mxfdec.c:3341
mxf_get_next_track_edit_unit
static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
Definition mxfdec.c:3904
SET_UID_METADATA
#define SET_UID_METADATA(pb, name, var, str)
Definition mxfdec.c:3210
mxf_is_st_422
static int mxf_is_st_422(const UID *essence_container_ul)
Definition mxfdec.c:2258
mxf_sony_mpeg4_extradata
static const uint8_t mxf_sony_mpeg4_extradata[]
Definition mxfdec.c:352
mxf_mca_link_id
static const uint8_t mxf_mca_link_id[]
Definition mxfdec.c:365
mxf_read_identification_metadata
static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
Definition mxfdec.c:3223
mxf_indirect_value_utf16le
static const uint8_t mxf_indirect_value_utf16le[]
Definition mxfdec.c:356
mxf_read_sequence
static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:1170
mxf_essence_container_end
static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
Returns the end position of the essence container with given BodySID, or zero if unknown.
Definition mxfdec.c:1905
mxf_read_generic_descriptor
static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:1341
mxf_mca_channel_id
static const uint8_t mxf_mca_channel_id[]
Definition mxfdec.c:366
mxf_mastering_display_prefix
static const uint8_t mxf_mastering_display_prefix[13]
Definition mxfdec.c:372
klv_read_packet
static int klv_read_packet(MXFContext *mxf, KLVPacket *klv, AVIOContext *pb)
Definition mxfdec.c:484
mxf_read_timecode_component
static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:1115
mxf_avid_essence_element_key
static const uint8_t mxf_avid_essence_element_key[]
Definition mxfdec.c:341
SET_VERSION_METADATA
#define SET_VERSION_METADATA(pb, name, major, minor, tertiary, patch, release, str)
Definition mxfdec.c:3199
mxf_add_umid_metadata
static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage *package)
Definition mxfdec.c:2290
SET_STR_METADATA
#define SET_STR_METADATA(pb, name, str)
Definition mxfdec.c:3193
MXF_MAX_CHUNK_SIZE
#define MXF_MAX_CHUNK_SIZE
Definition mxfdec.c:71
mxf_mastering_display_uls
static const uint8_t mxf_mastering_display_uls[4][16]
Definition mxfdec.c:373
mxf_compute_sample_count
static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st, int64_t edit_unit)
Definition mxfdec.c:3929
READ_STR16
#define READ_STR16(type, big_endian)
Definition mxfdec.c:1070
mxf_read_header
static int mxf_read_header(AVFormatContext *s)
Definition mxfdec.c:3780
mxf_compute_edit_units_per_packet
static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
Deal with the case where for some audio atoms EditUnitByteCount is very small (2, 4....
Definition mxfdec.c:3628
mxf_read_index_entry_array
static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
Definition mxfdec.c:1244
mxf_read_packet
static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition mxfdec.c:4050
mxf_absolute_bodysid_offset
static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
Computes the absolute file offset of the given essence container offset.
Definition mxfdec.c:1862
mxf_parse_handle_partition_or_eof
static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
Called when the next partition or EOF is encountered.
Definition mxfdec.c:3557
find_body_sid_by_absolute_offset
static int find_body_sid_by_absolute_offset(MXFContext *mxf, int64_t offset)
Definition mxfdec.c:525
mxf_parse_handle_essence
static int mxf_parse_handle_essence(MXFContext *mxf)
Called when essence is encountered.
Definition mxfdec.c:3514
mxf_read_index_table_segment
static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:1281
mxf_read_close
static int mxf_read_close(AVFormatContext *s)
Definition mxfdec.c:4178
mxf_read_ffv1_sub_descriptor
static int mxf_read_ffv1_sub_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:1541
mxf_set_audio_pts
static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par, AVPacket *pkt)
Definition mxfdec.c:3998
is_pcm
static int is_pcm(enum AVCodecID codec_id)
Definition mxfdec.c:2553
mxf_resolve_sourceclip
static MXFStructuralComponent * mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
Definition mxfdec.c:2364
mxf_resolve_strong_ref
static void * mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
Definition mxfdec.c:1617
mxf_read_us_ascii_string
static int mxf_read_us_ascii_string(AVIOContext *pb, int size, char **str)
Definition mxfdec.c:1019
mxf_get_codec_ul
static const MXFCodecUL * mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
Definition mxfdec.c:1607
mxf_mca_label_dictionary_id
static const uint8_t mxf_mca_label_dictionary_id[]
Definition mxfdec.c:361
mxf_seek_to_previous_partition
static int mxf_seek_to_previous_partition(MXFContext *mxf)
Seeks to the previous partition and parses it, if possible.
Definition mxfdec.c:3463
mxf_handle_missing_index_segment
static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
Definition mxfdec.c:3659
mxf_is_partition_pack_key
static int mxf_is_partition_pack_key(UID key)
Matches any partition pack key, in other words:
Definition mxfdec.c:3421
MXFWrappingScheme
MXFWrappingScheme
Definition mxfdec.c:94
FrameWrapped
@ FrameWrapped
Definition mxfdec.c:96
UnknownWrapped
@ UnknownWrapped
Definition mxfdec.c:95
ClipWrapped
@ ClipWrapped
Definition mxfdec.c:97
mxf_parse_klv
static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read, int ctx_size, enum MXFMetadataSetType type)
Parses a metadata KLV.
Definition mxfdec.c:3432
mxf_mca_rfc5646_spoken_language
static const uint8_t mxf_mca_rfc5646_spoken_language[]
Definition mxfdec.c:368
MXFPartitionType
MXFPartitionType
Definition mxfdec.c:74
Footer
@ Footer
Definition mxfdec.c:77
Header
@ Header
Definition mxfdec.c:75
BodyPartition
@ BodyPartition
Definition mxfdec.c:76
MXFMetadataReadFunc
int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:329
mxf_avid_project_name
static const uint8_t mxf_avid_project_name[]
Definition mxfdec.c:354
mxf_read_indirect_value
static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
Definition mxfdec.c:1560
mxf_get_wrapping_kind
static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
Definition mxfdec.c:1741
mxf_get_eia608_packet
static int mxf_get_eia608_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt, int64_t length)
Definition mxfdec.c:548
mxf_read_sync
static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
Definition mxfdec.c:455
mxf_add_timecode_metadata
static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
Definition mxfdec.c:2300
mxf_mca_tag_symbol
static const uint8_t mxf_mca_tag_symbol[]
Definition mxfdec.c:362
mxf_read_random_index_pack
static void mxf_read_random_index_pack(AVFormatContext *s)
Definition mxfdec.c:3726
mxf_read_pulldown_component
static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:1132
mxf_resolve_source_package
static MXFPackage * mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
Definition mxfdec.c:2324
mxf_get_color_range
static enum AVColorRange mxf_get_color_range(MXFContext *mxf, MXFDescriptor *descriptor)
Definition mxfdec.c:2529
mxf_apple_coll_max_cll
static const uint8_t mxf_apple_coll_max_cll[]
Definition mxfdec.c:358
IS_KLV_KEY
#define IS_KLV_KEY(x, y)
Definition mxfdec.c:380
mxf_read_essence_group
static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:1187
mxf_version_to_str
static int mxf_version_to_str(uint16_t major, uint16_t minor, uint16_t tertiary, uint16_t patch, uint16_t release, char **str)
Definition mxfdec.c:2281
mxf_read_sync_klv
static int mxf_read_sync_klv(AVIOContext *pb)
Definition mxfdec.c:469
RUN_IN_MAX
#define RUN_IN_MAX
Definition mxfdec.c:72
mxf_probe
static int mxf_probe(const AVProbeData *p)
Definition mxfdec.c:4212
mxf_get_d10_aes3_packet
static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
Definition mxfdec.c:624
partition_score
static uint64_t partition_score(MXFPartition *p)
Definition mxfdec.c:938
mxf_essence_element_key
static const uint8_t mxf_essence_element_key[]
Definition mxfdec.c:340
mxf_match_uid
static int mxf_match_uid(const UID key, const uint8_t uid_prefix[], int len)
Definition mxfdec.c:1597
mxf_get_wrapping_by_body_sid
static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
Definition mxfdec.c:3562
mxf_intra_only_picture_essence_coding_uls
static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[]
Definition mxfdec.c:1660
mxf_indirect_value_utf16be
static const uint8_t mxf_indirect_value_utf16be[]
Definition mxfdec.c:357
MXF_FIELD_DOMINANCE_FL
#define MXF_FIELD_DOMINANCE_FL
Definition mxfdec.c:208
mxf_read_content_storage
static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:1079
mxf_resolve_descriptor
static MXFDescriptor * mxf_resolve_descriptor(MXFContext *mxf, UID *strong_ref, int track_id)
Definition mxfdec.c:2340
mxf_metadataset_init
static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type, MXFPartition *partition)
Definition mxfdec.c:3326
mxf_parse_package_comments
static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
Definition mxfdec.c:2398
mxf_apple_coll_prefix
static const uint8_t mxf_apple_coll_prefix[]
Definition mxfdec.c:346
mxf_sound_essence_container_uls
static const MXFCodecUL mxf_sound_essence_container_uls[]
Definition mxfdec.c:1675
mxf_jp2k_rsiz
static const uint8_t mxf_jp2k_rsiz[]
Definition mxfdec.c:355
mxf_resolve_timecode_component
static MXFTimecodeComponent * mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
Definition mxfdec.c:2308
mxf_get_stream_index
static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
Definition mxfdec.c:513
mxf_read_track
static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
Definition mxfdec.c:1143
mxf_ffv1_extradata
static const uint8_t mxf_ffv1_extradata[]
Definition mxfdec.c:353
parse_mca_labels
static int parse_mca_labels(MXFContext *mxf, MXFTrack *source_track, MXFDescriptor *descriptor, AVStream *st)
Definition mxfdec.c:2600
mxf_compute_essence_containers
static void mxf_compute_essence_containers(AVFormatContext *s)
Figures out the proper offset and length of the essence container in each partition.
Definition mxfdec.c:3575
mxf_read_utf16_string
static int mxf_read_utf16_string(AVIOContext *pb, int size, char **str, int be)
Definition mxfdec.c:1043
mxf_compute_index_tables
static int mxf_compute_index_tables(MXFContext *mxf)
Sorts and collects index table segments into index tables.
Definition mxfdec.c:2138
mxf_system_item_key_gc
static const uint8_t mxf_system_item_key_gc[]
Definition mxfdec.c:344
mxf_is_intra_only
static int mxf_is_intra_only(MXFDescriptor *descriptor)
Definition mxfdec.c:2265
mxf_group_of_soundfield_groups_link_id
static const uint8_t mxf_group_of_soundfield_groups_link_id[]
Definition mxfdec.c:364
mxf_umid_to_str
static void mxf_umid_to_str(const UID ul, const UID uid, char str[2+sizeof(UID) *4+1])
Definition mxfdec.c:2273
mxf_read_strong_ref_array
static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
Definition mxfdec.c:993
mxf_system_item_key_cp
static const uint8_t mxf_system_item_key_cp[]
Definition mxfdec.c:343
codec_ul
UID codec_ul
Definition mxfenc.c:2300
uid
UID uid
Definition mxfenc.c:2488
container_ul
const UID container_ul
Definition mxfenc.c:2401
av_malloc
#define av_malloc(s)
Definition ops_static.c:52
opt.h
AVOptions.
av_timegm
time_t av_timegm(struct tm *tm)
Convert the decomposed UTC time in tm to a time_t value.
Definition parseutils.c:573
parseutils.h
misc parsing utilities
AVColorRange
AVColorRange
Visual content value range.
Definition pixfmt.h:748
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition pixfmt.h:766
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition pixfmt.h:749
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition pixfmt.h:783
AV_PIX_FMT_XYZ12
#define AV_PIX_FMT_XYZ12
Definition pixfmt.h:605
AVPixelFormat
AVPixelFormat
Pixel format.
Definition pixfmt.h:71
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition pixfmt.h:72
AV_PIX_FMT_UYVY422
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition pixfmt.h:88
name
const char * name
Definition qsvenc.c:142
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition sinewin_tablegen.c:29
index_table
static const uint8_t index_table[8]
Definition siren.c:35
snprintf
#define snprintf
Definition snprintf.h:34
code
const uint8_t * code
Definition spdifenc.c:433
pos
unsigned int pos
Definition spdifenc.c:431
AVChannelCustom::id
enum AVChannel id
Definition channel_layout.h:284
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition channel_layout.h:319
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition channel_layout.h:324
AVChannelLayout::u
union AVChannelLayout::@162063043056170047076125117143030261346263330336 u
Details about which channels are present in this layout.
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition channel_layout.h:329
AVChannelLayout::map
AVChannelCustom * map
This member must be used when the channel order is AV_CHANNEL_ORDER_CUSTOM.
Definition channel_layout.h:370
AVClass
Describe the class of an AVClass context structure.
Definition log.h:76
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition codec_par.h:49
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition codec_par.h:192
AVCodecParameters::field_order
enum AVFieldOrder field_order
The order of the fields in interlaced video.
Definition codec_par.h:182
AVCodecParameters::height
int height
The height of the video frame in pixels.
Definition codec_par.h:150
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition codec_par.h:88
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition codec_par.h:113
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
The channel layout and number of channels.
Definition codec_par.h:207
AVCodecParameters::width
int width
The width of the video frame in pixels.
Definition codec_par.h:143
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition codec_par.h:53
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition codec_par.h:61
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition codec_par.h:71
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition codec_par.h:57
AVCodecParameters::color_primaries
enum AVColorPrimaries color_primaries
Definition codec_par.h:190
AVCodecParameters::sample_rate
int sample_rate
The number of audio samples per second.
Definition codec_par.h:213
AVCodecParameters::color_trc
enum AVColorTransferCharacteristic color_trc
Definition codec_par.h:191
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition codec_par.h:83
AVCodecParameters::color_range
enum AVColorRange color_range
Additional colorspace characteristics.
Definition codec_par.h:189
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition mastering_display_metadata.h:107
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition mastering_display_metadata.h:116
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition mastering_display_metadata.h:111
AVFormatContext
Format I/O context.
Definition avformat.h:1333
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition avformat.h:1389
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition avformat.h:1375
AVFormatContext::metadata
AVDictionary * metadata
Metadata that applies to the whole file.
Definition avformat.h:1580
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition avformat.h:1401
AVIOContext
Bytestream IO Context.
Definition avio.h:160
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition avio.h:261
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition mastering_display_metadata.h:38
AVMasteringDisplayMetadata::has_primaries
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
Definition mastering_display_metadata.h:62
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition mastering_display_metadata.h:57
AVMasteringDisplayMetadata::min_luminance
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
Definition mastering_display_metadata.h:52
AVMasteringDisplayMetadata::display_primaries
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
Definition mastering_display_metadata.h:42
AVMasteringDisplayMetadata::white_point
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Definition mastering_display_metadata.h:47
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition mastering_display_metadata.h:67
AVOption
AVOption.
Definition opt.h:428
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition packet.h:424
AVPacketSideData::data
uint8_t * data
Definition packet.h:425
AVPacket
This structure stores compressed data.
Definition packet.h:580
AVProbeData
This structure contains the data a format has to probe a file.
Definition avformat.h:471
AVRational
Rational number (pair of numerator and denominator).
Definition rational.h:58
AVRational::num
int num
Numerator.
Definition rational.h:59
AVRational::den
int den
Denominator.
Definition rational.h:60
AVStream
Stream structure.
Definition avformat.h:766
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition avformat.h:789
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition avformat.h:825
AVStream::metadata
AVDictionary * metadata
Definition avformat.h:846
AVStream::priv_data
void * priv_data
Definition avformat.h:791
AVStream::id
int id
Format-specific stream ID.
Definition avformat.h:778
AVStream::index
int index
stream index in AVFormatContext
Definition avformat.h:772
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition avformat.h:815
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition avformat.h:855
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition avformat.h:805
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition avformat.h:900
FFStream::display_aspect_ratio
AVRational display_aspect_ratio
display aspect ratio (0 if unknown)
Definition internal.h:303
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition internal.h:321
KLVPacket::length
uint64_t length
Definition mxf.h:77
KLVPacket::offset
int64_t offset
Definition mxf.h:76
KLVPacket::next_klv
int64_t next_klv
Definition mxf.h:78
KLVPacket::key
UID key
Definition mxf.h:75
MXFChannelOrderingUL::service_type
enum AVAudioServiceType service_type
Definition mxfdec.c:1698
MXFChannelOrderingUL::channel
enum AVChannel channel
Definition mxfdec.c:1697
MXFCodecUL::uid
UID uid
Definition mxf.h:106
MXFCodecUL::matching_len
unsigned matching_len
Definition mxf.h:107
MXFCodecUL::id
int id
Definition mxf.h:108
MXFContext::eia608_extract
int eia608_extract
Definition mxfdec.c:325
MXFContext::partitions
MXFPartition * partitions
Definition mxfdec.c:304
MXFContext::index_tables
MXFIndexTable * index_tables
Definition mxfdec.c:324
MXFContext::last_forward_tell
int64_t last_forward_tell
Definition mxfdec.c:321
MXFContext::nb_index_tables
int nb_index_tables
Definition mxfdec.c:323
MXFContext::footer_partition
uint64_t footer_partition
Definition mxfdec.c:316
MXFContext::last_forward_partition
int last_forward_partition
Definition mxfdec.c:322
MXFContext::local_tags
uint8_t * local_tags
Definition mxfdec.c:314
MXFContext::local_tags_count
int local_tags_count
Definition mxfdec.c:315
MXFContext::run_in
int run_in
Definition mxfdec.c:318
MXFContext::current_klv_data
KLVPacket current_klv_data
Definition mxfdec.c:317
MXFContext::current_partition
MXFPartition * current_partition
Definition mxfdec.c:319
MXFContext::fc
AVFormatContext * fc
Definition mxfdec.c:312
MXFContext::parsing_backward
int parsing_backward
Definition mxfdec.c:320
MXFContext::essence_container_data_count
int essence_container_data_count
Definition mxfdec.c:310
MXFContext::partitions_count
unsigned partitions_count
Definition mxfdec.c:305
MXFContext::aesc
struct AVAES * aesc
Definition mxfdec.c:313
MXFContext::metadata_set_groups
MXFMetadataSetGroup metadata_set_groups[MetadataSetTypeNB]
Definition mxfdec.c:311
MXFContext::packages_count
int packages_count
Definition mxfdec.c:308
MXFContext::packages_refs
UID * packages_refs
Definition mxfdec.c:307
MXFContext::op
MXFOP op
Definition mxfdec.c:306
MXFContext::essence_container_data_refs
UID * essence_container_data_refs
Definition mxfdec.c:309
MXFCryptoContext::source_container_ul
UID source_container_ul
Definition mxfdec.c:130
MXFCryptoContext::meta
MXFMetadataSet meta
Definition mxfdec.c:129
MXFDescriptor::mastering_size
size_t mastering_size
Definition mxfdec.c:231
MXFDescriptor::component_depth
unsigned int component_depth
Definition mxfdec.c:213
MXFDescriptor::color_primaries_ul
UID color_primaries_ul
Definition mxfdec.c:227
MXFDescriptor::color_range
unsigned int color_range
Definition mxfdec.c:216
MXFDescriptor::pix_fmt
enum AVPixelFormat pix_fmt
Definition mxfdec.c:226
MXFDescriptor::horiz_subsampling
unsigned int horiz_subsampling
Definition mxfdec.c:217
MXFDescriptor::sample_rate
AVRational sample_rate
Definition mxfdec.c:200
MXFDescriptor::field_dominance
int field_dominance
Definition mxfdec.c:209
MXFDescriptor::bits_per_sample
int bits_per_sample
Definition mxfdec.c:211
MXFDescriptor::black_ref_level
unsigned int black_ref_level
Definition mxfdec.c:214
MXFDescriptor::vert_subsampling
unsigned int vert_subsampling
Definition mxfdec.c:218
MXFDescriptor::extradata_size
int extradata_size
Definition mxfdec.c:225
MXFDescriptor::essence_codec_ul
UID essence_codec_ul
Definition mxfdec.c:198
MXFDescriptor::video_line_map
int video_line_map[2]
Definition mxfdec.c:205
MXFDescriptor::file_descriptors_refs
UID * file_descriptors_refs
Definition mxfdec.c:219
MXFDescriptor::white_ref_level
unsigned int white_ref_level
Definition mxfdec.c:215
MXFDescriptor::duration
int64_t duration
Definition mxfdec.c:212
MXFDescriptor::file_descriptors_count
int file_descriptors_count
Definition mxfdec.c:220
MXFDescriptor::sub_descriptors_count
int sub_descriptors_count
Definition mxfdec.c:222
MXFDescriptor::linked_track_id
int linked_track_id
Definition mxfdec.c:223
MXFDescriptor::sub_descriptors_refs
UID * sub_descriptors_refs
Definition mxfdec.c:221
MXFDescriptor::color_trc_ul
UID color_trc_ul
Definition mxfdec.c:228
MXFDescriptor::color_space_ul
UID color_space_ul
Definition mxfdec.c:229
MXFDescriptor::mastering
AVMasteringDisplayMetadata * mastering
Definition mxfdec.c:230
MXFDescriptor::extradata
uint8_t * extradata
Definition mxfdec.c:224
MXFDescriptor::coll_size
size_t coll_size
Definition mxfdec.c:233
MXFDescriptor::essence_container_ul
UID essence_container_ul
Definition mxfdec.c:197
MXFDescriptor::coll
AVContentLightMetadata * coll
Definition mxfdec.c:232
MXFDescriptor::frame_layout
int frame_layout
Definition mxfdec.c:204
MXFDescriptor::meta
MXFMetadataSet meta
Definition mxfdec.c:196
MXFDescriptor::aspect_ratio
AVRational aspect_ratio
Definition mxfdec.c:201
MXFEssenceContainerData::meta
MXFMetadataSet meta
Definition mxfdec.c:282
MXFEssenceGroup::meta
MXFMetadataSet meta
Definition mxfdec.c:165
MXFEssenceGroup::structural_components_refs
UID * structural_components_refs
Definition mxfdec.c:166
MXFEssenceGroup::duration
int64_t duration
Definition mxfdec.c:168
MXFEssenceGroup::structural_components_count
int structural_components_count
Definition mxfdec.c:167
MXFFFV1SubDescriptor::meta
MXFMetadataSet meta
Definition mxfdec.c:249
MXFFFV1SubDescriptor::extradata
uint8_t * extradata
Definition mxfdec.c:250
MXFIndexTableSegment::stream_offset_entries
uint64_t * stream_offset_entries
Definition mxfdec.c:264
MXFIndexTableSegment::edit_unit_byte_count
unsigned edit_unit_byte_count
Definition mxfdec.c:256
MXFIndexTableSegment::index_start_position
uint64_t index_start_position
Definition mxfdec.c:260
MXFIndexTableSegment::meta
MXFMetadataSet meta
Definition mxfdec.c:255
MXFIndexTableSegment::index_duration
uint64_t index_duration
Definition mxfdec.c:261
MXFIndexTableSegment::index_edit_rate
AVRational index_edit_rate
Definition mxfdec.c:259
MXFIndexTableSegment::temporal_offset_entries
int8_t * temporal_offset_entries
Definition mxfdec.c:262
MXFIndexTable::ptses
int64_t * ptses
Definition mxfdec.c:295
MXFIndexTable::index_sid
int index_sid
Definition mxfdec.c:291
MXFIndexTable::fake_index
AVIndexEntry * fake_index
Definition mxfdec.c:298
MXFIndexTable::nb_segments
int nb_segments
Definition mxfdec.c:296
MXFIndexTable::first_dts
int64_t first_dts
Definition mxfdec.c:294
MXFIndexTable::offsets
int8_t * offsets
Definition mxfdec.c:299
MXFIndexTable::segments
MXFIndexTableSegment ** segments
Definition mxfdec.c:297
MXFMCASubDescriptor::soundfield_group_link_id
UID soundfield_group_link_id
Definition mxfdec.c:240
MXFMCASubDescriptor::mca_label_dictionary_id
UID mca_label_dictionary_id
Definition mxfdec.c:243
MXFMCASubDescriptor::meta
MXFMetadataSet meta
Definition mxfdec.c:237
MXFMCASubDescriptor::group_of_soundfield_groups_link_id_refs
UID * group_of_soundfield_groups_link_id_refs
Definition mxfdec.c:241
MXFMCASubDescriptor::group_of_soundfield_groups_link_id_count
int group_of_soundfield_groups_link_id_count
Definition mxfdec.c:242
MXFMetadataReadTableEntry::type
enum MXFMetadataSetType type
Definition mxfdec.c:335
MXFMetadataReadTableEntry::read
MXFMetadataReadFunc * read
Definition mxfdec.c:333
MXFMetadataSetGroup::metadata_sets
MXFMetadataSet ** metadata_sets
Definition mxfdec.c:124
MXFMetadataSet::partition_score
uint64_t partition_score
Definition mxfdec.c:120
MXFPackage::comment_refs
UID * comment_refs
Definition mxfdec.c:277
MXFPackage::tracks_refs
UID * tracks_refs
Definition mxfdec.c:273
MXFPackage::package_ul
UID package_ul
Definition mxfdec.c:272
MXFPackage::package_uid
UID package_uid
Definition mxfdec.c:271
MXFPackage::tracks_count
int tracks_count
Definition mxfdec.c:274
MXFPackage::comment_count
int comment_count
Definition mxfdec.c:278
MXFPackage::name
char * name
Definition mxfdec.c:276
MXFPackage::descriptor_ref
UID descriptor_ref
Definition mxfdec.c:275
MXFPackage::meta
MXFMetadataSet meta
Definition mxfdec.c:270
MXFPartition::pack_length
int pack_length
Definition mxfdec.c:112
MXFPartition::previous_partition
uint64_t previous_partition
Definition mxfdec.c:104
MXFPartition::essence_length
int64_t essence_length
Definition mxfdec.c:108
MXFPartition::index_byte_count
int64_t index_byte_count
Definition mxfdec.c:111
MXFPartition::pack_ofs
int64_t pack_ofs
absolute offset of pack in file, including run-in
Definition mxfdec.c:113
MXFPartition::index_sid
int index_sid
Definition mxfdec.c:105
MXFPartition::essence_offset
int64_t essence_offset
absolute offset of essence
Definition mxfdec.c:107
MXFPartition::body_sid
int body_sid
Definition mxfdec.c:106
MXFPartition::kag_size
int32_t kag_size
Definition mxfdec.c:109
MXFPartition::first_essence_klv
KLVPacket first_essence_klv
Definition mxfdec.c:115
MXFPartition::body_offset
int64_t body_offset
Definition mxfdec.c:114
MXFPartition::header_byte_count
int64_t header_byte_count
Definition mxfdec.c:110
MXFPartition::complete
int complete
Definition mxfdec.c:102
MXFPartition::type
MXFPartitionType type
Definition mxfdec.c:103
MXFPulldownComponent::meta
MXFMetadataSet meta
Definition mxfdec.c:160
MXFSequence::duration
int64_t duration
Definition mxfdec.c:148
MXFSequence::structural_components_refs
UID * structural_components_refs
Definition mxfdec.c:146
MXFSequence::meta
MXFMetadataSet meta
Definition mxfdec.c:144
MXFSequence::data_definition_ul
UID data_definition_ul
Definition mxfdec.c:145
MXFSequence::structural_components_count
int structural_components_count
Definition mxfdec.c:147
MXFStructuralComponent::meta
MXFMetadataSet meta
Definition mxfdec.c:134
MXFTaggedValue::value
char * value
Definition mxfdec.c:174
MXFTaggedValue::name
char * name
Definition mxfdec.c:173
MXFTaggedValue::meta
MXFMetadataSet meta
Definition mxfdec.c:172
MXFTimecodeComponent::rate
struct AVRational rate
Definition mxfdec.c:155
MXFTimecodeComponent::tc
AVTimecode tc
Definition mxfdec.c:156
MXFTimecodeComponent::meta
MXFMetadataSet meta
Definition mxfdec.c:152
MXFTrack::intra_only
int intra_only
Definition mxfdec.c:185
MXFTrack::original_duration
int64_t original_duration
Definition mxfdec.c:187
MXFTrack::edit_units_per_packet
int edit_units_per_packet
Definition mxfdec.c:191
MXFTrack::body_sid
int body_sid
Definition mxfdec.c:189
MXFTrack::sequence
MXFSequence * sequence
Definition mxfdec.c:179
MXFTrack::sample_count
uint64_t sample_count
Definition mxfdec.c:186
MXFTrack::origin
int64_t origin
Definition mxfdec.c:192
MXFTrack::index_sid
int index_sid
Definition mxfdec.c:188
MXFTrack::track_number
uint8_t track_number[4]
Definition mxfdec.c:183
MXFTrack::wrapping
MXFWrappingScheme wrapping
Definition mxfdec.c:190
MXFTrack::name
char * name
Definition mxfdec.c:182
MXFTrack::edit_rate
AVRational edit_rate
Definition mxfdec.c:184
MXFTrack::track_id
int track_id
Definition mxfdec.c:181
MXFTrack::meta
MXFMetadataSet meta
Definition mxfdec.c:178
MXFTrack::sequence_ref
UID sequence_ref
Definition mxfdec.c:180
segment
Definition hls.c:77
av_free
#define av_free(p)
Definition tableprint_vlc.h:34
av_malloc_array
#define av_malloc_array(a, b)
Definition tableprint_vlc.h:32
av_mallocz
#define av_mallocz(s)
Definition tableprint_vlc.h:31
avpriv_request_sample
#define avpriv_request_sample(...)
Definition tableprint_vlc.h:37
av_freep
#define av_freep(p)
Definition tableprint_vlc.h:35
av_log
#define av_log(a,...)
Definition tableprint_vlc.h:27
ctx
static AVFormatContext * ctx
Definition movenc.c:49
av_timecode_init
int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx)
Init a timecode struct with the passed parameters.
Definition timecode.c:201
av_timecode_make_string
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum_arg)
Load timecode string in buf.
Definition timecode.c:104
timecode.h
Timecode helpers header.
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition timecode.h:33
AV_TIMECODE_FLAG_DROPFRAME
@ AV_TIMECODE_FLAG_DROPFRAME
timecode is drop frame
Definition timecode.h:36
size
int size
Definition twinvq_data.h:10344
codec_id
enum AVCodecID codec_id
Definition vaapi_decode.c:410
mg
#define mg
Definition vf_colormatrix.c:104
len
int len
Definition vorbis_enc_data.h:426
c
static double c[64]
Definition vsrc_mptestsrc.c:89
Generated on Mon Aug 17 2026 20:21:10 for FFmpeg by doxygen 1.13.2