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

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