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