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