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  *
  32  * Principle
  33  * Search for Track numbers which will identify essence element KLV packets.
  34  * Search for SourcePackage which define tracks which contains Track numbers.
  35  * Material Package contains tracks with reference to SourcePackage tracks.
  36  * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
  37  * Assign Descriptors to correct Tracks.
  38  *
  39  * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
  40  * Metadata parsing resolves Strong References to objects.
  41  *
  42  * Simple demuxer, only OP1A supported and some files might not work at all.
  43  * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
  44  */
  45
  46 #include <inttypes.h>
  47
  48 #include "libavutil/aes.h"
  49 #include "libavutil/avassert.h"
  50 #include "libavutil/mathematics.h"
  51 #include "libavcodec/bytestream.h"
  52 #include "libavutil/intreadwrite.h"
  53 #include "libavutil/timecode.h"
  54 #include "avformat.h"
  55 #include "internal.h"
  56 #include "mxf.h"
  57
  58 typedef enum {
  59     Header,
  60     BodyPartition,
  61     Footer
  62 } MXFPartitionType;
  63
  64 typedef enum {
  65     OP1a = 1,
  66     OP1b,
  67     OP1c,
  68     OP2a,
  69     OP2b,
  70     OP2c,
  71     OP3a,
  72     OP3b,
  73     OP3c,
  74     OPAtom,
  75     OPSONYOpt,  /* FATE sample, violates the spec in places */
  76 } MXFOP;
  77
  78 typedef struct {
  79     int closed;
  80     int complete;
  81     MXFPartitionType type;
  82     uint64_t previous_partition;
  83     int index_sid;
  84     int body_sid;
  85     int64_t this_partition;
  86     int64_t essence_offset;         ///< absolute offset of essence
  87     int64_t essence_length;
  88     int32_t kag_size;
  89     int64_t header_byte_count;
  90     int64_t index_byte_count;
  91     int pack_length;
  92     int64_t pack_ofs;               ///< absolute offset of pack in file, including run-in
  93 } MXFPartition;
  94
  95 typedef struct {
  96     UID uid;
  97     enum MXFMetadataSetType type;
  98     UID source_container_ul;
  99 } MXFCryptoContext;
 100
 101 typedef struct {
 102     UID uid;
 103     enum MXFMetadataSetType type;
 104     UID source_package_uid;
 105     UID data_definition_ul;
 106     int64_t duration;
 107     int64_t start_position;
 108     int source_track_id;
 109 } MXFStructuralComponent;
 110
 111 typedef struct {
 112     UID uid;
 113     enum MXFMetadataSetType type;
 114     UID data_definition_ul;
 115     UID *structural_components_refs;
 116     int structural_components_count;
 117     int64_t duration;
 118     uint8_t origin;
 119 } MXFSequence;
 120
 121 typedef struct {
 122     UID uid;
 123     enum MXFMetadataSetType type;
 124     int drop_frame;
 125     int start_frame;
 126     struct AVRational rate;
 127     AVTimecode tc;
 128 } MXFTimecodeComponent;
 129
 130 typedef struct {
 131     UID uid;
 132     enum MXFMetadataSetType type;
 133     UID input_segment_ref;
 134 } MXFPulldownComponent;
 135
 136 typedef struct {
 137     UID uid;
 138     enum MXFMetadataSetType type;
 139     UID *structural_components_refs;
 140     int structural_components_count;
 141     int64_t duration;
 142 } MXFEssenceGroup;
 143
 144 typedef struct {
 145     UID uid;
 146     enum MXFMetadataSetType type;
 147     MXFSequence *sequence; /* mandatory, and only one */
 148     UID sequence_ref;
 149     int track_id;
 150     uint8_t track_number[4];
 151     AVRational edit_rate;
 152     int intra_only;
 153     uint64_t sample_count;
 154     int64_t original_duration; /* st->duration in SampleRate/EditRate units */
 155 } MXFTrack;
 156
 157 typedef struct {
 158     UID uid;
 159     enum MXFMetadataSetType type;
 160     UID essence_container_ul;
 161     UID essence_codec_ul;
 162     AVRational sample_rate;
 163     AVRational aspect_ratio;
 164     int width;
 165     int height; /* Field height, not frame height */
 166     int frame_layout; /* See MXFFrameLayout enum */
 167 #define MXF_TFF 1
 168 #define MXF_BFF 2
 169     int field_dominance;
 170     int channels;
 171     int bits_per_sample;
 172     int64_t duration; /* ContainerDuration optional property */
 173     unsigned int component_depth;
 174     unsigned int horiz_subsampling;
 175     unsigned int vert_subsampling;
 176     UID *sub_descriptors_refs;
 177     int sub_descriptors_count;
 178     int linked_track_id;
 179     uint8_t *extradata;
 180     int extradata_size;
 181     enum AVPixelFormat pix_fmt;
 182 } MXFDescriptor;
 183
 184 typedef struct {
 185     UID uid;
 186     enum MXFMetadataSetType type;
 187     int edit_unit_byte_count;
 188     int index_sid;
 189     int body_sid;
 190     AVRational index_edit_rate;
 191     uint64_t index_start_position;
 192     uint64_t index_duration;
 193     int8_t *temporal_offset_entries;
 194     int *flag_entries;
 195     uint64_t *stream_offset_entries;
 196     int nb_index_entries;
 197 } MXFIndexTableSegment;
 198
 199 typedef struct {
 200     UID uid;
 201     enum MXFMetadataSetType type;
 202     UID package_uid;
 203     UID *tracks_refs;
 204     int tracks_count;
 205     MXFDescriptor *descriptor; /* only one */
 206     UID descriptor_ref;
 207     char *name;
 208 } MXFPackage;
 209
 210 typedef struct {
 211     UID uid;
 212     enum MXFMetadataSetType type;
 213 } MXFMetadataSet;
 214
 215 /* decoded index table */
 216 typedef struct {
 217     int index_sid;
 218     int body_sid;
 219     int nb_ptses;               /* number of PTSes or total duration of index */
 220     int64_t first_dts;          /* DTS = EditUnit + first_dts */
 221     int64_t *ptses;             /* maps EditUnit -> PTS */
 222     int nb_segments;
 223     MXFIndexTableSegment **segments;    /* sorted by IndexStartPosition */
 224     AVIndexEntry *fake_index;   /* used for calling ff_index_search_timestamp() */
 225 } MXFIndexTable;
 226
 227 typedef struct {
 228     MXFPartition *partitions;
 229     unsigned partitions_count;
 230     MXFOP op;
 231     UID *packages_refs;
 232     int packages_count;
 233     MXFMetadataSet **metadata_sets;
 234     int metadata_sets_count;
 235     AVFormatContext *fc;
 236     struct AVAES *aesc;
 237     uint8_t *local_tags;
 238     int local_tags_count;
 239     uint64_t footer_partition;
 240     KLVPacket current_klv_data;
 241     int current_klv_index;
 242     int run_in;
 243     MXFPartition *current_partition;
 244     int parsing_backward;
 245     int64_t last_forward_tell;
 246     int last_forward_partition;
 247     int current_edit_unit;
 248     int nb_index_tables;
 249     MXFIndexTable *index_tables;
 250     int edit_units_per_packet;      ///< how many edit units to read at a time (PCM, OPAtom)
 251 } MXFContext;
 252
 253 enum MXFWrappingScheme {
 254     Frame,
 255     Clip,
 256 };
 257
 258 /* NOTE: klv_offset is not set (-1) for local keys */
 259 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
 260
 261 typedef struct {
 262     const UID key;
 263     MXFMetadataReadFunc *read;
 264     int ctx_size;
 265     enum MXFMetadataSetType type;
 266 } MXFMetadataReadTableEntry;
 267
 268 static int mxf_read_close(AVFormatContext *s);
 269
 270 /* partial keys to match */
 271 static const uint8_t mxf_header_partition_pack_key[]       = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
 272 static const uint8_t mxf_essence_element_key[]             = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
 273 static const uint8_t mxf_avid_essence_element_key[]        = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
 274 static const uint8_t mxf_system_item_key[]                 = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
 275 static const uint8_t mxf_klv_key[]                         = { 0x06,0x0e,0x2b,0x34 };
 276 /* complete keys to match */
 277 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 };
 278 static const uint8_t mxf_encrypted_triplet_key[]           = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
 279 static const uint8_t mxf_encrypted_essence_container[]     = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
 280 static const uint8_t mxf_random_index_pack_key[]           = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x11,0x01,0x00 };
 281 static const uint8_t mxf_sony_mpeg4_extradata[]            = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
 282
 283 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
 284
 285 static void mxf_free_metadataset(MXFMetadataSet **ctx)
 286 {
 287     MXFIndexTableSegment *seg;
 288     switch ((*ctx)->type) {
 289     case Descriptor:
 290         av_freep(&((MXFDescriptor *)*ctx)->extradata);
 291         break;
 292     case MultipleDescriptor:
 293         av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
 294         break;
 295     case Sequence:
 296         av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
 297         break;
 298     case EssenceGroup:
 299         av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
 300         break;
 301     case SourcePackage:
 302     case MaterialPackage:
 303         av_freep(&((MXFPackage *)*ctx)->tracks_refs);
 304         av_freep(&((MXFPackage *)*ctx)->name);
 305         break;
 306     case IndexTableSegment:
 307         seg = (MXFIndexTableSegment *)*ctx;
 308         av_freep(&seg->temporal_offset_entries);
 309         av_freep(&seg->flag_entries);
 310         av_freep(&seg->stream_offset_entries);
 311     default:
 312         break;
 313     }
 314     av_freep(ctx);
 315 }
 316
 317 static int64_t klv_decode_ber_length(AVIOContext *pb)
 318 {
 319     uint64_t size = avio_r8(pb);
 320     if (size & 0x80) { /* long form */
 321         int bytes_num = size & 0x7f;
 322         /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
 323         if (bytes_num > 8)
 324             return AVERROR_INVALIDDATA;
 325         size = 0;
 326         while (bytes_num--)
 327             size = size << 8 | avio_r8(pb);
 328     }
 329     return size;
 330 }
 331
 332 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
 333 {
 334     int i, b;
 335     for (i = 0; i < size && !avio_feof(pb); i++) {
 336         b = avio_r8(pb);
 337         if (b == key[0])
 338             i = 0;
 339         else if (b != key[i])
 340             i = -1;
 341     }
 342     return i == size;
 343 }
 344
 345 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
 346 {
 347     if (!mxf_read_sync(pb, mxf_klv_key, 4))
 348         return AVERROR_INVALIDDATA;
 349     klv->offset = avio_tell(pb) - 4;
 350     memcpy(klv->key, mxf_klv_key, 4);
 351     avio_read(pb, klv->key + 4, 12);
 352     klv->length = klv_decode_ber_length(pb);
 353     return klv->length == -1 ? -1 : 0;
 354 }
 355
 356 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
 357 {
 358     int i;
 359
 360     for (i = 0; i < s->nb_streams; i++) {
 361         MXFTrack *track = s->streams[i]->priv_data;
 362         /* SMPTE 379M 7.3 */
 363         if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
 364             return i;
 365     }
 366     /* return 0 if only one stream, for OP Atom files with 0 as track number */
 367     return s->nb_streams == 1 ? 0 : -1;
 368 }
 369
 370 /* XXX: use AVBitStreamFilter */
 371 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
 372 {
 373     const uint8_t *buf_ptr, *end_ptr;
 374     uint8_t *data_ptr;
 375     int i;
 376
 377     if (length > 61444) /* worst case PAL 1920 samples 8 channels */
 378         return AVERROR_INVALIDDATA;
 379     length = av_get_packet(pb, pkt, length);
 380     if (length < 0)
 381         return length;
 382     data_ptr = pkt->data;
 383     end_ptr = pkt->data + length;
 384     buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
 385     for (; end_ptr - buf_ptr >= st->codec->channels * 4; ) {
 386         for (i = 0; i < st->codec->channels; i++) {
 387             uint32_t sample = bytestream_get_le32(&buf_ptr);
 388             if (st->codec->bits_per_coded_sample == 24)
 389                 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
 390             else
 391                 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
 392         }
 393         buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M
 394     }
 395     av_shrink_packet(pkt, data_ptr - pkt->data);
 396     return 0;
 397 }
 398
 399 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
 400 {
 401     static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
 402     MXFContext *mxf = s->priv_data;
 403     AVIOContext *pb = s->pb;
 404     int64_t end = avio_tell(pb) + klv->length;
 405     int64_t size;
 406     uint64_t orig_size;
 407     uint64_t plaintext_size;
 408     uint8_t ivec[16];
 409     uint8_t tmpbuf[16];
 410     int index;
 411
 412     if (!mxf->aesc && s->key && s->keylen == 16) {
 413         mxf->aesc = av_aes_alloc();
 414         if (!mxf->aesc)
 415             return AVERROR(ENOMEM);
 416         av_aes_init(mxf->aesc, s->key, 128, 1);
 417     }
 418     // crypto context
 419     avio_skip(pb, klv_decode_ber_length(pb));
 420     // plaintext offset
 421     klv_decode_ber_length(pb);
 422     plaintext_size = avio_rb64(pb);
 423     // source klv key
 424     klv_decode_ber_length(pb);
 425     avio_read(pb, klv->key, 16);
 426     if (!IS_KLV_KEY(klv, mxf_essence_element_key))
 427         return AVERROR_INVALIDDATA;
 428     index = mxf_get_stream_index(s, klv);
 429     if (index < 0)
 430         return AVERROR_INVALIDDATA;
 431     // source size
 432     klv_decode_ber_length(pb);
 433     orig_size = avio_rb64(pb);
 434     if (orig_size < plaintext_size)
 435         return AVERROR_INVALIDDATA;
 436     // enc. code
 437     size = klv_decode_ber_length(pb);
 438     if (size < 32 || size - 32 < orig_size)
 439         return AVERROR_INVALIDDATA;
 440     avio_read(pb, ivec, 16);
 441     avio_read(pb, tmpbuf, 16);
 442     if (mxf->aesc)
 443         av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
 444     if (memcmp(tmpbuf, checkv, 16))
 445         av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
 446     size -= 32;
 447     size = av_get_packet(pb, pkt, size);
 448     if (size < 0)
 449         return size;
 450     else if (size < plaintext_size)
 451         return AVERROR_INVALIDDATA;
 452     size -= plaintext_size;
 453     if (mxf->aesc)
 454         av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
 455                      &pkt->data[plaintext_size], size >> 4, ivec, 1);
 456     av_shrink_packet(pkt, orig_size);
 457     pkt->stream_index = index;
 458     avio_skip(pb, end - avio_tell(pb));
 459     return 0;
 460 }
 461
 462 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 463 {
 464     MXFContext *mxf = arg;
 465     int item_num = avio_rb32(pb);
 466     int item_len = avio_rb32(pb);
 467
 468     if (item_len != 18) {
 469         avpriv_request_sample(pb, "Primer pack item length %d", item_len);
 470         return AVERROR_PATCHWELCOME;
 471     }
 472     if (item_num > 65536) {
 473         av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
 474         return AVERROR_INVALIDDATA;
 475     }
 476     if (mxf->local_tags)
 477         av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
 478     av_free(mxf->local_tags);
 479     mxf->local_tags_count = 0;
 480     mxf->local_tags = av_calloc(item_num, item_len);
 481     if (!mxf->local_tags)
 482         return AVERROR(ENOMEM);
 483     mxf->local_tags_count = item_num;
 484     avio_read(pb, mxf->local_tags, item_num*item_len);
 485     return 0;
 486 }
 487
 488 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 489 {
 490     MXFContext *mxf = arg;
 491     MXFPartition *partition, *tmp_part;
 492     UID op;
 493     uint64_t footer_partition;
 494     uint32_t nb_essence_containers;
 495
 496     tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
 497     if (!tmp_part)
 498         return AVERROR(ENOMEM);
 499     mxf->partitions = tmp_part;
 500
 501     if (mxf->parsing_backward) {
 502         /* insert the new partition pack in the middle
 503          * this makes the entries in mxf->partitions sorted by offset */
 504         memmove(&mxf->partitions[mxf->last_forward_partition+1],
 505                 &mxf->partitions[mxf->last_forward_partition],
 506                 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
 507         partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
 508     } else {
 509         mxf->last_forward_partition++;
 510         partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
 511     }
 512
 513     memset(partition, 0, sizeof(*partition));
 514     mxf->partitions_count++;
 515     partition->pack_length = avio_tell(pb) - klv_offset + size;
 516     partition->pack_ofs    = klv_offset;
 517
 518     switch(uid[13]) {
 519     case 2:
 520         partition->type = Header;
 521         break;
 522     case 3:
 523         partition->type = BodyPartition;
 524         break;
 525     case 4:
 526         partition->type = Footer;
 527         break;
 528     default:
 529         av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
 530         return AVERROR_INVALIDDATA;
 531     }
 532
 533     /* consider both footers to be closed (there is only Footer and CompleteFooter) */
 534     partition->closed = partition->type == Footer || !(uid[14] & 1);
 535     partition->complete = uid[14] > 2;
 536     avio_skip(pb, 4);
 537     partition->kag_size = avio_rb32(pb);
 538     partition->this_partition = avio_rb64(pb);
 539     partition->previous_partition = avio_rb64(pb);
 540     footer_partition = avio_rb64(pb);
 541     partition->header_byte_count = avio_rb64(pb);
 542     partition->index_byte_count = avio_rb64(pb);
 543     partition->index_sid = avio_rb32(pb);
 544     avio_skip(pb, 8);
 545     partition->body_sid = avio_rb32(pb);
 546     if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
 547         av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
 548         return AVERROR_INVALIDDATA;
 549     }
 550     nb_essence_containers = avio_rb32(pb);
 551
 552     if (partition->this_partition &&
 553         partition->previous_partition == partition->this_partition) {
 554         av_log(mxf->fc, AV_LOG_ERROR,
 555                "PreviousPartition equal to ThisPartition %"PRIx64"\n",
 556                partition->previous_partition);
 557         /* override with the actual previous partition offset */
 558         if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
 559             MXFPartition *prev =
 560                 mxf->partitions + mxf->last_forward_partition - 2;
 561             partition->previous_partition = prev->this_partition;
 562         }
 563         /* if no previous body partition are found point to the header
 564          * partition */
 565         if (partition->previous_partition == partition->this_partition)
 566             partition->previous_partition = 0;
 567         av_log(mxf->fc, AV_LOG_ERROR,
 568                "Overriding PreviousPartition with %"PRIx64"\n",
 569                partition->previous_partition);
 570     }
 571
 572     /* some files don'thave FooterPartition set in every partition */
 573     if (footer_partition) {
 574         if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
 575             av_log(mxf->fc, AV_LOG_ERROR,
 576                    "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
 577                    mxf->footer_partition, footer_partition);
 578         } else {
 579             mxf->footer_partition = footer_partition;
 580         }
 581     }
 582
 583     av_dlog(mxf->fc,
 584             "PartitionPack: ThisPartition = 0x%"PRIX64
 585             ", PreviousPartition = 0x%"PRIX64", "
 586             "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
 587             partition->this_partition,
 588             partition->previous_partition, footer_partition,
 589             partition->index_sid, partition->body_sid);
 590
 591     /* sanity check PreviousPartition if set */
 592     //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
 593     if (partition->previous_partition &&
 594         mxf->run_in + partition->previous_partition >= klv_offset) {
 595         av_log(mxf->fc, AV_LOG_ERROR,
 596                "PreviousPartition points to this partition or forward\n");
 597         return AVERROR_INVALIDDATA;
 598     }
 599
 600     if      (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
 601     else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
 602     else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
 603     else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
 604     else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
 605     else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
 606     else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
 607     else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
 608     else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
 609     else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
 610     else if (op[12] == 0x10) {
 611         /* SMPTE 390m: "There shall be exactly one essence container"
 612          * The following block deals with files that violate this, namely:
 613          * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
 614          * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
 615         if (nb_essence_containers != 1) {
 616             MXFOP op = nb_essence_containers ? OP1a : OPAtom;
 617
 618             /* only nag once */
 619             if (!mxf->op)
 620                 av_log(mxf->fc, AV_LOG_WARNING,
 621                        "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
 622                        nb_essence_containers,
 623                        op == OP1a ? "OP1a" : "OPAtom");
 624
 625             mxf->op = op;
 626         } else
 627             mxf->op = OPAtom;
 628     } else {
 629         av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
 630         mxf->op = OP1a;
 631     }
 632
 633     if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
 634         av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
 635                partition->kag_size);
 636
 637         if (mxf->op == OPSONYOpt)
 638             partition->kag_size = 512;
 639         else
 640             partition->kag_size = 1;
 641
 642         av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
 643     }
 644
 645     return 0;
 646 }
 647
 648 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
 649 {
 650     MXFMetadataSet **tmp;
 651
 652     tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
 653     if (!tmp)
 654         return AVERROR(ENOMEM);
 655     mxf->metadata_sets = tmp;
 656     mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
 657     mxf->metadata_sets_count++;
 658     return 0;
 659 }
 660
 661 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 662 {
 663     MXFCryptoContext *cryptocontext = arg;
 664     if (size != 16)
 665         return AVERROR_INVALIDDATA;
 666     if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
 667         avio_read(pb, cryptocontext->source_container_ul, 16);
 668     return 0;
 669 }
 670
 671 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 672 {
 673     MXFContext *mxf = arg;
 674     switch (tag) {
 675     case 0x1901:
 676         if (mxf->packages_refs)
 677             av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
 678         av_free(mxf->packages_refs);
 679         mxf->packages_count = avio_rb32(pb);
 680         mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID));
 681         if (!mxf->packages_refs)
 682             return AVERROR(ENOMEM);
 683         avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
 684         avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));
 685         break;
 686     }
 687     return 0;
 688 }
 689
 690 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 691 {
 692     MXFStructuralComponent *source_clip = arg;
 693     switch(tag) {
 694     case 0x0202:
 695         source_clip->duration = avio_rb64(pb);
 696         break;
 697     case 0x1201:
 698         source_clip->start_position = avio_rb64(pb);
 699         break;
 700     case 0x1101:
 701         /* UMID, only get last 16 bytes */
 702         avio_skip(pb, 16);
 703         avio_read(pb, source_clip->source_package_uid, 16);
 704         break;
 705     case 0x1102:
 706         source_clip->source_track_id = avio_rb32(pb);
 707         break;
 708     }
 709     return 0;
 710 }
 711
 712 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 713 {
 714     MXFTimecodeComponent *mxf_timecode = arg;
 715     switch(tag) {
 716     case 0x1501:
 717         mxf_timecode->start_frame = avio_rb64(pb);
 718         break;
 719     case 0x1502:
 720         mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
 721         break;
 722     case 0x1503:
 723         mxf_timecode->drop_frame = avio_r8(pb);
 724         break;
 725     }
 726     return 0;
 727 }
 728
 729 static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 730 {
 731     MXFPulldownComponent *mxf_pulldown = arg;
 732     switch(tag) {
 733     case 0x0d01:
 734         avio_read(pb, mxf_pulldown->input_segment_ref, 16);
 735         break;
 736     }
 737     return 0;
 738 }
 739
 740 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 741 {
 742     MXFTrack *track = arg;
 743     switch(tag) {
 744     case 0x4801:
 745         track->track_id = avio_rb32(pb);
 746         break;
 747     case 0x4804:
 748         avio_read(pb, track->track_number, 4);
 749         break;
 750     case 0x4b01:
 751         track->edit_rate.num = avio_rb32(pb);
 752         track->edit_rate.den = avio_rb32(pb);
 753         break;
 754     case 0x4803:
 755         avio_read(pb, track->sequence_ref, 16);
 756         break;
 757     }
 758     return 0;
 759 }
 760
 761 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 762 {
 763     MXFSequence *sequence = arg;
 764     switch(tag) {
 765     case 0x0202:
 766         sequence->duration = avio_rb64(pb);
 767         break;
 768     case 0x0201:
 769         avio_read(pb, sequence->data_definition_ul, 16);
 770         break;
 771         case 0x4b02:
 772         sequence->origin = avio_r8(pb);
 773         break;
 774     case 0x1001:
 775         sequence->structural_components_count = avio_rb32(pb);
 776         sequence->structural_components_refs = av_calloc(sequence->structural_components_count, sizeof(UID));
 777         if (!sequence->structural_components_refs) {
 778             sequence->structural_components_count = 0;
 779             return AVERROR(ENOMEM);
 780         }
 781         avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
 782         avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
 783         break;
 784     }
 785     return 0;
 786 }
 787
 788 static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 789 {
 790     MXFEssenceGroup *essence_group = arg;
 791     switch (tag) {
 792     case 0x0202:
 793         essence_group->duration = avio_rb64(pb);
 794         break;
 795     case 0x0501:
 796         essence_group->structural_components_count = avio_rb32(pb);
 797         essence_group->structural_components_refs = av_calloc(essence_group->structural_components_count, sizeof(UID));
 798         if (!essence_group->structural_components_refs) {
 799             essence_group->structural_components_count = 0;
 800             return AVERROR(ENOMEM);
 801         }
 802         avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
 803         avio_read(pb, (uint8_t *)essence_group->structural_components_refs, essence_group->structural_components_count * sizeof(UID));
 804         break;
 805     }
 806     return 0;
 807 }
 808
 809 static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str)
 810 {
 811     int ret;
 812     size_t buf_size;
 813
 814     if (size < 0)
 815         return AVERROR(EINVAL);
 816
 817     buf_size = size + size / 2 + 1;
 818     *str = av_malloc(buf_size);
 819     if (!*str)
 820         return AVERROR(ENOMEM);
 821
 822     if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
 823         av_freep(str);
 824         return ret;
 825     }
 826
 827     return ret;
 828 }
 829
 830 static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 831 {
 832     MXFPackage *package = arg;
 833     switch(tag) {
 834     case 0x4403:
 835         package->tracks_count = avio_rb32(pb);
 836         package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
 837         if (!package->tracks_refs)
 838             return AVERROR(ENOMEM);
 839         avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
 840         avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
 841         break;
 842     case 0x4401:
 843         /* UMID, only get last 16 bytes */
 844         avio_skip(pb, 16);
 845         avio_read(pb, package->package_uid, 16);
 846         break;
 847     case 0x4701:
 848         avio_read(pb, package->descriptor_ref, 16);
 849         break;
 850     case 0x4402:
 851         return mxf_read_utf16_string(pb, size, &package->name);
 852     }
 853     return 0;
 854 }
 855
 856 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
 857 {
 858     int i, length;
 859
 860     segment->nb_index_entries = avio_rb32(pb);
 861
 862     length = avio_rb32(pb);
 863
 864     if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
 865         !(segment->flag_entries          = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
 866         !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries)))) {
 867         av_freep(&segment->temporal_offset_entries);
 868         av_freep(&segment->flag_entries);
 869         return AVERROR(ENOMEM);
 870     }
 871
 872     for (i = 0; i < segment->nb_index_entries; i++) {
 873         segment->temporal_offset_entries[i] = avio_r8(pb);
 874         avio_r8(pb);                                        /* KeyFrameOffset */
 875         segment->flag_entries[i] = avio_r8(pb);
 876         segment->stream_offset_entries[i] = avio_rb64(pb);
 877         avio_skip(pb, length - 11);
 878     }
 879     return 0;
 880 }
 881
 882 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 883 {
 884     MXFIndexTableSegment *segment = arg;
 885     switch(tag) {
 886     case 0x3F05:
 887         segment->edit_unit_byte_count = avio_rb32(pb);
 888         av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
 889         break;
 890     case 0x3F06:
 891         segment->index_sid = avio_rb32(pb);
 892         av_dlog(NULL, "IndexSID %d\n", segment->index_sid);
 893         break;
 894     case 0x3F07:
 895         segment->body_sid = avio_rb32(pb);
 896         av_dlog(NULL, "BodySID %d\n", segment->body_sid);
 897         break;
 898     case 0x3F0A:
 899         av_dlog(NULL, "IndexEntryArray found\n");
 900         return mxf_read_index_entry_array(pb, segment);
 901     case 0x3F0B:
 902         segment->index_edit_rate.num = avio_rb32(pb);
 903         segment->index_edit_rate.den = avio_rb32(pb);
 904         av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
 905                 segment->index_edit_rate.den);
 906         break;
 907     case 0x3F0C:
 908         segment->index_start_position = avio_rb64(pb);
 909         av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
 910         break;
 911     case 0x3F0D:
 912         segment->index_duration = avio_rb64(pb);
 913         av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration);
 914         break;
 915     }
 916     return 0;
 917 }
 918
 919 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
 920 {
 921     int code, value, ofs = 0;
 922     char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
 923
 924     do {
 925         code = avio_r8(pb);
 926         value = avio_r8(pb);
 927         av_dlog(NULL, "pixel layout: code %#x\n", code);
 928
 929         if (ofs <= 14) {
 930             layout[ofs++] = code;
 931             layout[ofs++] = value;
 932         } else
 933             break;  /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
 934     } while (code != 0); /* SMPTE 377M E.2.46 */
 935
 936     ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
 937 }
 938
 939 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 940 {
 941     MXFDescriptor *descriptor = arg;
 942     switch(tag) {
 943     case 0x3F01:
 944         descriptor->sub_descriptors_count = avio_rb32(pb);
 945         descriptor->sub_descriptors_refs = av_calloc(descriptor->sub_descriptors_count, sizeof(UID));
 946         if (!descriptor->sub_descriptors_refs)
 947             return AVERROR(ENOMEM);
 948         avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
 949         avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
 950         break;
 951     case 0x3002: /* ContainerDuration */
 952         descriptor->duration = avio_rb64(pb);
 953         break;
 954     case 0x3004:
 955         avio_read(pb, descriptor->essence_container_ul, 16);
 956         break;
 957     case 0x3006:
 958         descriptor->linked_track_id = avio_rb32(pb);
 959         break;
 960     case 0x3201: /* PictureEssenceCoding */
 961         avio_read(pb, descriptor->essence_codec_ul, 16);
 962         break;
 963     case 0x3203:
 964         descriptor->width = avio_rb32(pb);
 965         break;
 966     case 0x3202:
 967         descriptor->height = avio_rb32(pb);
 968         break;
 969     case 0x320C:
 970         descriptor->frame_layout = avio_r8(pb);
 971         break;
 972     case 0x320E:
 973         descriptor->aspect_ratio.num = avio_rb32(pb);
 974         descriptor->aspect_ratio.den = avio_rb32(pb);
 975         break;
 976     case 0x3212:
 977         descriptor->field_dominance = avio_r8(pb);
 978         break;
 979     case 0x3301:
 980         descriptor->component_depth = avio_rb32(pb);
 981         break;
 982     case 0x3302:
 983         descriptor->horiz_subsampling = avio_rb32(pb);
 984         break;
 985     case 0x3308:
 986         descriptor->vert_subsampling = avio_rb32(pb);
 987         break;
 988     case 0x3D03:
 989         descriptor->sample_rate.num = avio_rb32(pb);
 990         descriptor->sample_rate.den = avio_rb32(pb);
 991         break;
 992     case 0x3D06: /* SoundEssenceCompression */
 993         avio_read(pb, descriptor->essence_codec_ul, 16);
 994         break;
 995     case 0x3D07:
 996         descriptor->channels = avio_rb32(pb);
 997         break;
 998     case 0x3D01:
 999         descriptor->bits_per_sample = avio_rb32(pb);
1000         break;
1001     case 0x3401:
1002         mxf_read_pixel_layout(pb, descriptor);
1003         break;
1004     default:
1005         /* Private uid used by SONY C0023S01.mxf */
1006         if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
1007             if (descriptor->extradata)
1008                 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1009             av_free(descriptor->extradata);
1010             descriptor->extradata_size = 0;
1011             descriptor->extradata = av_malloc(size);
1012             if (!descriptor->extradata)
1013                 return AVERROR(ENOMEM);
1014             descriptor->extradata_size = size;
1015             avio_read(pb, descriptor->extradata, size);
1016         }
1017         break;
1018     }
1019     return 0;
1020 }
1021
1022 /*
1023  * Match an uid independently of the version byte and up to len common bytes
1024  * Returns: boolean
1025  */
1026 static int mxf_match_uid(const UID key, const UID uid, int len)
1027 {
1028     int i;
1029     for (i = 0; i < len; i++) {
1030         if (i != 7 && key[i] != uid[i])
1031             return 0;
1032     }
1033     return 1;
1034 }
1035
1036 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1037 {
1038     while (uls->uid[0]) {
1039         if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1040             break;
1041         uls++;
1042     }
1043     return uls;
1044 }
1045
1046 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1047 {
1048     int i;
1049
1050     if (!strong_ref)
1051         return NULL;
1052     for (i = 0; i < mxf->metadata_sets_count; i++) {
1053         if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
1054             (type == AnyType || mxf->metadata_sets[i]->type == type)) {
1055             return mxf->metadata_sets[i];
1056         }
1057     }
1058     return NULL;
1059 }
1060
1061 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1062     // video essence container uls
1063     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* MPEG-ES Frame wrapped */
1064     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14,    AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
1065     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14,   AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
1066     { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14,   AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1067     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,      AV_CODEC_ID_NONE },
1068 };
1069
1070 /* EC ULs for intra-only formats */
1071 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1072     { { 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 */
1073     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,       AV_CODEC_ID_NONE },
1074 };
1075
1076 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1077 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1078     { { 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 */
1079     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14,   AV_CODEC_ID_JPEG2000 }, /* JPEG2000 Codestream */
1080     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,       AV_CODEC_ID_NONE },
1081 };
1082
1083 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1084     // sound essence container uls
1085     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14, AV_CODEC_ID_PCM_S16LE }, /* BWF Frame wrapped */
1086     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14,       AV_CODEC_ID_MP2 }, /* MPEG-ES Frame wrapped, 0x40 ??? stream id */
1087     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14, AV_CODEC_ID_PCM_S16LE }, /* D-10 Mapping 50Mbps PAL Extended Template */
1088     { { 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 */
1089     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x03,0x04,0x02,0x02,0x02,0x03,0x03,0x01,0x00 }, 14,       AV_CODEC_ID_AAC }, /* MPEG2 AAC ADTS (legacy) */
1090     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,      AV_CODEC_ID_NONE },
1091 };
1092
1093 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1094     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, 0 },
1095     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0, AV_CODEC_ID_NONE },
1096 };
1097
1098 static const char* const mxf_data_essence_descriptor[] = {
1099     "vbi_vanc_smpte_436M",
1100 };
1101
1102 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1103 {
1104     int i, j, nb_segments = 0;
1105     MXFIndexTableSegment **unsorted_segments;
1106     int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1107
1108     /* count number of segments, allocate arrays and copy unsorted segments */
1109     for (i = 0; i < mxf->metadata_sets_count; i++)
1110         if (mxf->metadata_sets[i]->type == IndexTableSegment)
1111             nb_segments++;
1112
1113     if (!nb_segments)
1114         return AVERROR_INVALIDDATA;
1115
1116     if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1117         !(*sorted_segments  = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1118         av_freep(sorted_segments);
1119         av_free(unsorted_segments);
1120         return AVERROR(ENOMEM);
1121     }
1122
1123     for (i = j = 0; i < mxf->metadata_sets_count; i++)
1124         if (mxf->metadata_sets[i]->type == IndexTableSegment)
1125             unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1126
1127     *nb_sorted_segments = 0;
1128
1129     /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1130     for (i = 0; i < nb_segments; i++) {
1131         int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1132         uint64_t best_index_duration = 0;
1133
1134         for (j = 0; j < nb_segments; j++) {
1135             MXFIndexTableSegment *s = unsorted_segments[j];
1136
1137             /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1138              * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1139              * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1140              */
1141             if ((i == 0     || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
1142                 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
1143                 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
1144                 best             = j;
1145                 best_body_sid    = s->body_sid;
1146                 best_index_sid   = s->index_sid;
1147                 best_index_start = s->index_start_position;
1148                 best_index_duration = s->index_duration;
1149             }
1150         }
1151
1152         /* no suitable entry found -> we're done */
1153         if (best == -1)
1154             break;
1155
1156         (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1157         last_body_sid    = best_body_sid;
1158         last_index_sid   = best_index_sid;
1159         last_index_start = best_index_start;
1160     }
1161
1162     av_free(unsorted_segments);
1163
1164     return 0;
1165 }
1166
1167 /**
1168  * Computes the absolute file offset of the given essence container offset
1169  */
1170 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1171 {
1172     int x;
1173     int64_t offset_in = offset;     /* for logging */
1174
1175     for (x = 0; x < mxf->partitions_count; x++) {
1176         MXFPartition *p = &mxf->partitions[x];
1177
1178         if (p->body_sid != body_sid)
1179             continue;
1180
1181         if (offset < p->essence_length || !p->essence_length) {
1182             *offset_out = p->essence_offset + offset;
1183             return 0;
1184         }
1185
1186         offset -= p->essence_length;
1187     }
1188
1189     av_log(mxf->fc, AV_LOG_ERROR,
1190            "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1191            offset_in, body_sid);
1192
1193     return AVERROR_INVALIDDATA;
1194 }
1195
1196 /**
1197  * Returns the end position of the essence container with given BodySID, or zero if unknown
1198  */
1199 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1200 {
1201     int x;
1202     int64_t ret = 0;
1203
1204     for (x = 0; x < mxf->partitions_count; x++) {
1205         MXFPartition *p = &mxf->partitions[x];
1206
1207         if (p->body_sid != body_sid)
1208             continue;
1209
1210         if (!p->essence_length)
1211             return 0;
1212
1213         ret = p->essence_offset + p->essence_length;
1214     }
1215
1216     return ret;
1217 }
1218
1219 /* EditUnit -> absolute offset */
1220 static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, int64_t *edit_unit_out, int64_t *offset_out, int nag)
1221 {
1222     int i;
1223     int64_t offset_temp = 0;
1224
1225     for (i = 0; i < index_table->nb_segments; i++) {
1226         MXFIndexTableSegment *s = index_table->segments[i];
1227
1228         edit_unit = FFMAX(edit_unit, s->index_start_position);  /* clamp if trying to seek before start */
1229
1230         if (edit_unit < s->index_start_position + s->index_duration) {
1231             int64_t index = edit_unit - s->index_start_position;
1232
1233             if (s->edit_unit_byte_count)
1234                 offset_temp += s->edit_unit_byte_count * index;
1235             else if (s->nb_index_entries) {
1236                 if (s->nb_index_entries == 2 * s->index_duration + 1)
1237                     index *= 2;     /* Avid index */
1238
1239                 if (index < 0 || index >= s->nb_index_entries) {
1240                     av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1241                            index_table->index_sid, s->index_start_position);
1242                     return AVERROR_INVALIDDATA;
1243                 }
1244
1245                 offset_temp = s->stream_offset_entries[index];
1246             } else {
1247                 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1248                        index_table->index_sid, s->index_start_position);
1249                 return AVERROR_INVALIDDATA;
1250             }
1251
1252             if (edit_unit_out)
1253                 *edit_unit_out = edit_unit;
1254
1255             return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1256         } else {
1257             /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1258             offset_temp += s->edit_unit_byte_count * s->index_duration;
1259         }
1260     }
1261
1262     if (nag)
1263         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);
1264
1265     return AVERROR_INVALIDDATA;
1266 }
1267
1268 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1269 {
1270     int i, j, x;
1271     int8_t max_temporal_offset = -128;
1272
1273     /* first compute how many entries we have */
1274     for (i = 0; i < index_table->nb_segments; i++) {
1275         MXFIndexTableSegment *s = index_table->segments[i];
1276
1277         if (!s->nb_index_entries) {
1278             index_table->nb_ptses = 0;
1279             return 0;                               /* no TemporalOffsets */
1280         }
1281
1282         index_table->nb_ptses += s->index_duration;
1283     }
1284
1285     /* paranoid check */
1286     if (index_table->nb_ptses <= 0)
1287         return 0;
1288
1289     if (!(index_table->ptses      = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1290         !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1291         av_freep(&index_table->ptses);
1292         return AVERROR(ENOMEM);
1293     }
1294
1295     /* we may have a few bad TemporalOffsets
1296      * make sure the corresponding PTSes don't have the bogus value 0 */
1297     for (x = 0; x < index_table->nb_ptses; x++)
1298         index_table->ptses[x] = AV_NOPTS_VALUE;
1299
1300     /**
1301      * We have this:
1302      *
1303      * x  TemporalOffset
1304      * 0:  0
1305      * 1:  1
1306      * 2:  1
1307      * 3: -2
1308      * 4:  1
1309      * 5:  1
1310      * 6: -2
1311      *
1312      * We want to transform it into this:
1313      *
1314      * x  DTS PTS
1315      * 0: -1   0
1316      * 1:  0   3
1317      * 2:  1   1
1318      * 3:  2   2
1319      * 4:  3   6
1320      * 5:  4   4
1321      * 6:  5   5
1322      *
1323      * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1324      * then settings mxf->first_dts = -max(TemporalOffset[x]).
1325      * The latter makes DTS <= PTS.
1326      */
1327     for (i = x = 0; i < index_table->nb_segments; i++) {
1328         MXFIndexTableSegment *s = index_table->segments[i];
1329         int index_delta = 1;
1330         int n = s->nb_index_entries;
1331
1332         if (s->nb_index_entries == 2 * s->index_duration + 1) {
1333             index_delta = 2;    /* Avid index */
1334             /* ignore the last entry - it's the size of the essence container */
1335             n--;
1336         }
1337
1338         for (j = 0; j < n; j += index_delta, x++) {
1339             int offset = s->temporal_offset_entries[j] / index_delta;
1340             int index  = x + offset;
1341
1342             if (x >= index_table->nb_ptses) {
1343                 av_log(mxf->fc, AV_LOG_ERROR,
1344                        "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1345                        s->nb_index_entries, s->index_duration);
1346                 break;
1347             }
1348
1349             index_table->fake_index[x].timestamp = x;
1350             index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1351
1352             if (index < 0 || index >= index_table->nb_ptses) {
1353                 av_log(mxf->fc, AV_LOG_ERROR,
1354                        "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1355                        x, offset, index);
1356                 continue;
1357             }
1358
1359             index_table->ptses[index] = x;
1360             max_temporal_offset = FFMAX(max_temporal_offset, offset);
1361         }
1362     }
1363
1364     index_table->first_dts = -max_temporal_offset;
1365
1366     return 0;
1367 }
1368
1369 /**
1370  * Sorts and collects index table segments into index tables.
1371  * Also computes PTSes if possible.
1372  */
1373 static int mxf_compute_index_tables(MXFContext *mxf)
1374 {
1375     int i, j, k, ret, nb_sorted_segments;
1376     MXFIndexTableSegment **sorted_segments = NULL;
1377
1378     if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1379         nb_sorted_segments <= 0) {
1380         av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1381         return 0;
1382     }
1383
1384     /* sanity check and count unique BodySIDs/IndexSIDs */
1385     for (i = 0; i < nb_sorted_segments; i++) {
1386         if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1387             mxf->nb_index_tables++;
1388         else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1389             av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1390             ret = AVERROR_INVALIDDATA;
1391             goto finish_decoding_index;
1392         }
1393     }
1394
1395     mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1396                                          sizeof(*mxf->index_tables));
1397     if (!mxf->index_tables) {
1398         av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1399         ret = AVERROR(ENOMEM);
1400         goto finish_decoding_index;
1401     }
1402
1403     /* distribute sorted segments to index tables */
1404     for (i = j = 0; i < nb_sorted_segments; i++) {
1405         if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1406             /* next IndexSID */
1407             j++;
1408         }
1409
1410         mxf->index_tables[j].nb_segments++;
1411     }
1412
1413     for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1414         MXFIndexTable *t = &mxf->index_tables[j];
1415
1416         t->segments = av_mallocz_array(t->nb_segments,
1417                                        sizeof(*t->segments));
1418
1419         if (!t->segments) {
1420             av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1421                    " pointer array\n");
1422             ret = AVERROR(ENOMEM);
1423             goto finish_decoding_index;
1424         }
1425
1426         if (sorted_segments[i]->index_start_position)
1427             av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1428                    sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1429
1430         memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1431         t->index_sid = sorted_segments[i]->index_sid;
1432         t->body_sid = sorted_segments[i]->body_sid;
1433
1434         if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1435             goto finish_decoding_index;
1436
1437         /* fix zero IndexDurations */
1438         for (k = 0; k < t->nb_segments; k++) {
1439             if (t->segments[k]->index_duration)
1440                 continue;
1441
1442             if (t->nb_segments > 1)
1443                 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1444                        t->index_sid, k);
1445
1446             if (mxf->fc->nb_streams <= 0) {
1447                 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1448                 break;
1449             }
1450
1451             /* assume the first stream's duration is reasonable
1452              * leave index_duration = 0 on further segments in case we have any (unlikely)
1453              */
1454             t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1455             break;
1456         }
1457     }
1458
1459     ret = 0;
1460 finish_decoding_index:
1461     av_free(sorted_segments);
1462     return ret;
1463 }
1464
1465 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1466 {
1467     return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1468                             &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1469            mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1470                             &descriptor->essence_codec_ul)->id     != AV_CODEC_ID_NONE;
1471 }
1472
1473 static int mxf_uid_to_str(UID uid, char **str)
1474 {
1475     int i;
1476     char *p;
1477     p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1478     if (!p)
1479         return AVERROR(ENOMEM);
1480     for (i = 0; i < sizeof(UID); i++) {
1481         snprintf(p, 2 + 1, "%.2x", uid[i]);
1482         p += 2;
1483         if (i == 3 || i == 5 || i == 7 || i == 9) {
1484             snprintf(p, 1 + 1, "-");
1485             p++;
1486         }
1487     }
1488     return 0;
1489 }
1490
1491 static int mxf_add_uid_metadata(AVDictionary **pm, const char *key, UID uid)
1492 {
1493     char *str;
1494     int ret;
1495     if ((ret = mxf_uid_to_str(uid, &str)) < 0)
1496         return ret;
1497     av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1498     return 0;
1499 }
1500
1501 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1502 {
1503     char buf[AV_TIMECODE_STR_SIZE];
1504     av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1505
1506     return 0;
1507 }
1508
1509 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
1510 {
1511     MXFStructuralComponent *component = NULL;
1512     MXFPulldownComponent *pulldown = NULL;
1513
1514     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1515     if (!component)
1516         return NULL;
1517
1518     switch (component->type) {
1519     case TimecodeComponent:
1520         return (MXFTimecodeComponent*)component;
1521     case PulldownComponent: /* timcode component may be located on a pulldown component */
1522         pulldown = (MXFPulldownComponent*)component;
1523         return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
1524     default:
1525         break;
1526     }
1527     return NULL;
1528 }
1529
1530 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_uid)
1531 {
1532     MXFPackage *package = NULL;
1533     int i;
1534
1535     for (i = 0; i < mxf->packages_count; i++) {
1536         package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1537         if (!package)
1538             continue;
1539
1540         if (!memcmp(package->package_uid, package_uid, 16))
1541             return package;
1542     }
1543     return NULL;
1544 }
1545
1546 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1547 {
1548     MXFDescriptor *sub_descriptor = NULL;
1549     int i;
1550
1551     if (!descriptor)
1552         return NULL;
1553
1554     if (descriptor->type == MultipleDescriptor) {
1555         for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1556             sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1557
1558             if (!sub_descriptor) {
1559                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1560                 continue;
1561             }
1562             if (sub_descriptor->linked_track_id == track_id) {
1563                 return sub_descriptor;
1564             }
1565         }
1566     } else if (descriptor->type == Descriptor)
1567         return descriptor;
1568
1569     return NULL;
1570 }
1571
1572 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
1573 {
1574     MXFStructuralComponent *component = NULL;
1575     MXFPackage *package = NULL;
1576     MXFDescriptor *descriptor = NULL;
1577     int i;
1578
1579     if (!essence_group || !essence_group->structural_components_count)
1580         return NULL;
1581
1582     /* essence groups contains multiple representations of the same media,
1583        this return the first components with a valid Descriptor typically index 0 */
1584     for (i =0; i < essence_group->structural_components_count; i++){
1585         component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1586         if (!component)
1587             continue;
1588
1589         if (!(package = mxf_resolve_source_package(mxf, component->source_package_uid)))
1590             continue;
1591
1592         descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1593         if (descriptor)
1594             return component;
1595     }
1596     return NULL;
1597 }
1598
1599 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
1600 {
1601     MXFStructuralComponent *component = NULL;
1602
1603     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1604     if (!component)
1605         return NULL;
1606     switch (component->type) {
1607         case SourceClip:
1608             return component;
1609         case EssenceGroup:
1610             return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
1611         default:
1612             break;
1613     }
1614     return NULL;
1615 }
1616
1617 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
1618 {
1619     MXFPackage *physical_package = NULL;
1620     MXFTrack *physical_track = NULL;
1621     MXFStructuralComponent *sourceclip = NULL;
1622     MXFTimecodeComponent *mxf_tc = NULL;
1623     int i, j, k;
1624     AVTimecode tc;
1625     int flags;
1626     int64_t start_position;
1627
1628     for (i = 0; i < source_track->sequence->structural_components_count; i++) {
1629         sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
1630         if (!sourceclip)
1631             continue;
1632
1633         if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_uid)))
1634             break;
1635
1636         mxf_add_uid_metadata(&st->metadata, "reel_uid", physical_package->package_uid);
1637
1638         /* the name of physical source package is name of the reel or tape */
1639         if (physical_package->name && physical_package->name[0])
1640             av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
1641
1642         /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
1643          * to the start_frame of the timecode component located on one of the tracks of the physical source package.
1644          */
1645         for (j = 0; j < physical_package->tracks_count; j++) {
1646             if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
1647                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1648                 continue;
1649             }
1650
1651             if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
1652                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1653                 continue;
1654             }
1655
1656             for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
1657                 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
1658                     continue;
1659
1660                 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1661                 /* scale sourceclip start_position to match physical track edit rate */
1662                 start_position = av_rescale_q(sourceclip->start_position,
1663                                               physical_track->edit_rate,
1664                                               source_track->edit_rate);
1665
1666                 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
1667                     mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
1668                     return 0;
1669                 }
1670             }
1671         }
1672     }
1673
1674     return 0;
1675 }
1676
1677 static int mxf_parse_structural_metadata(MXFContext *mxf)
1678 {
1679     MXFPackage *material_package = NULL;
1680     int i, j, k, ret;
1681
1682     av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1683     /* TODO: handle multiple material packages (OP3x) */
1684     for (i = 0; i < mxf->packages_count; i++) {
1685         material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1686         if (material_package) break;
1687     }
1688     if (!material_package) {
1689         av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1690         return AVERROR_INVALIDDATA;
1691     }
1692
1693     mxf_add_uid_metadata(&mxf->fc->metadata, "material_package_uid", material_package->package_uid);
1694     if (material_package->name && material_package->name[0])
1695         av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
1696
1697     for (i = 0; i < material_package->tracks_count; i++) {
1698         MXFPackage *source_package = NULL;
1699         MXFTrack *material_track = NULL;
1700         MXFTrack *source_track = NULL;
1701         MXFTrack *temp_track = NULL;
1702         MXFDescriptor *descriptor = NULL;
1703         MXFStructuralComponent *component = NULL;
1704         MXFTimecodeComponent *mxf_tc = NULL;
1705         UID *essence_container_ul = NULL;
1706         const MXFCodecUL *codec_ul = NULL;
1707         const MXFCodecUL *container_ul = NULL;
1708         const MXFCodecUL *pix_fmt_ul = NULL;
1709         AVStream *st;
1710         AVTimecode tc;
1711         int flags;
1712
1713         if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1714             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1715             continue;
1716         }
1717
1718         if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1719             mxf_tc = (MXFTimecodeComponent*)component;
1720             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1721             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1722                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1723             }
1724         }
1725
1726         if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1727             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1728             continue;
1729         }
1730
1731         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1732             component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1733             if (!component)
1734                 continue;
1735
1736             mxf_tc = (MXFTimecodeComponent*)component;
1737             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1738             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1739                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1740                 break;
1741             }
1742         }
1743
1744         /* TODO: handle multiple source clips */
1745         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1746             component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
1747             if (!component)
1748                 continue;
1749
1750             source_package = mxf_resolve_source_package(mxf, component->source_package_uid);
1751             if (!source_package) {
1752                 av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1753                 break;
1754             }
1755             for (k = 0; k < source_package->tracks_count; k++) {
1756                 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1757                     av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1758                     ret = AVERROR_INVALIDDATA;
1759                     goto fail_and_free;
1760                 }
1761                 if (temp_track->track_id == component->source_track_id) {
1762                     source_track = temp_track;
1763                     break;
1764                 }
1765             }
1766             if (!source_track) {
1767                 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1768                 break;
1769             }
1770         }
1771         if (!source_track || !component)
1772             continue;
1773
1774         if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1775             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1776             ret = AVERROR_INVALIDDATA;
1777             goto fail_and_free;
1778         }
1779
1780         /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1781          * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1782         if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1783             av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1784             continue;
1785         }
1786
1787         st = avformat_new_stream(mxf->fc, NULL);
1788         if (!st) {
1789             av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1790             ret = AVERROR(ENOMEM);
1791             goto fail_and_free;
1792         }
1793         st->id = source_track->track_id;
1794         st->priv_data = source_track;
1795
1796         source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1797         descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
1798
1799         /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
1800          * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
1801         if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
1802             source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
1803         else
1804             source_track->original_duration = st->duration = component->duration;
1805
1806         if (st->duration == -1)
1807             st->duration = AV_NOPTS_VALUE;
1808         st->start_time = component->start_position;
1809         if (material_track->edit_rate.num <= 0 ||
1810             material_track->edit_rate.den <= 0) {
1811             av_log(mxf->fc, AV_LOG_WARNING,
1812                    "Invalid edit rate (%d/%d) found on stream #%d, "
1813                    "defaulting to 25/1\n",
1814                    material_track->edit_rate.num,
1815                    material_track->edit_rate.den, st->index);
1816             material_track->edit_rate = (AVRational){25, 1};
1817         }
1818         avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1819
1820         /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
1821          * the former is accessible via st->priv_data */
1822         source_track->edit_rate = material_track->edit_rate;
1823
1824         PRINT_KEY(mxf->fc, "data definition   ul", source_track->sequence->data_definition_ul);
1825         codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1826         st->codec->codec_type = codec_ul->id;
1827
1828         if (!descriptor) {
1829             av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1830             continue;
1831         }
1832         PRINT_KEY(mxf->fc, "essence codec     ul", descriptor->essence_codec_ul);
1833         PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1834         essence_container_ul = &descriptor->essence_container_ul;
1835         /* HACK: replacing the original key with mxf_encrypted_essence_container
1836          * is not allowed according to s429-6, try to find correct information anyway */
1837         if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1838             av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1839             for (k = 0; k < mxf->metadata_sets_count; k++) {
1840                 MXFMetadataSet *metadata = mxf->metadata_sets[k];
1841                 if (metadata->type == CryptoContext) {
1842                     essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1843                     break;
1844                 }
1845             }
1846         }
1847
1848         /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1849         codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1850         st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1851         av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
1852                avcodec_get_name(st->codec->codec_id));
1853         for (k = 0; k < 16; k++) {
1854             av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
1855                    descriptor->essence_codec_ul[k]);
1856             if (!(k+1 & 19) || k == 5)
1857                 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
1858         }
1859         av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1860
1861         mxf_add_uid_metadata(&st->metadata, "file_package_uid", source_package->package_uid);
1862         if (source_package->name && source_package->name[0])
1863             av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
1864
1865         mxf_parse_physical_source_package(mxf, source_track, st);
1866
1867         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1868             source_track->intra_only = mxf_is_intra_only(descriptor);
1869             container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1870             if (st->codec->codec_id == AV_CODEC_ID_NONE)
1871                 st->codec->codec_id = container_ul->id;
1872             st->codec->width = descriptor->width;
1873             st->codec->height = descriptor->height; /* Field height, not frame height */
1874             switch (descriptor->frame_layout) {
1875                 case SegmentedFrame:
1876                     /* This one is a weird layout I don't fully understand. */
1877                     av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1878                     break;
1879                 case FullFrame:
1880                     st->codec->field_order = AV_FIELD_PROGRESSIVE;
1881                     break;
1882                 case OneField:
1883                     /* Every other line is stored and needs to be duplicated. */
1884                     av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1885                     break; /* The correct thing to do here is fall through, but by breaking we might be
1886                               able to decode some streams at half the vertical resolution, rather than not al all.
1887                               It's also for compatibility with the old behavior. */
1888                 case MixedFields:
1889                     break;
1890                 case SeparateFields:
1891                     switch (descriptor->field_dominance) {
1892                     case MXF_TFF:
1893                         st->codec->field_order = AV_FIELD_TT;
1894                         break;
1895                     case MXF_BFF:
1896                         st->codec->field_order = AV_FIELD_BB;
1897                         break;
1898                     default:
1899                         avpriv_request_sample(mxf->fc,
1900                                               "Field dominance %d support",
1901                                               descriptor->field_dominance);
1902                     case 0: // we already have many samples with field_dominance == unknown
1903                         break;
1904                     }
1905                     /* Turn field height into frame height. */
1906                     st->codec->height *= 2;
1907                     break;
1908                 default:
1909                     av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1910             }
1911             if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1912                 st->codec->pix_fmt = descriptor->pix_fmt;
1913                 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1914                     pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1915                                                   &descriptor->essence_codec_ul);
1916                     st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1917                     if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1918                         /* support files created before RP224v10 by defaulting to UYVY422
1919                            if subsampling is 4:2:2 and component depth is 8-bit */
1920                         if (descriptor->horiz_subsampling == 2 &&
1921                             descriptor->vert_subsampling == 1 &&
1922                             descriptor->component_depth == 8) {
1923                             st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1924                         }
1925                     }
1926                 }
1927             }
1928             st->need_parsing = AVSTREAM_PARSE_HEADERS;
1929             if (material_track->sequence->origin) {
1930                 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
1931             }
1932             if (source_track->sequence->origin) {
1933                 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
1934             }
1935             if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
1936                 st->display_aspect_ratio = descriptor->aspect_ratio;
1937         } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1938             container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1939             /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1940             if (st->codec->codec_id == AV_CODEC_ID_NONE || (st->codec->codec_id == AV_CODEC_ID_PCM_ALAW && (enum AVCodecID)container_ul->id != AV_CODEC_ID_NONE))
1941                 st->codec->codec_id = (enum AVCodecID)container_ul->id;
1942             st->codec->channels = descriptor->channels;
1943             st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1944
1945             if (descriptor->sample_rate.den > 0) {
1946                 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1947                 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1948             } else {
1949                 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
1950                        "found for stream #%d, time base forced to 1/48000\n",
1951                        descriptor->sample_rate.num, descriptor->sample_rate.den,
1952                        st->index);
1953                 avpriv_set_pts_info(st, 64, 1, 48000);
1954             }
1955
1956             /* if duration is set, rescale it from EditRate to SampleRate */
1957             if (st->duration != AV_NOPTS_VALUE)
1958                 st->duration = av_rescale_q(st->duration,
1959                                             av_inv_q(material_track->edit_rate),
1960                                             st->time_base);
1961
1962             /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1963             if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1964                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1965                     st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1966                 else if (descriptor->bits_per_sample == 32)
1967                     st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1968             } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1969                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1970                     st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1971                 else if (descriptor->bits_per_sample == 32)
1972                     st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1973             } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1974                 st->need_parsing = AVSTREAM_PARSE_FULL;
1975             }
1976         } else if (st->codec->codec_type == AVMEDIA_TYPE_DATA) {
1977             int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls,
1978                                             essence_container_ul)->id;
1979             if (codec_id >= 0 &&
1980                 codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) {
1981                 av_dict_set(&st->metadata, "data_type",
1982                             mxf_data_essence_descriptor[codec_id], 0);
1983             }
1984         }
1985         if (descriptor->extradata) {
1986             if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) {
1987                 memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
1988             }
1989         } else if (st->codec->codec_id == AV_CODEC_ID_H264) {
1990             ret = ff_generate_avci_extradata(st);
1991             if (ret < 0)
1992                 return ret;
1993         }
1994         if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1995             /* TODO: decode timestamps */
1996             st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
1997         }
1998     }
1999
2000     ret = 0;
2001 fail_and_free:
2002     return ret;
2003 }
2004
2005 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
2006 {
2007     struct tm time = { 0 };
2008     time.tm_year = (timestamp >> 48) - 1900;
2009     time.tm_mon  = (timestamp >> 40 & 0xFF) - 1;
2010     time.tm_mday = (timestamp >> 32 & 0xFF);
2011     time.tm_hour = (timestamp >> 24 & 0xFF);
2012     time.tm_min  = (timestamp >> 16 & 0xFF);
2013     time.tm_sec  = (timestamp >> 8  & 0xFF);
2014
2015     /* msvcrt versions of strftime calls the invalid parameter handler
2016      * (aborting the process if one isn't set) if the parameters are out
2017      * of range. */
2018     time.tm_mon  = av_clip(time.tm_mon,  0, 11);
2019     time.tm_mday = av_clip(time.tm_mday, 1, 31);
2020     time.tm_hour = av_clip(time.tm_hour, 0, 23);
2021     time.tm_min  = av_clip(time.tm_min,  0, 59);
2022     time.tm_sec  = av_clip(time.tm_sec,  0, 59);
2023
2024     *str = av_mallocz(32);
2025     if (!*str)
2026         return AVERROR(ENOMEM);
2027     if (!strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time))
2028         str[0] = '\0';
2029
2030     return 0;
2031 }
2032
2033 #define SET_STR_METADATA(pb, name, str) do { \
2034     if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
2035         return ret; \
2036     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2037 } while (0)
2038
2039 #define SET_UID_METADATA(pb, name, var, str) do { \
2040     avio_read(pb, var, 16); \
2041     if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2042         return ret; \
2043     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2044 } while (0)
2045
2046 #define SET_TS_METADATA(pb, name, var, str) do { \
2047     var = avio_rb64(pb); \
2048     if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
2049         return ret; \
2050     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2051 } while (0)
2052
2053 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2054 {
2055     MXFContext *mxf = arg;
2056     AVFormatContext *s = mxf->fc;
2057     int ret;
2058     UID uid = { 0 };
2059     char *str = NULL;
2060     uint64_t ts;
2061     switch (tag) {
2062     case 0x3C01:
2063         SET_STR_METADATA(pb, "company_name", str);
2064         break;
2065     case 0x3C02:
2066         SET_STR_METADATA(pb, "product_name", str);
2067         break;
2068     case 0x3C04:
2069         SET_STR_METADATA(pb, "product_version", str);
2070         break;
2071     case 0x3C05:
2072         SET_UID_METADATA(pb, "product_uid", uid, str);
2073         break;
2074     case 0x3C06:
2075         SET_TS_METADATA(pb, "modification_date", ts, str);
2076         break;
2077     case 0x3C08:
2078         SET_STR_METADATA(pb, "application_platform", str);
2079         break;
2080     case 0x3C09:
2081         SET_UID_METADATA(pb, "generation_uid", uid, str);
2082         break;
2083     case 0x3C0A:
2084         SET_UID_METADATA(pb, "uid", uid, str);
2085         break;
2086     }
2087     return 0;
2088 }
2089
2090 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2091     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2092     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2093     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2094     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2095     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2096     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2097     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2098     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2099     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2100     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2101     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2102     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2103     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2104     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2105     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2106     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2107     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2108     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2109     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2110     { { 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 */
2111     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2112     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2113     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG 2 Video */
2114     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2115     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2116     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2117     { { 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 */
2118     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2119     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2120     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2121     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2122     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2123     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2124     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2125     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2126 };
2127
2128 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2129 {
2130     switch (type){
2131     case MultipleDescriptor:
2132     case Descriptor:
2133         ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2134         ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2135         break;
2136     default:
2137         break;
2138     }
2139     return 0;
2140 }
2141
2142 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2143 {
2144     AVIOContext *pb = mxf->fc->pb;
2145     MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2146     uint64_t klv_end = avio_tell(pb) + klv->length;
2147
2148     if (!ctx)
2149         return AVERROR(ENOMEM);
2150     mxf_metadataset_init(ctx, type);
2151     while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2152         int ret;
2153         int tag = avio_rb16(pb);
2154         int size = avio_rb16(pb); /* KLV specified by 0x53 */
2155         uint64_t next = avio_tell(pb) + size;
2156         UID uid = {0};
2157
2158         av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
2159         if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2160             av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2161             continue;
2162         }
2163         if (tag > 0x7FFF) { /* dynamic tag */
2164             int i;
2165             for (i = 0; i < mxf->local_tags_count; i++) {
2166                 int local_tag = AV_RB16(mxf->local_tags+i*18);
2167                 if (local_tag == tag) {
2168                     memcpy(uid, mxf->local_tags+i*18+2, 16);
2169                     av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
2170                     PRINT_KEY(mxf->fc, "uid", uid);
2171                 }
2172             }
2173         }
2174         if (ctx_size && tag == 0x3C0A) {
2175             avio_read(pb, ctx->uid, 16);
2176         } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2177             mxf_free_metadataset(&ctx);
2178             return ret;
2179         }
2180
2181         /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2182          * it extending past the end of the KLV though (zzuf5.mxf). */
2183         if (avio_tell(pb) > klv_end) {
2184             if (ctx_size) {
2185                 ctx->type = type;
2186                 mxf_free_metadataset(&ctx);
2187             }
2188
2189             av_log(mxf->fc, AV_LOG_ERROR,
2190                    "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2191                    tag, klv->offset);
2192             return AVERROR_INVALIDDATA;
2193         } else if (avio_tell(pb) <= next)   /* only seek forward, else this can loop for a long time */
2194             avio_seek(pb, next, SEEK_SET);
2195     }
2196     if (ctx_size) ctx->type = type;
2197     return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2198 }
2199
2200 /**
2201  * Matches any partition pack key, in other words:
2202  * - HeaderPartition
2203  * - BodyPartition
2204  * - FooterPartition
2205  * @return non-zero if the key is a partition pack key, zero otherwise
2206  */
2207 static int mxf_is_partition_pack_key(UID key)
2208 {
2209     //NOTE: this is a little lax since it doesn't constraint key[14]
2210     return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2211             key[13] >= 2 && key[13] <= 4;
2212 }
2213
2214 /**
2215  * Parses a metadata KLV
2216  * @return <0 on error, 0 otherwise
2217  */
2218 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2219                                      int ctx_size, enum MXFMetadataSetType type)
2220 {
2221     AVFormatContext *s = mxf->fc;
2222     int res;
2223     if (klv.key[5] == 0x53) {
2224         res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2225     } else {
2226         uint64_t next = avio_tell(s->pb) + klv.length;
2227         res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2228
2229         /* only seek forward, else this can loop for a long time */
2230         if (avio_tell(s->pb) > next) {
2231             av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2232                    klv.offset);
2233             return AVERROR_INVALIDDATA;
2234         }
2235
2236         avio_seek(s->pb, next, SEEK_SET);
2237     }
2238     if (res < 0) {
2239         av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2240         return res;
2241     }
2242     return 0;
2243 }
2244
2245 /**
2246  * Seeks to the previous partition and parses it, if possible
2247  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2248  */
2249 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2250 {
2251     AVIOContext *pb = mxf->fc->pb;
2252     KLVPacket klv;
2253     int64_t current_partition_ofs;
2254     int ret;
2255
2256     if (!mxf->current_partition ||
2257         mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2258         return 0;   /* we've parsed all partitions */
2259
2260     /* seek to previous partition */
2261     current_partition_ofs = mxf->current_partition->pack_ofs;   //includes run-in
2262     avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2263     mxf->current_partition = NULL;
2264
2265     av_dlog(mxf->fc, "seeking to previous partition\n");
2266
2267     /* Make sure this is actually a PartitionPack, and if so parse it.
2268      * See deadlock2.mxf
2269      */
2270     if ((ret = klv_read_packet(&klv, pb)) < 0) {
2271         av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2272         return ret;
2273     }
2274
2275     if (!mxf_is_partition_pack_key(klv.key)) {
2276         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2277         return AVERROR_INVALIDDATA;
2278     }
2279
2280     /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2281      * can point to just before the current partition, causing klv_read_packet()
2282      * to sync back up to it. See deadlock3.mxf
2283      */
2284     if (klv.offset >= current_partition_ofs) {
2285         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2286                PRIx64 " indirectly points to itself\n", current_partition_ofs);
2287         return AVERROR_INVALIDDATA;
2288     }
2289
2290     if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2291         return ret;
2292
2293     return 1;
2294 }
2295
2296 /**
2297  * Called when essence is encountered
2298  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2299  */
2300 static int mxf_parse_handle_essence(MXFContext *mxf)
2301 {
2302     AVIOContext *pb = mxf->fc->pb;
2303     int64_t ret;
2304
2305     if (mxf->parsing_backward) {
2306         return mxf_seek_to_previous_partition(mxf);
2307     } else {
2308         if (!mxf->footer_partition) {
2309             av_dlog(mxf->fc, "no FooterPartition\n");
2310             return 0;
2311         }
2312
2313         av_dlog(mxf->fc, "seeking to FooterPartition\n");
2314
2315         /* remember where we were so we don't end up seeking further back than this */
2316         mxf->last_forward_tell = avio_tell(pb);
2317
2318         if (!pb->seekable) {
2319             av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2320             return -1;
2321         }
2322
2323         /* seek to FooterPartition and parse backward */
2324         if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2325             av_log(mxf->fc, AV_LOG_ERROR,
2326                    "failed to seek to FooterPartition @ 0x%" PRIx64
2327                    " (%"PRId64") - partial file?\n",
2328                    mxf->run_in + mxf->footer_partition, ret);
2329             return ret;
2330         }
2331
2332         mxf->current_partition = NULL;
2333         mxf->parsing_backward = 1;
2334     }
2335
2336     return 1;
2337 }
2338
2339 /**
2340  * Called when the next partition or EOF is encountered
2341  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2342  */
2343 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2344 {
2345     return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2346 }
2347
2348 /**
2349  * Figures out the proper offset and length of the essence container in each partition
2350  */
2351 static void mxf_compute_essence_containers(MXFContext *mxf)
2352 {
2353     int x;
2354
2355     /* everything is already correct */
2356     if (mxf->op == OPAtom)
2357         return;
2358
2359     for (x = 0; x < mxf->partitions_count; x++) {
2360         MXFPartition *p = &mxf->partitions[x];
2361
2362         if (!p->body_sid)
2363             continue;       /* BodySID == 0 -> no essence */
2364
2365         if (x >= mxf->partitions_count - 1)
2366             break;          /* FooterPartition - can't compute length (and we don't need to) */
2367
2368         /* essence container spans to the next partition */
2369         p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2370
2371         if (p->essence_length < 0) {
2372             /* next ThisPartition < essence_offset */
2373             p->essence_length = 0;
2374             av_log(mxf->fc, AV_LOG_ERROR,
2375                    "partition %i: bad ThisPartition = %"PRIX64"\n",
2376                    x+1, mxf->partitions[x+1].this_partition);
2377         }
2378     }
2379 }
2380
2381 static int64_t round_to_kag(int64_t position, int kag_size)
2382 {
2383     /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2384     /* NOTE: kag_size may be any integer between 1 - 2^10 */
2385     int64_t ret = (position / kag_size) * kag_size;
2386     return ret == position ? ret : ret + kag_size;
2387 }
2388
2389 static int is_pcm(enum AVCodecID codec_id)
2390 {
2391     /* we only care about "normal" PCM codecs until we get samples */
2392     return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2393 }
2394
2395 /**
2396  * Deal with the case where for some audio atoms EditUnitByteCount is
2397  * very small (2, 4..). In those cases we should read more than one
2398  * sample per call to mxf_read_packet().
2399  */
2400 static void mxf_handle_small_eubc(AVFormatContext *s)
2401 {
2402     MXFContext *mxf = s->priv_data;
2403
2404     /* assuming non-OPAtom == frame wrapped
2405      * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2406     if (mxf->op != OPAtom)
2407         return;
2408
2409     /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2410     if (s->nb_streams != 1                                     ||
2411         s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
2412         !is_pcm(s->streams[0]->codec->codec_id)                ||
2413         mxf->nb_index_tables != 1                              ||
2414         mxf->index_tables[0].nb_segments != 1                  ||
2415         mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2416         return;
2417
2418     /* arbitrarily default to 48 kHz PAL audio frame size */
2419     /* TODO: We could compute this from the ratio between the audio
2420      *       and video edit rates for 48 kHz NTSC we could use the
2421      *       1802-1802-1802-1802-1801 pattern. */
2422     mxf->edit_units_per_packet = 1920;
2423 }
2424
2425 static void mxf_read_random_index_pack(AVFormatContext *s)
2426 {
2427     MXFContext *mxf = s->priv_data;
2428     uint32_t length;
2429     int64_t file_size, max_rip_length, min_rip_length;
2430     KLVPacket klv;
2431
2432     if (!s->pb->seekable)
2433         return;
2434
2435     file_size = avio_size(s->pb);
2436
2437     /* S377m says to check the RIP length for "silly" values, without defining "silly".
2438      * The limit below assumes a file with nothing but partition packs and a RIP.
2439      * Before changing this, consider that a muxer may place each sample in its own partition.
2440      *
2441      * 105 is the size of the smallest possible PartitionPack
2442      * 12 is the size of each RIP entry
2443      * 28 is the size of the RIP header and footer, assuming an 8-byte BER
2444      */
2445     max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
2446     max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
2447
2448     /* We're only interested in RIPs with at least two entries.. */
2449     min_rip_length = 16+1+24+4;
2450
2451     /* See S377m section 11 */
2452     avio_seek(s->pb, file_size - 4, SEEK_SET);
2453     length = avio_rb32(s->pb);
2454
2455     if (length < min_rip_length || length > max_rip_length)
2456         goto end;
2457     avio_seek(s->pb, file_size - length, SEEK_SET);
2458     if (klv_read_packet(&klv, s->pb) < 0 ||
2459         !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2460         klv.length != length - 20)
2461         goto end;
2462
2463     avio_skip(s->pb, klv.length - 12);
2464     mxf->footer_partition = avio_rb64(s->pb);
2465
2466     /* sanity check */
2467     if (mxf->run_in + mxf->footer_partition >= file_size) {
2468         av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
2469         mxf->footer_partition = 0;
2470     }
2471
2472 end:
2473     avio_seek(s->pb, mxf->run_in, SEEK_SET);
2474 }
2475
2476 static int mxf_read_header(AVFormatContext *s)
2477 {
2478     MXFContext *mxf = s->priv_data;
2479     KLVPacket klv;
2480     int64_t essence_offset = 0;
2481     int ret;
2482
2483     mxf->last_forward_tell = INT64_MAX;
2484     mxf->edit_units_per_packet = 1;
2485
2486     if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2487         av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2488         return AVERROR_INVALIDDATA;
2489     }
2490     avio_seek(s->pb, -14, SEEK_CUR);
2491     mxf->fc = s;
2492     mxf->run_in = avio_tell(s->pb);
2493
2494     mxf_read_random_index_pack(s);
2495
2496     while (!avio_feof(s->pb)) {
2497         const MXFMetadataReadTableEntry *metadata;
2498
2499         if (klv_read_packet(&klv, s->pb) < 0) {
2500             /* EOF - seek to previous partition or stop */
2501             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2502                 break;
2503             else
2504                 continue;
2505         }
2506
2507         PRINT_KEY(s, "read header", klv.key);
2508         av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2509         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2510             IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2511             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2512             IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2513
2514             if (!mxf->current_partition) {
2515                 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2516                 return AVERROR_INVALIDDATA;
2517             }
2518
2519             if (!mxf->current_partition->essence_offset) {
2520                 /* for OP1a we compute essence_offset
2521                  * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2522                  * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2523                  *       for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2524                  */
2525                 int64_t op1a_essence_offset =
2526                     round_to_kag(mxf->current_partition->this_partition +
2527                                  mxf->current_partition->pack_length,       mxf->current_partition->kag_size) +
2528                     round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2529                     round_to_kag(mxf->current_partition->index_byte_count,  mxf->current_partition->kag_size);
2530
2531                 if (mxf->op == OPAtom) {
2532                     /* point essence_offset to the actual data
2533                     * OPAtom has all the essence in one big KLV
2534                     */
2535                     mxf->current_partition->essence_offset = avio_tell(s->pb);
2536                     mxf->current_partition->essence_length = klv.length;
2537                 } else {
2538                     /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf)  */
2539                     mxf->current_partition->essence_offset = op1a_essence_offset;
2540                 }
2541             }
2542
2543             if (!essence_offset)
2544                 essence_offset = klv.offset;
2545
2546             /* seek to footer, previous partition or stop */
2547             if (mxf_parse_handle_essence(mxf) <= 0)
2548                 break;
2549             continue;
2550         } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
2551             /* next partition pack - keep going, seek to previous partition or stop */
2552             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2553                 break;
2554             else if (mxf->parsing_backward)
2555                 continue;
2556             /* we're still parsing forward. proceed to parsing this partition pack */
2557         }
2558
2559         for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2560             if (IS_KLV_KEY(klv.key, metadata->key)) {
2561                 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
2562                     goto fail;
2563                 break;
2564             } else {
2565                 av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
2566                        UID_ARG(klv.key));
2567             }
2568         }
2569         if (!metadata->read)
2570             avio_skip(s->pb, klv.length);
2571     }
2572     /* FIXME avoid seek */
2573     if (!essence_offset)  {
2574         av_log(s, AV_LOG_ERROR, "no essence\n");
2575         ret = AVERROR_INVALIDDATA;
2576         goto fail;
2577     }
2578     avio_seek(s->pb, essence_offset, SEEK_SET);
2579
2580     mxf_compute_essence_containers(mxf);
2581
2582     /* we need to do this before computing the index tables
2583      * to be able to fill in zero IndexDurations with st->duration */
2584     if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2585         goto fail;
2586
2587     if ((ret = mxf_compute_index_tables(mxf)) < 0)
2588         goto fail;
2589
2590     if (mxf->nb_index_tables > 1) {
2591         /* TODO: look up which IndexSID to use via EssenceContainerData */
2592         av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2593                mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2594     } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2595         av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2596         ret = AVERROR_INVALIDDATA;
2597         goto fail;
2598     }
2599
2600     mxf_handle_small_eubc(s);
2601
2602     return 0;
2603 fail:
2604     mxf_read_close(s);
2605
2606     return ret;
2607 }
2608
2609 /**
2610  * Sets mxf->current_edit_unit based on what offset we're currently at.
2611  * @return next_ofs if OK, <0 on error
2612  */
2613 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2614 {
2615     int64_t last_ofs = -1, next_ofs = -1;
2616     MXFIndexTable *t = &mxf->index_tables[0];
2617
2618     /* this is called from the OP1a demuxing logic, which means there
2619      * may be no index tables */
2620     if (mxf->nb_index_tables <= 0)
2621         return -1;
2622
2623     /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2624     while (mxf->current_edit_unit >= 0) {
2625         if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2626             return -1;
2627
2628         if (next_ofs <= last_ofs) {
2629             /* large next_ofs didn't change or current_edit_unit wrapped
2630              * around this fixes the infinite loop on zzuf3.mxf */
2631             av_log(mxf->fc, AV_LOG_ERROR,
2632                    "next_ofs didn't change. not deriving packet timestamps\n");
2633             return -1;
2634         }
2635
2636         if (next_ofs > current_offset)
2637             break;
2638
2639         last_ofs = next_ofs;
2640         mxf->current_edit_unit++;
2641     }
2642
2643     /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2644     if (mxf->current_edit_unit < 0)
2645         return -1;
2646
2647     return next_ofs;
2648 }
2649
2650 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
2651                                     uint64_t *sample_count)
2652 {
2653     int i, total = 0, size = 0;
2654     AVStream *st = mxf->fc->streams[stream_index];
2655     MXFTrack *track = st->priv_data;
2656     AVRational time_base = av_inv_q(track->edit_rate);
2657     AVRational sample_rate = av_inv_q(st->time_base);
2658     const MXFSamplesPerFrame *spf = NULL;
2659
2660     if ((sample_rate.num / sample_rate.den) == 48000)
2661         spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2662     if (!spf) {
2663         int remainder = (sample_rate.num * time_base.num) %
2664                         (time_base.den * sample_rate.den);
2665         *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2666                                         av_mul_q(sample_rate, time_base)));
2667         if (remainder)
2668             av_log(mxf->fc, AV_LOG_WARNING,
2669                    "seeking detected on stream #%d with time base (%d/%d) and "
2670                    "sample rate (%d/%d), audio pts won't be accurate.\n",
2671                    stream_index, time_base.num, time_base.den,
2672                    sample_rate.num, sample_rate.den);
2673         return 0;
2674     }
2675
2676     while (spf->samples_per_frame[size]) {
2677         total += spf->samples_per_frame[size];
2678         size++;
2679     }
2680
2681     av_assert2(size);
2682
2683     *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2684     for (i = 0; i < mxf->current_edit_unit % size; i++) {
2685         *sample_count += spf->samples_per_frame[i];
2686     }
2687
2688     return 0;
2689 }
2690
2691 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec,
2692                              AVPacket *pkt)
2693 {
2694     MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2695     int64_t bits_per_sample = codec->bits_per_coded_sample;
2696
2697     if (!bits_per_sample)
2698         bits_per_sample = av_get_bits_per_sample(codec->codec_id);
2699
2700     pkt->pts = track->sample_count;
2701
2702     if (   codec->channels <= 0
2703         || bits_per_sample <= 0
2704         || codec->channels * (int64_t)bits_per_sample < 8)
2705         return AVERROR(EINVAL);
2706     track->sample_count += pkt->size / (codec->channels * (int64_t)bits_per_sample / 8);
2707     return 0;
2708 }
2709
2710 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2711 {
2712     KLVPacket klv;
2713     MXFContext *mxf = s->priv_data;
2714     int ret;
2715
2716     while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
2717         PRINT_KEY(s, "read packet", klv.key);
2718         av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2719         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2720             ret = mxf_decrypt_triplet(s, pkt, &klv);
2721             if (ret < 0) {
2722                 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2723                 return ret;
2724             }
2725             return 0;
2726         }
2727         if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2728             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2729             int index = mxf_get_stream_index(s, &klv);
2730             int64_t next_ofs, next_klv;
2731             AVStream *st;
2732             MXFTrack *track;
2733             AVCodecContext *codec;
2734
2735             if (index < 0) {
2736                 av_log(s, AV_LOG_ERROR,
2737                        "error getting stream index %"PRIu32"\n",
2738                        AV_RB32(klv.key + 12));
2739                 goto skip;
2740             }
2741
2742             st = s->streams[index];
2743             track = st->priv_data;
2744
2745             if (s->streams[index]->discard == AVDISCARD_ALL)
2746                 goto skip;
2747
2748             next_klv = avio_tell(s->pb) + klv.length;
2749             next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2750
2751             if (next_ofs >= 0 && next_klv > next_ofs) {
2752                 /* if this check is hit then it's possible OPAtom was treated as OP1a
2753                  * truncate the packet since it's probably very large (>2 GiB is common) */
2754                 avpriv_request_sample(s,
2755                                       "OPAtom misinterpreted as OP1a?"
2756                                       "KLV for edit unit %i extending into "
2757                                       "next edit unit",
2758                                       mxf->current_edit_unit);
2759                 klv.length = next_ofs - avio_tell(s->pb);
2760             }
2761
2762             /* check for 8 channels AES3 element */
2763             if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2764                 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
2765                                               pkt, klv.length);
2766                 if (ret < 0) {
2767                     av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2768                     return ret;
2769                 }
2770             } else {
2771                 ret = av_get_packet(s->pb, pkt, klv.length);
2772                 if (ret < 0)
2773                     return ret;
2774             }
2775             pkt->stream_index = index;
2776             pkt->pos = klv.offset;
2777
2778             codec = st->codec;
2779
2780             if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2781                 /* mxf->current_edit_unit good - see if we have an
2782                  * index table to derive timestamps from */
2783                 MXFIndexTable *t = &mxf->index_tables[0];
2784
2785                 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2786                     pkt->dts = mxf->current_edit_unit + t->first_dts;
2787                     pkt->pts = t->ptses[mxf->current_edit_unit];
2788                 } else if (track->intra_only) {
2789                     /* intra-only -> PTS = EditUnit.
2790                      * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2791                     pkt->pts = mxf->current_edit_unit;
2792                 }
2793             } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2794                 ret = mxf_set_audio_pts(mxf, codec, pkt);
2795                 if (ret < 0)
2796                     return ret;
2797             }
2798
2799             /* seek for truncated packets */
2800             avio_seek(s->pb, next_klv, SEEK_SET);
2801
2802             return 0;
2803         } else
2804         skip:
2805             avio_skip(s->pb, klv.length);
2806     }
2807     return avio_feof(s->pb) ? AVERROR_EOF : ret;
2808 }
2809
2810 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2811 {
2812     MXFContext *mxf = s->priv_data;
2813     int ret, size;
2814     int64_t ret64, pos, next_pos;
2815     AVStream *st;
2816     MXFIndexTable *t;
2817     int edit_units;
2818
2819     if (mxf->op != OPAtom)
2820         return mxf_read_packet_old(s, pkt);
2821
2822     /* OPAtom - clip wrapped demuxing */
2823     /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2824     st = s->streams[0];
2825     t = &mxf->index_tables[0];
2826
2827     if (mxf->current_edit_unit >= st->duration)
2828         return AVERROR_EOF;
2829
2830     edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2831
2832     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2833         return ret;
2834
2835     /* compute size by finding the next edit unit or the end of the essence container
2836      * not pretty, but it works */
2837     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2838         (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2839         av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2840         return AVERROR_INVALIDDATA;
2841     }
2842
2843     if ((size = next_pos - pos) <= 0) {
2844         av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2845         return AVERROR_INVALIDDATA;
2846     }
2847
2848     if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2849         return ret64;
2850
2851     if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2852         return size;
2853
2854     pkt->stream_index = 0;
2855
2856     if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2857         mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2858         pkt->dts = mxf->current_edit_unit + t->first_dts;
2859         pkt->pts = t->ptses[mxf->current_edit_unit];
2860     } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2861         int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2862         if (ret < 0)
2863             return ret;
2864     }
2865
2866     mxf->current_edit_unit += edit_units;
2867
2868     return 0;
2869 }
2870
2871 static int mxf_read_close(AVFormatContext *s)
2872 {
2873     MXFContext *mxf = s->priv_data;
2874     int i;
2875
2876     av_freep(&mxf->packages_refs);
2877
2878     for (i = 0; i < s->nb_streams; i++)
2879         s->streams[i]->priv_data = NULL;
2880
2881     for (i = 0; i < mxf->metadata_sets_count; i++) {
2882         mxf_free_metadataset(mxf->metadata_sets + i);
2883     }
2884     av_freep(&mxf->partitions);
2885     av_freep(&mxf->metadata_sets);
2886     av_freep(&mxf->aesc);
2887     av_freep(&mxf->local_tags);
2888
2889     if (mxf->index_tables) {
2890         for (i = 0; i < mxf->nb_index_tables; i++) {
2891             av_freep(&mxf->index_tables[i].segments);
2892             av_freep(&mxf->index_tables[i].ptses);
2893             av_freep(&mxf->index_tables[i].fake_index);
2894         }
2895     }
2896     av_freep(&mxf->index_tables);
2897
2898     return 0;
2899 }
2900
2901 static int mxf_probe(AVProbeData *p) {
2902     const uint8_t *bufp = p->buf;
2903     const uint8_t *end = p->buf + p->buf_size;
2904
2905     if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2906         return 0;
2907
2908     /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2909     end -= sizeof(mxf_header_partition_pack_key);
2910
2911     for (; bufp < end;) {
2912         if (!((bufp[13] - 1) & 0xF2)){
2913             if (AV_RN32(bufp   ) == AV_RN32(mxf_header_partition_pack_key   ) &&
2914                 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
2915                 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
2916                 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
2917                 return AVPROBE_SCORE_MAX;
2918             bufp ++;
2919         } else
2920             bufp += 10;
2921     }
2922
2923     return 0;
2924 }
2925
2926 /* rudimentary byte seek */
2927 /* XXX: use MXF Index */
2928 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2929 {
2930     AVStream *st = s->streams[stream_index];
2931     int64_t seconds;
2932     MXFContext* mxf = s->priv_data;
2933     int64_t seekpos;
2934     int i, ret;
2935     MXFIndexTable *t;
2936     MXFTrack *source_track = st->priv_data;
2937
2938     /* if audio then truncate sample_time to EditRate */
2939     if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2940         sample_time = av_rescale_q(sample_time, st->time_base,
2941                                    av_inv_q(source_track->edit_rate));
2942
2943     if (mxf->nb_index_tables <= 0) {
2944     if (!s->bit_rate)
2945         return AVERROR_INVALIDDATA;
2946     if (sample_time < 0)
2947         sample_time = 0;
2948     seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2949
2950     seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
2951     if (seekpos < 0)
2952         return seekpos;
2953
2954     ff_update_cur_dts(s, st, sample_time);
2955     mxf->current_edit_unit = sample_time;
2956     } else {
2957         t = &mxf->index_tables[0];
2958
2959         /* clamp above zero, else ff_index_search_timestamp() returns negative
2960          * this also means we allow seeking before the start */
2961         sample_time = FFMAX(sample_time, 0);
2962
2963         if (t->fake_index) {
2964             /* behave as if we have a proper index */
2965             if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2966                 return sample_time;
2967         } else {
2968             /* no IndexEntryArray (one or more CBR segments)
2969              * make sure we don't seek past the end */
2970             sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2971         }
2972
2973         if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
2974             return ret;
2975
2976         ff_update_cur_dts(s, st, sample_time);
2977         mxf->current_edit_unit = sample_time;
2978         avio_seek(s->pb, seekpos, SEEK_SET);
2979     }
2980
2981     // Update all tracks sample count
2982     for (i = 0; i < s->nb_streams; i++) {
2983         AVStream *cur_st = s->streams[i];
2984         MXFTrack *cur_track = cur_st->priv_data;
2985         uint64_t current_sample_count = 0;
2986         if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2987             ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
2988             if (ret < 0)
2989                 return ret;
2990
2991             cur_track->sample_count = current_sample_count;
2992         }
2993     }
2994     return 0;
2995 }
2996
2997 AVInputFormat ff_mxf_demuxer = {
2998     .name           = "mxf",
2999     .long_name      = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3000     .priv_data_size = sizeof(MXFContext),
3001     .read_probe     = mxf_probe,
3002     .read_header    = mxf_read_header,
3003     .read_packet    = mxf_read_packet,
3004     .read_close     = mxf_read_close,
3005     .read_seek      = mxf_read_seek,
3006 };