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