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