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