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