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