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

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