git.sesse.net Git - ffmpeg/blob - libavformat/mxfdec.c

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