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