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

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