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

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