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