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