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 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1149     // sound essence container uls
1150     { { 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 */
1151     { { 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 */
1152     { { 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 */
1153     { { 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 */
1154     { { 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) */
1155     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,      AV_CODEC_ID_NONE },
1156 };
1157
1158 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1159     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, 0 },
1160     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0, AV_CODEC_ID_NONE },
1161 };
1162
1163 static const char* const mxf_data_essence_descriptor[] = {
1164     "vbi_vanc_smpte_436M",
1165 };
1166
1167 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1168 {
1169     int i, j, nb_segments = 0;
1170     MXFIndexTableSegment **unsorted_segments;
1171     int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1172
1173     /* count number of segments, allocate arrays and copy unsorted segments */
1174     for (i = 0; i < mxf->metadata_sets_count; i++)
1175         if (mxf->metadata_sets[i]->type == IndexTableSegment)
1176             nb_segments++;
1177
1178     if (!nb_segments)
1179         return AVERROR_INVALIDDATA;
1180
1181     if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1182         !(*sorted_segments  = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1183         av_freep(sorted_segments);
1184         av_free(unsorted_segments);
1185         return AVERROR(ENOMEM);
1186     }
1187
1188     for (i = j = 0; i < mxf->metadata_sets_count; i++)
1189         if (mxf->metadata_sets[i]->type == IndexTableSegment)
1190             unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1191
1192     *nb_sorted_segments = 0;
1193
1194     /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1195     for (i = 0; i < nb_segments; i++) {
1196         int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1197         uint64_t best_index_duration = 0;
1198
1199         for (j = 0; j < nb_segments; j++) {
1200             MXFIndexTableSegment *s = unsorted_segments[j];
1201
1202             /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1203              * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1204              * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1205              */
1206             if ((i == 0     || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
1207                 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
1208                 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
1209                 best             = j;
1210                 best_body_sid    = s->body_sid;
1211                 best_index_sid   = s->index_sid;
1212                 best_index_start = s->index_start_position;
1213                 best_index_duration = s->index_duration;
1214             }
1215         }
1216
1217         /* no suitable entry found -> we're done */
1218         if (best == -1)
1219             break;
1220
1221         (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1222         last_body_sid    = best_body_sid;
1223         last_index_sid   = best_index_sid;
1224         last_index_start = best_index_start;
1225     }
1226
1227     av_free(unsorted_segments);
1228
1229     return 0;
1230 }
1231
1232 /**
1233  * Computes the absolute file offset of the given essence container offset
1234  */
1235 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1236 {
1237     int x;
1238     int64_t offset_in = offset;     /* for logging */
1239
1240     for (x = 0; x < mxf->partitions_count; x++) {
1241         MXFPartition *p = &mxf->partitions[x];
1242
1243         if (p->body_sid != body_sid)
1244             continue;
1245
1246         if (offset < p->essence_length || !p->essence_length) {
1247             *offset_out = p->essence_offset + offset;
1248             return 0;
1249         }
1250
1251         offset -= p->essence_length;
1252     }
1253
1254     av_log(mxf->fc, AV_LOG_ERROR,
1255            "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1256            offset_in, body_sid);
1257
1258     return AVERROR_INVALIDDATA;
1259 }
1260
1261 /**
1262  * Returns the end position of the essence container with given BodySID, or zero if unknown
1263  */
1264 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1265 {
1266     int x;
1267     int64_t ret = 0;
1268
1269     for (x = 0; x < mxf->partitions_count; x++) {
1270         MXFPartition *p = &mxf->partitions[x];
1271
1272         if (p->body_sid != body_sid)
1273             continue;
1274
1275         if (!p->essence_length)
1276             return 0;
1277
1278         ret = p->essence_offset + p->essence_length;
1279     }
1280
1281     return ret;
1282 }
1283
1284 /* EditUnit -> absolute offset */
1285 static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, int64_t *edit_unit_out, int64_t *offset_out, int nag)
1286 {
1287     int i;
1288     int64_t offset_temp = 0;
1289
1290     for (i = 0; i < index_table->nb_segments; i++) {
1291         MXFIndexTableSegment *s = index_table->segments[i];
1292
1293         edit_unit = FFMAX(edit_unit, s->index_start_position);  /* clamp if trying to seek before start */
1294
1295         if (edit_unit < s->index_start_position + s->index_duration) {
1296             int64_t index = edit_unit - s->index_start_position;
1297
1298             if (s->edit_unit_byte_count)
1299                 offset_temp += s->edit_unit_byte_count * index;
1300             else if (s->nb_index_entries) {
1301                 if (s->nb_index_entries == 2 * s->index_duration + 1)
1302                     index *= 2;     /* Avid index */
1303
1304                 if (index < 0 || index >= s->nb_index_entries) {
1305                     av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1306                            index_table->index_sid, s->index_start_position);
1307                     return AVERROR_INVALIDDATA;
1308                 }
1309
1310                 offset_temp = s->stream_offset_entries[index];
1311             } else {
1312                 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1313                        index_table->index_sid, s->index_start_position);
1314                 return AVERROR_INVALIDDATA;
1315             }
1316
1317             if (edit_unit_out)
1318                 *edit_unit_out = edit_unit;
1319
1320             return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1321         } else {
1322             /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1323             offset_temp += s->edit_unit_byte_count * s->index_duration;
1324         }
1325     }
1326
1327     if (nag)
1328         av_log(mxf->fc, AV_LOG_ERROR, "failed to map EditUnit %"PRId64" in IndexSID %i to an offset\n", edit_unit, index_table->index_sid);
1329
1330     return AVERROR_INVALIDDATA;
1331 }
1332
1333 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1334 {
1335     int i, j, x;
1336     int8_t max_temporal_offset = -128;
1337     uint8_t *flags;
1338
1339     /* first compute how many entries we have */
1340     for (i = 0; i < index_table->nb_segments; i++) {
1341         MXFIndexTableSegment *s = index_table->segments[i];
1342
1343         if (!s->nb_index_entries) {
1344             index_table->nb_ptses = 0;
1345             return 0;                               /* no TemporalOffsets */
1346         }
1347
1348         index_table->nb_ptses += s->index_duration;
1349     }
1350
1351     /* paranoid check */
1352     if (index_table->nb_ptses <= 0)
1353         return 0;
1354
1355     if (!(index_table->ptses      = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1356         !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1357         !(index_table->offsets    = av_calloc(index_table->nb_ptses, sizeof(int8_t))) ||
1358         !(flags                   = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) {
1359         av_freep(&index_table->ptses);
1360         av_freep(&index_table->fake_index);
1361         av_freep(&index_table->offsets);
1362         return AVERROR(ENOMEM);
1363     }
1364
1365     /* we may have a few bad TemporalOffsets
1366      * make sure the corresponding PTSes don't have the bogus value 0 */
1367     for (x = 0; x < index_table->nb_ptses; x++)
1368         index_table->ptses[x] = AV_NOPTS_VALUE;
1369
1370     /**
1371      * We have this:
1372      *
1373      * x  TemporalOffset
1374      * 0:  0
1375      * 1:  1
1376      * 2:  1
1377      * 3: -2
1378      * 4:  1
1379      * 5:  1
1380      * 6: -2
1381      *
1382      * We want to transform it into this:
1383      *
1384      * x  DTS PTS
1385      * 0: -1   0
1386      * 1:  0   3
1387      * 2:  1   1
1388      * 3:  2   2
1389      * 4:  3   6
1390      * 5:  4   4
1391      * 6:  5   5
1392      *
1393      * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1394      * then settings mxf->first_dts = -max(TemporalOffset[x]).
1395      * The latter makes DTS <= PTS.
1396      */
1397     for (i = x = 0; i < index_table->nb_segments; i++) {
1398         MXFIndexTableSegment *s = index_table->segments[i];
1399         int index_delta = 1;
1400         int n = s->nb_index_entries;
1401
1402         if (s->nb_index_entries == 2 * s->index_duration + 1) {
1403             index_delta = 2;    /* Avid index */
1404             /* ignore the last entry - it's the size of the essence container */
1405             n--;
1406         }
1407
1408         for (j = 0; j < n; j += index_delta, x++) {
1409             int offset = s->temporal_offset_entries[j] / index_delta;
1410             int index  = x + offset;
1411
1412             if (x >= index_table->nb_ptses) {
1413                 av_log(mxf->fc, AV_LOG_ERROR,
1414                        "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1415                        s->nb_index_entries, s->index_duration);
1416                 break;
1417             }
1418
1419             flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1420
1421             if (index < 0 || index >= index_table->nb_ptses) {
1422                 av_log(mxf->fc, AV_LOG_ERROR,
1423                        "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1424                        x, offset, index);
1425                 continue;
1426             }
1427
1428             index_table->offsets[x] = offset;
1429             index_table->ptses[index] = x;
1430             max_temporal_offset = FFMAX(max_temporal_offset, offset);
1431         }
1432     }
1433
1434     /* calculate the fake index table in display order */
1435     for (x = 0; x < index_table->nb_ptses; x++) {
1436         index_table->fake_index[x].timestamp = x;
1437         if (index_table->ptses[x] != AV_NOPTS_VALUE)
1438             index_table->fake_index[index_table->ptses[x]].flags = flags[x];
1439     }
1440     av_freep(&flags);
1441
1442     index_table->first_dts = -max_temporal_offset;
1443
1444     return 0;
1445 }
1446
1447 /**
1448  * Sorts and collects index table segments into index tables.
1449  * Also computes PTSes if possible.
1450  */
1451 static int mxf_compute_index_tables(MXFContext *mxf)
1452 {
1453     int i, j, k, ret, nb_sorted_segments;
1454     MXFIndexTableSegment **sorted_segments = NULL;
1455
1456     if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1457         nb_sorted_segments <= 0) {
1458         av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1459         return 0;
1460     }
1461
1462     /* sanity check and count unique BodySIDs/IndexSIDs */
1463     for (i = 0; i < nb_sorted_segments; i++) {
1464         if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1465             mxf->nb_index_tables++;
1466         else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1467             av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1468             ret = AVERROR_INVALIDDATA;
1469             goto finish_decoding_index;
1470         }
1471     }
1472
1473     mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1474                                          sizeof(*mxf->index_tables));
1475     if (!mxf->index_tables) {
1476         av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1477         ret = AVERROR(ENOMEM);
1478         goto finish_decoding_index;
1479     }
1480
1481     /* distribute sorted segments to index tables */
1482     for (i = j = 0; i < nb_sorted_segments; i++) {
1483         if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1484             /* next IndexSID */
1485             j++;
1486         }
1487
1488         mxf->index_tables[j].nb_segments++;
1489     }
1490
1491     for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1492         MXFIndexTable *t = &mxf->index_tables[j];
1493
1494         t->segments = av_mallocz_array(t->nb_segments,
1495                                        sizeof(*t->segments));
1496
1497         if (!t->segments) {
1498             av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1499                    " pointer array\n");
1500             ret = AVERROR(ENOMEM);
1501             goto finish_decoding_index;
1502         }
1503
1504         if (sorted_segments[i]->index_start_position)
1505             av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1506                    sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1507
1508         memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1509         t->index_sid = sorted_segments[i]->index_sid;
1510         t->body_sid = sorted_segments[i]->body_sid;
1511
1512         if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1513             goto finish_decoding_index;
1514
1515         /* fix zero IndexDurations */
1516         for (k = 0; k < t->nb_segments; k++) {
1517             if (t->segments[k]->index_duration)
1518                 continue;
1519
1520             if (t->nb_segments > 1)
1521                 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1522                        t->index_sid, k);
1523
1524             if (mxf->fc->nb_streams <= 0) {
1525                 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1526                 break;
1527             }
1528
1529             /* assume the first stream's duration is reasonable
1530              * leave index_duration = 0 on further segments in case we have any (unlikely)
1531              */
1532             t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1533             break;
1534         }
1535     }
1536
1537     ret = 0;
1538 finish_decoding_index:
1539     av_free(sorted_segments);
1540     return ret;
1541 }
1542
1543 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1544 {
1545     return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1546                             &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1547            mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1548                             &descriptor->essence_codec_ul)->id     != AV_CODEC_ID_NONE;
1549 }
1550
1551 static int mxf_uid_to_str(UID uid, char **str)
1552 {
1553     int i;
1554     char *p;
1555     p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1556     if (!p)
1557         return AVERROR(ENOMEM);
1558     for (i = 0; i < sizeof(UID); i++) {
1559         snprintf(p, 2 + 1, "%.2x", uid[i]);
1560         p += 2;
1561         if (i == 3 || i == 5 || i == 7 || i == 9) {
1562             snprintf(p, 1 + 1, "-");
1563             p++;
1564         }
1565     }
1566     return 0;
1567 }
1568
1569 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1570 {
1571     int i;
1572     char *p;
1573     p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1574     if (!p)
1575         return AVERROR(ENOMEM);
1576     snprintf(p, 2 + 1, "0x");
1577     p += 2;
1578     for (i = 0; i < sizeof(UID); i++) {
1579         snprintf(p, 2 + 1, "%.2X", ul[i]);
1580         p += 2;
1581
1582     }
1583     for (i = 0; i < sizeof(UID); i++) {
1584         snprintf(p, 2 + 1, "%.2X", uid[i]);
1585         p += 2;
1586     }
1587     return 0;
1588 }
1589
1590 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1591 {
1592     char *str;
1593     int ret;
1594     if (!package)
1595         return 0;
1596     if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1597         return ret;
1598     av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1599     return 0;
1600 }
1601
1602 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1603 {
1604     char buf[AV_TIMECODE_STR_SIZE];
1605     av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1606
1607     return 0;
1608 }
1609
1610 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
1611 {
1612     MXFStructuralComponent *component = NULL;
1613     MXFPulldownComponent *pulldown = NULL;
1614
1615     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1616     if (!component)
1617         return NULL;
1618
1619     switch (component->type) {
1620     case TimecodeComponent:
1621         return (MXFTimecodeComponent*)component;
1622     case PulldownComponent: /* timcode component may be located on a pulldown component */
1623         pulldown = (MXFPulldownComponent*)component;
1624         return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
1625     default:
1626         break;
1627     }
1628     return NULL;
1629 }
1630
1631 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_uid)
1632 {
1633     MXFPackage *package = NULL;
1634     int i;
1635
1636     for (i = 0; i < mxf->packages_count; i++) {
1637         package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1638         if (!package)
1639             continue;
1640
1641         if (!memcmp(package->package_uid, package_uid, 16))
1642             return package;
1643     }
1644     return NULL;
1645 }
1646
1647 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1648 {
1649     MXFDescriptor *sub_descriptor = NULL;
1650     int i;
1651
1652     if (!descriptor)
1653         return NULL;
1654
1655     if (descriptor->type == MultipleDescriptor) {
1656         for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1657             sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1658
1659             if (!sub_descriptor) {
1660                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1661                 continue;
1662             }
1663             if (sub_descriptor->linked_track_id == track_id) {
1664                 return sub_descriptor;
1665             }
1666         }
1667     } else if (descriptor->type == Descriptor)
1668         return descriptor;
1669
1670     return NULL;
1671 }
1672
1673 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
1674 {
1675     MXFStructuralComponent *component = NULL;
1676     MXFPackage *package = NULL;
1677     MXFDescriptor *descriptor = NULL;
1678     int i;
1679
1680     if (!essence_group || !essence_group->structural_components_count)
1681         return NULL;
1682
1683     /* essence groups contains multiple representations of the same media,
1684        this return the first components with a valid Descriptor typically index 0 */
1685     for (i =0; i < essence_group->structural_components_count; i++){
1686         component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1687         if (!component)
1688             continue;
1689
1690         if (!(package = mxf_resolve_source_package(mxf, component->source_package_uid)))
1691             continue;
1692
1693         descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1694         if (descriptor)
1695             return component;
1696     }
1697     return NULL;
1698 }
1699
1700 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
1701 {
1702     MXFStructuralComponent *component = NULL;
1703
1704     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1705     if (!component)
1706         return NULL;
1707     switch (component->type) {
1708         case SourceClip:
1709             return component;
1710         case EssenceGroup:
1711             return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
1712         default:
1713             break;
1714     }
1715     return NULL;
1716 }
1717
1718 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
1719 {
1720     MXFTaggedValue *tag;
1721     int size, i;
1722     char *key = NULL;
1723
1724     for (i = 0; i < package->comment_count; i++) {
1725         tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
1726         if (!tag || !tag->name || !tag->value)
1727             continue;
1728
1729         size = strlen(tag->name) + 8 + 1;
1730         key = av_mallocz(size);
1731         if (!key)
1732             return AVERROR(ENOMEM);
1733
1734         snprintf(key, size, "comment_%s", tag->name);
1735         av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
1736     }
1737     return 0;
1738 }
1739
1740 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
1741 {
1742     MXFPackage *physical_package = NULL;
1743     MXFTrack *physical_track = NULL;
1744     MXFStructuralComponent *sourceclip = NULL;
1745     MXFTimecodeComponent *mxf_tc = NULL;
1746     int i, j, k;
1747     AVTimecode tc;
1748     int flags;
1749     int64_t start_position;
1750
1751     for (i = 0; i < source_track->sequence->structural_components_count; i++) {
1752         sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
1753         if (!sourceclip)
1754             continue;
1755
1756         if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_uid)))
1757             break;
1758
1759         mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
1760
1761         /* the name of physical source package is name of the reel or tape */
1762         if (physical_package->name && physical_package->name[0])
1763             av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
1764
1765         /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
1766          * to the start_frame of the timecode component located on one of the tracks of the physical source package.
1767          */
1768         for (j = 0; j < physical_package->tracks_count; j++) {
1769             if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
1770                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1771                 continue;
1772             }
1773
1774             if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
1775                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1776                 continue;
1777             }
1778
1779         if (physical_track->edit_rate.num <= 0 ||
1780             physical_track->edit_rate.den <= 0) {
1781             av_log(mxf->fc, AV_LOG_WARNING,
1782                    "Invalid edit rate (%d/%d) found on structural"
1783                    " component #%d, defaulting to 25/1\n",
1784                    physical_track->edit_rate.num,
1785                    physical_track->edit_rate.den, i);
1786             physical_track->edit_rate = (AVRational){25, 1};
1787         }
1788
1789             for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
1790                 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
1791                     continue;
1792
1793                 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1794                 /* scale sourceclip start_position to match physical track edit rate */
1795                 start_position = av_rescale_q(sourceclip->start_position,
1796                                               physical_track->edit_rate,
1797                                               source_track->edit_rate);
1798
1799                 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
1800                     mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
1801                     return 0;
1802                 }
1803             }
1804         }
1805     }
1806
1807     return 0;
1808 }
1809
1810 static int mxf_parse_structural_metadata(MXFContext *mxf)
1811 {
1812     MXFPackage *material_package = NULL;
1813     int i, j, k, ret;
1814
1815     av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
1816     /* TODO: handle multiple material packages (OP3x) */
1817     for (i = 0; i < mxf->packages_count; i++) {
1818         material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1819         if (material_package) break;
1820     }
1821     if (!material_package) {
1822         av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1823         return AVERROR_INVALIDDATA;
1824     }
1825
1826     mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
1827     if (material_package->name && material_package->name[0])
1828         av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
1829     mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
1830
1831     for (i = 0; i < material_package->tracks_count; i++) {
1832         MXFPackage *source_package = NULL;
1833         MXFTrack *material_track = NULL;
1834         MXFTrack *source_track = NULL;
1835         MXFTrack *temp_track = NULL;
1836         MXFDescriptor *descriptor = NULL;
1837         MXFStructuralComponent *component = NULL;
1838         MXFTimecodeComponent *mxf_tc = NULL;
1839         UID *essence_container_ul = NULL;
1840         const MXFCodecUL *codec_ul = NULL;
1841         const MXFCodecUL *container_ul = NULL;
1842         const MXFCodecUL *pix_fmt_ul = NULL;
1843         AVStream *st;
1844         AVTimecode tc;
1845         int flags;
1846
1847         if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1848             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1849             continue;
1850         }
1851
1852         if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1853             mxf_tc = (MXFTimecodeComponent*)component;
1854             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1855             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1856                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1857             }
1858         }
1859
1860         if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1861             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1862             continue;
1863         }
1864
1865         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1866             component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1867             if (!component)
1868                 continue;
1869
1870             mxf_tc = (MXFTimecodeComponent*)component;
1871             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1872             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1873                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1874                 break;
1875             }
1876         }
1877
1878         /* TODO: handle multiple source clips */
1879         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1880             component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
1881             if (!component)
1882                 continue;
1883
1884             source_package = mxf_resolve_source_package(mxf, component->source_package_uid);
1885             if (!source_package) {
1886                 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
1887                 break;
1888             }
1889             for (k = 0; k < source_package->tracks_count; k++) {
1890                 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1891                     av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1892                     ret = AVERROR_INVALIDDATA;
1893                     goto fail_and_free;
1894                 }
1895                 if (temp_track->track_id == component->source_track_id) {
1896                     source_track = temp_track;
1897                     break;
1898                 }
1899             }
1900             if (!source_track) {
1901                 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1902                 break;
1903             }
1904         }
1905         if (!source_track || !component)
1906             continue;
1907
1908         if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1909             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1910             ret = AVERROR_INVALIDDATA;
1911             goto fail_and_free;
1912         }
1913
1914         /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1915          * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1916         if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1917             av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1918             continue;
1919         }
1920
1921         st = avformat_new_stream(mxf->fc, NULL);
1922         if (!st) {
1923             av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1924             ret = AVERROR(ENOMEM);
1925             goto fail_and_free;
1926         }
1927         st->id = source_track->track_id;
1928         st->priv_data = source_track;
1929
1930         source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1931         descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
1932
1933         /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
1934          * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
1935         if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
1936             source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
1937         else
1938             source_track->original_duration = st->duration = component->duration;
1939
1940         if (st->duration == -1)
1941             st->duration = AV_NOPTS_VALUE;
1942         st->start_time = component->start_position;
1943         if (material_track->edit_rate.num <= 0 ||
1944             material_track->edit_rate.den <= 0) {
1945             av_log(mxf->fc, AV_LOG_WARNING,
1946                    "Invalid edit rate (%d/%d) found on stream #%d, "
1947                    "defaulting to 25/1\n",
1948                    material_track->edit_rate.num,
1949                    material_track->edit_rate.den, st->index);
1950             material_track->edit_rate = (AVRational){25, 1};
1951         }
1952         avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1953
1954         /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
1955          * the former is accessible via st->priv_data */
1956         source_track->edit_rate = material_track->edit_rate;
1957
1958         PRINT_KEY(mxf->fc, "data definition   ul", source_track->sequence->data_definition_ul);
1959         codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1960         st->codec->codec_type = codec_ul->id;
1961
1962         if (!descriptor) {
1963             av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1964             continue;
1965         }
1966         PRINT_KEY(mxf->fc, "essence codec     ul", descriptor->essence_codec_ul);
1967         PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1968         essence_container_ul = &descriptor->essence_container_ul;
1969         /* HACK: replacing the original key with mxf_encrypted_essence_container
1970          * is not allowed according to s429-6, try to find correct information anyway */
1971         if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1972             av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1973             for (k = 0; k < mxf->metadata_sets_count; k++) {
1974                 MXFMetadataSet *metadata = mxf->metadata_sets[k];
1975                 if (metadata->type == CryptoContext) {
1976                     essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1977                     break;
1978                 }
1979             }
1980         }
1981
1982         /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1983         codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1984         st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1985         if (st->codec->codec_id == AV_CODEC_ID_NONE) {
1986             codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
1987             st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1988         }
1989
1990         av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
1991                avcodec_get_name(st->codec->codec_id));
1992         for (k = 0; k < 16; k++) {
1993             av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
1994                    descriptor->essence_codec_ul[k]);
1995             if (!(k+1 & 19) || k == 5)
1996                 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
1997         }
1998         av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1999
2000         mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2001         if (source_package->name && source_package->name[0])
2002             av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2003
2004         mxf_parse_physical_source_package(mxf, source_track, st);
2005
2006         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2007             source_track->intra_only = mxf_is_intra_only(descriptor);
2008             container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2009             if (st->codec->codec_id == AV_CODEC_ID_NONE)
2010                 st->codec->codec_id = container_ul->id;
2011             st->codec->width = descriptor->width;
2012             st->codec->height = descriptor->height; /* Field height, not frame height */
2013             switch (descriptor->frame_layout) {
2014                 case FullFrame:
2015                     st->codec->field_order = AV_FIELD_PROGRESSIVE;
2016                     break;
2017                 case OneField:
2018                     /* Every other line is stored and needs to be duplicated. */
2019                     av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2020                     break; /* The correct thing to do here is fall through, but by breaking we might be
2021                               able to decode some streams at half the vertical resolution, rather than not al all.
2022                               It's also for compatibility with the old behavior. */
2023                 case MixedFields:
2024                     break;
2025                 case SegmentedFrame:
2026                     st->codec->field_order = AV_FIELD_PROGRESSIVE;
2027                 case SeparateFields:
2028                     switch (descriptor->field_dominance) {
2029                     case MXF_TFF:
2030                         st->codec->field_order = AV_FIELD_TT;
2031                         break;
2032                     case MXF_BFF:
2033                         st->codec->field_order = AV_FIELD_BB;
2034                         break;
2035                     default:
2036                         avpriv_request_sample(mxf->fc,
2037                                               "Field dominance %d support",
2038                                               descriptor->field_dominance);
2039                     case 0: // we already have many samples with field_dominance == unknown
2040                         break;
2041                     }
2042                     /* Turn field height into frame height. */
2043                     st->codec->height *= 2;
2044                     break;
2045                 default:
2046                     av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2047             }
2048             if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
2049                 st->codec->pix_fmt = descriptor->pix_fmt;
2050                 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
2051                     pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2052                                                   &descriptor->essence_codec_ul);
2053                     st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
2054                     if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
2055                         st->codec->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2056                                                                 &descriptor->essence_codec_ul)->id;
2057                         if (!st->codec->codec_tag) {
2058                             /* support files created before RP224v10 by defaulting to UYVY422
2059                                if subsampling is 4:2:2 and component depth is 8-bit */
2060                             if (descriptor->horiz_subsampling == 2 &&
2061                                 descriptor->vert_subsampling == 1 &&
2062                                 descriptor->component_depth == 8) {
2063                                 st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
2064                             }
2065                         }
2066                     }
2067                 }
2068             }
2069             st->need_parsing = AVSTREAM_PARSE_HEADERS;
2070             if (material_track->sequence->origin) {
2071                 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2072             }
2073             if (source_track->sequence->origin) {
2074                 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2075             }
2076             if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2077                 st->display_aspect_ratio = descriptor->aspect_ratio;
2078         } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2079             container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2080             /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2081             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))
2082                 st->codec->codec_id = (enum AVCodecID)container_ul->id;
2083             st->codec->channels = descriptor->channels;
2084             st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
2085
2086             if (descriptor->sample_rate.den > 0) {
2087                 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2088                 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2089             } else {
2090                 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2091                        "found for stream #%d, time base forced to 1/48000\n",
2092                        descriptor->sample_rate.num, descriptor->sample_rate.den,
2093                        st->index);
2094                 avpriv_set_pts_info(st, 64, 1, 48000);
2095             }
2096
2097             /* if duration is set, rescale it from EditRate to SampleRate */
2098             if (st->duration != AV_NOPTS_VALUE)
2099                 st->duration = av_rescale_q(st->duration,
2100                                             av_inv_q(material_track->edit_rate),
2101                                             st->time_base);
2102
2103             /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2104             if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
2105                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2106                     st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
2107                 else if (descriptor->bits_per_sample == 32)
2108                     st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
2109             } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
2110                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2111                     st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
2112                 else if (descriptor->bits_per_sample == 32)
2113                     st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
2114             } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
2115                 st->need_parsing = AVSTREAM_PARSE_FULL;
2116             }
2117         } else if (st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2118             int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls,
2119                                             essence_container_ul)->id;
2120             if (codec_id >= 0 &&
2121                 codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) {
2122                 av_dict_set(&st->metadata, "data_type",
2123                             mxf_data_essence_descriptor[codec_id], 0);
2124             }
2125         }
2126         if (descriptor->extradata) {
2127             if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) {
2128                 memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
2129             }
2130         } else if (st->codec->codec_id == AV_CODEC_ID_H264) {
2131             ret = ff_generate_avci_extradata(st);
2132             if (ret < 0)
2133                 return ret;
2134         }
2135         if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
2136             /* TODO: decode timestamps */
2137             st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2138         }
2139     }
2140
2141     ret = 0;
2142 fail_and_free:
2143     return ret;
2144 }
2145
2146 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
2147 {
2148     struct tm time = { 0 };
2149     time.tm_year = (timestamp >> 48) - 1900;
2150     time.tm_mon  = (timestamp >> 40 & 0xFF) - 1;
2151     time.tm_mday = (timestamp >> 32 & 0xFF);
2152     time.tm_hour = (timestamp >> 24 & 0xFF);
2153     time.tm_min  = (timestamp >> 16 & 0xFF);
2154     time.tm_sec  = (timestamp >> 8  & 0xFF);
2155
2156     /* msvcrt versions of strftime calls the invalid parameter handler
2157      * (aborting the process if one isn't set) if the parameters are out
2158      * of range. */
2159     time.tm_mon  = av_clip(time.tm_mon,  0, 11);
2160     time.tm_mday = av_clip(time.tm_mday, 1, 31);
2161     time.tm_hour = av_clip(time.tm_hour, 0, 23);
2162     time.tm_min  = av_clip(time.tm_min,  0, 59);
2163     time.tm_sec  = av_clip(time.tm_sec,  0, 59);
2164
2165     *str = av_mallocz(32);
2166     if (!*str)
2167         return AVERROR(ENOMEM);
2168     if (!strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time))
2169         (*str)[0] = '\0';
2170
2171     return 0;
2172 }
2173
2174 #define SET_STR_METADATA(pb, name, str) do { \
2175     if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2176         return ret; \
2177     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2178 } while (0)
2179
2180 #define SET_UID_METADATA(pb, name, var, str) do { \
2181     avio_read(pb, var, 16); \
2182     if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2183         return ret; \
2184     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2185 } while (0)
2186
2187 #define SET_TS_METADATA(pb, name, var, str) do { \
2188     var = avio_rb64(pb); \
2189     if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
2190         return ret; \
2191     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2192 } while (0)
2193
2194 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2195 {
2196     MXFContext *mxf = arg;
2197     AVFormatContext *s = mxf->fc;
2198     int ret;
2199     UID uid = { 0 };
2200     char *str = NULL;
2201     uint64_t ts;
2202     switch (tag) {
2203     case 0x3C01:
2204         SET_STR_METADATA(pb, "company_name", str);
2205         break;
2206     case 0x3C02:
2207         SET_STR_METADATA(pb, "product_name", str);
2208         break;
2209     case 0x3C04:
2210         SET_STR_METADATA(pb, "product_version", str);
2211         break;
2212     case 0x3C05:
2213         SET_UID_METADATA(pb, "product_uid", uid, str);
2214         break;
2215     case 0x3C06:
2216         SET_TS_METADATA(pb, "modification_date", ts, str);
2217         break;
2218     case 0x3C08:
2219         SET_STR_METADATA(pb, "application_platform", str);
2220         break;
2221     case 0x3C09:
2222         SET_UID_METADATA(pb, "generation_uid", uid, str);
2223         break;
2224     case 0x3C0A:
2225         SET_UID_METADATA(pb, "uid", uid, str);
2226         break;
2227     }
2228     return 0;
2229 }
2230
2231 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2232 {
2233     MXFContext *mxf = arg;
2234     AVFormatContext *s = mxf->fc;
2235     int ret;
2236     char *str = NULL;
2237
2238     if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2239         SET_STR_METADATA(pb, "project_name", str);
2240     }
2241     return 0;
2242 }
2243
2244 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2245     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2246     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2247     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2248     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2249     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2250     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2251     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2252     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2253     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2254     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2255     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2256     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2257     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2258     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2259     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2260     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2261     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2262     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2263     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2264     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2265     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2266     { { 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 */
2267     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2268     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2269     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG 2 Video */
2270     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2271     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2272     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2273     { { 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 */
2274     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2275     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2276     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2277     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2278     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2279     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2280     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2281     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2282 };
2283
2284 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2285 {
2286     switch (type){
2287     case MultipleDescriptor:
2288     case Descriptor:
2289         ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2290         ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2291         break;
2292     default:
2293         break;
2294     }
2295     return 0;
2296 }
2297
2298 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2299 {
2300     AVIOContext *pb = mxf->fc->pb;
2301     MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2302     uint64_t klv_end = avio_tell(pb) + klv->length;
2303
2304     if (!ctx)
2305         return AVERROR(ENOMEM);
2306     mxf_metadataset_init(ctx, type);
2307     while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2308         int ret;
2309         int tag = avio_rb16(pb);
2310         int size = avio_rb16(pb); /* KLV specified by 0x53 */
2311         uint64_t next = avio_tell(pb) + size;
2312         UID uid = {0};
2313
2314         av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2315         if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2316             av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2317             continue;
2318         }
2319         if (tag > 0x7FFF) { /* dynamic tag */
2320             int i;
2321             for (i = 0; i < mxf->local_tags_count; i++) {
2322                 int local_tag = AV_RB16(mxf->local_tags+i*18);
2323                 if (local_tag == tag) {
2324                     memcpy(uid, mxf->local_tags+i*18+2, 16);
2325                     av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2326                     PRINT_KEY(mxf->fc, "uid", uid);
2327                 }
2328             }
2329         }
2330         if (ctx_size && tag == 0x3C0A) {
2331             avio_read(pb, ctx->uid, 16);
2332         } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2333             mxf_free_metadataset(&ctx, !!ctx_size);
2334             return ret;
2335         }
2336
2337         /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2338          * it extending past the end of the KLV though (zzuf5.mxf). */
2339         if (avio_tell(pb) > klv_end) {
2340             if (ctx_size) {
2341                 ctx->type = type;
2342                 mxf_free_metadataset(&ctx, !!ctx_size);
2343             }
2344
2345             av_log(mxf->fc, AV_LOG_ERROR,
2346                    "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2347                    tag, klv->offset);
2348             return AVERROR_INVALIDDATA;
2349         } else if (avio_tell(pb) <= next)   /* only seek forward, else this can loop for a long time */
2350             avio_seek(pb, next, SEEK_SET);
2351     }
2352     if (ctx_size) ctx->type = type;
2353     return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2354 }
2355
2356 /**
2357  * Matches any partition pack key, in other words:
2358  * - HeaderPartition
2359  * - BodyPartition
2360  * - FooterPartition
2361  * @return non-zero if the key is a partition pack key, zero otherwise
2362  */
2363 static int mxf_is_partition_pack_key(UID key)
2364 {
2365     //NOTE: this is a little lax since it doesn't constraint key[14]
2366     return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2367             key[13] >= 2 && key[13] <= 4;
2368 }
2369
2370 /**
2371  * Parses a metadata KLV
2372  * @return <0 on error, 0 otherwise
2373  */
2374 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2375                                      int ctx_size, enum MXFMetadataSetType type)
2376 {
2377     AVFormatContext *s = mxf->fc;
2378     int res;
2379     if (klv.key[5] == 0x53) {
2380         res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2381     } else {
2382         uint64_t next = avio_tell(s->pb) + klv.length;
2383         res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2384
2385         /* only seek forward, else this can loop for a long time */
2386         if (avio_tell(s->pb) > next) {
2387             av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2388                    klv.offset);
2389             return AVERROR_INVALIDDATA;
2390         }
2391
2392         avio_seek(s->pb, next, SEEK_SET);
2393     }
2394     if (res < 0) {
2395         av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2396         return res;
2397     }
2398     return 0;
2399 }
2400
2401 /**
2402  * Seeks to the previous partition and parses it, if possible
2403  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2404  */
2405 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2406 {
2407     AVIOContext *pb = mxf->fc->pb;
2408     KLVPacket klv;
2409     int64_t current_partition_ofs;
2410     int ret;
2411
2412     if (!mxf->current_partition ||
2413         mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2414         return 0;   /* we've parsed all partitions */
2415
2416     /* seek to previous partition */
2417     current_partition_ofs = mxf->current_partition->pack_ofs;   //includes run-in
2418     avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2419     mxf->current_partition = NULL;
2420
2421     av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
2422
2423     /* Make sure this is actually a PartitionPack, and if so parse it.
2424      * See deadlock2.mxf
2425      */
2426     if ((ret = klv_read_packet(&klv, pb)) < 0) {
2427         av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2428         return ret;
2429     }
2430
2431     if (!mxf_is_partition_pack_key(klv.key)) {
2432         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2433         return AVERROR_INVALIDDATA;
2434     }
2435
2436     /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2437      * can point to just before the current partition, causing klv_read_packet()
2438      * to sync back up to it. See deadlock3.mxf
2439      */
2440     if (klv.offset >= current_partition_ofs) {
2441         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2442                PRIx64 " indirectly points to itself\n", current_partition_ofs);
2443         return AVERROR_INVALIDDATA;
2444     }
2445
2446     if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2447         return ret;
2448
2449     return 1;
2450 }
2451
2452 /**
2453  * Called when essence is encountered
2454  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2455  */
2456 static int mxf_parse_handle_essence(MXFContext *mxf)
2457 {
2458     AVIOContext *pb = mxf->fc->pb;
2459     int64_t ret;
2460
2461     if (mxf->parsing_backward) {
2462         return mxf_seek_to_previous_partition(mxf);
2463     } else {
2464         if (!mxf->footer_partition) {
2465             av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
2466             return 0;
2467         }
2468
2469         av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
2470
2471         /* remember where we were so we don't end up seeking further back than this */
2472         mxf->last_forward_tell = avio_tell(pb);
2473
2474         if (!pb->seekable) {
2475             av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2476             return -1;
2477         }
2478
2479         /* seek to FooterPartition and parse backward */
2480         if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2481             av_log(mxf->fc, AV_LOG_ERROR,
2482                    "failed to seek to FooterPartition @ 0x%" PRIx64
2483                    " (%"PRId64") - partial file?\n",
2484                    mxf->run_in + mxf->footer_partition, ret);
2485             return ret;
2486         }
2487
2488         mxf->current_partition = NULL;
2489         mxf->parsing_backward = 1;
2490     }
2491
2492     return 1;
2493 }
2494
2495 /**
2496  * Called when the next partition or EOF is encountered
2497  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2498  */
2499 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2500 {
2501     return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2502 }
2503
2504 /**
2505  * Figures out the proper offset and length of the essence container in each partition
2506  */
2507 static void mxf_compute_essence_containers(MXFContext *mxf)
2508 {
2509     int x;
2510
2511     /* everything is already correct */
2512     if (mxf->op == OPAtom)
2513         return;
2514
2515     for (x = 0; x < mxf->partitions_count; x++) {
2516         MXFPartition *p = &mxf->partitions[x];
2517
2518         if (!p->body_sid)
2519             continue;       /* BodySID == 0 -> no essence */
2520
2521         if (x >= mxf->partitions_count - 1)
2522             break;          /* FooterPartition - can't compute length (and we don't need to) */
2523
2524         /* essence container spans to the next partition */
2525         p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2526
2527         if (p->essence_length < 0) {
2528             /* next ThisPartition < essence_offset */
2529             p->essence_length = 0;
2530             av_log(mxf->fc, AV_LOG_ERROR,
2531                    "partition %i: bad ThisPartition = %"PRIX64"\n",
2532                    x+1, mxf->partitions[x+1].this_partition);
2533         }
2534     }
2535 }
2536
2537 static int64_t round_to_kag(int64_t position, int kag_size)
2538 {
2539     /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2540     /* NOTE: kag_size may be any integer between 1 - 2^10 */
2541     int64_t ret = (position / kag_size) * kag_size;
2542     return ret == position ? ret : ret + kag_size;
2543 }
2544
2545 static int is_pcm(enum AVCodecID codec_id)
2546 {
2547     /* we only care about "normal" PCM codecs until we get samples */
2548     return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2549 }
2550
2551 /**
2552  * Deal with the case where for some audio atoms EditUnitByteCount is
2553  * very small (2, 4..). In those cases we should read more than one
2554  * sample per call to mxf_read_packet().
2555  */
2556 static void mxf_handle_small_eubc(AVFormatContext *s)
2557 {
2558     MXFContext *mxf = s->priv_data;
2559
2560     /* assuming non-OPAtom == frame wrapped
2561      * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2562     if (mxf->op != OPAtom)
2563         return;
2564
2565     /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2566     if (s->nb_streams != 1                                     ||
2567         s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
2568         !is_pcm(s->streams[0]->codec->codec_id)                ||
2569         mxf->nb_index_tables != 1                              ||
2570         mxf->index_tables[0].nb_segments != 1                  ||
2571         mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2572         return;
2573
2574     /* arbitrarily default to 48 kHz PAL audio frame size */
2575     /* TODO: We could compute this from the ratio between the audio
2576      *       and video edit rates for 48 kHz NTSC we could use the
2577      *       1802-1802-1802-1802-1801 pattern. */
2578     mxf->edit_units_per_packet = 1920;
2579 }
2580
2581 /**
2582  * Deal with the case where OPAtom files does not have any IndexTableSegments.
2583  */
2584 static int mxf_handle_missing_index_segment(MXFContext *mxf)
2585 {
2586     AVFormatContext *s = mxf->fc;
2587     AVStream *st = NULL;
2588     MXFIndexTableSegment *segment = NULL;
2589     MXFPartition *p = NULL;
2590     int essence_partition_count = 0;
2591     int i, ret;
2592
2593     if (mxf->op != OPAtom)
2594         return 0;
2595
2596     /* TODO: support raw video without a index if they exist */
2597     if (s->nb_streams != 1 || s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO || !is_pcm(s->streams[0]->codec->codec_id))
2598         return 0;
2599
2600     /* check if file already has a IndexTableSegment */
2601     for (i = 0; i < mxf->metadata_sets_count; i++) {
2602         if (mxf->metadata_sets[i]->type == IndexTableSegment)
2603             return 0;
2604     }
2605
2606     /* find the essence partition */
2607     for (i = 0; i < mxf->partitions_count; i++) {
2608         /* BodySID == 0 -> no essence */
2609         if (!mxf->partitions[i].body_sid)
2610             continue;
2611
2612         p = &mxf->partitions[i];
2613         essence_partition_count++;
2614     }
2615
2616     /* only handle files with a single essence partition */
2617     if (essence_partition_count != 1)
2618         return 0;
2619
2620     if (!(segment = av_mallocz(sizeof(*segment))))
2621         return AVERROR(ENOMEM);
2622
2623     if ((ret = mxf_add_metadata_set(mxf, segment))) {
2624         mxf_free_metadataset((MXFMetadataSet**)&segment, 1);
2625         return ret;
2626     }
2627
2628     st = s->streams[0];
2629     segment->type = IndexTableSegment;
2630     /* stream will be treated as small EditUnitByteCount */
2631     segment->edit_unit_byte_count = (av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3;
2632     segment->index_start_position = 0;
2633     segment->index_duration = s->streams[0]->duration;
2634     segment->index_sid = p->index_sid;
2635     segment->body_sid = p->body_sid;
2636     return 0;
2637 }
2638
2639 static void mxf_read_random_index_pack(AVFormatContext *s)
2640 {
2641     MXFContext *mxf = s->priv_data;
2642     uint32_t length;
2643     int64_t file_size, max_rip_length, min_rip_length;
2644     KLVPacket klv;
2645
2646     if (!s->pb->seekable)
2647         return;
2648
2649     file_size = avio_size(s->pb);
2650
2651     /* S377m says to check the RIP length for "silly" values, without defining "silly".
2652      * The limit below assumes a file with nothing but partition packs and a RIP.
2653      * Before changing this, consider that a muxer may place each sample in its own partition.
2654      *
2655      * 105 is the size of the smallest possible PartitionPack
2656      * 12 is the size of each RIP entry
2657      * 28 is the size of the RIP header and footer, assuming an 8-byte BER
2658      */
2659     max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
2660     max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
2661
2662     /* We're only interested in RIPs with at least two entries.. */
2663     min_rip_length = 16+1+24+4;
2664
2665     /* See S377m section 11 */
2666     avio_seek(s->pb, file_size - 4, SEEK_SET);
2667     length = avio_rb32(s->pb);
2668
2669     if (length < min_rip_length || length > max_rip_length)
2670         goto end;
2671     avio_seek(s->pb, file_size - length, SEEK_SET);
2672     if (klv_read_packet(&klv, s->pb) < 0 ||
2673         !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2674         klv.length != length - 20)
2675         goto end;
2676
2677     avio_skip(s->pb, klv.length - 12);
2678     mxf->footer_partition = avio_rb64(s->pb);
2679
2680     /* sanity check */
2681     if (mxf->run_in + mxf->footer_partition >= file_size) {
2682         av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
2683         mxf->footer_partition = 0;
2684     }
2685
2686 end:
2687     avio_seek(s->pb, mxf->run_in, SEEK_SET);
2688 }
2689
2690 static int mxf_read_header(AVFormatContext *s)
2691 {
2692     MXFContext *mxf = s->priv_data;
2693     KLVPacket klv;
2694     int64_t essence_offset = 0;
2695     int ret;
2696
2697     mxf->last_forward_tell = INT64_MAX;
2698     mxf->edit_units_per_packet = 1;
2699
2700     if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2701         av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2702         return AVERROR_INVALIDDATA;
2703     }
2704     avio_seek(s->pb, -14, SEEK_CUR);
2705     mxf->fc = s;
2706     mxf->run_in = avio_tell(s->pb);
2707
2708     mxf_read_random_index_pack(s);
2709
2710     while (!avio_feof(s->pb)) {
2711         const MXFMetadataReadTableEntry *metadata;
2712
2713         if (klv_read_packet(&klv, s->pb) < 0) {
2714             /* EOF - seek to previous partition or stop */
2715             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2716                 break;
2717             else
2718                 continue;
2719         }
2720
2721         PRINT_KEY(s, "read header", klv.key);
2722         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2723         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2724             IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2725             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2726             IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2727
2728             if (!mxf->current_partition) {
2729                 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2730                 return AVERROR_INVALIDDATA;
2731             }
2732
2733             if (!mxf->current_partition->essence_offset) {
2734                 /* for OP1a we compute essence_offset
2735                  * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2736                  * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2737                  *       for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2738                  */
2739                 int64_t op1a_essence_offset =
2740                     round_to_kag(mxf->current_partition->this_partition +
2741                                  mxf->current_partition->pack_length,       mxf->current_partition->kag_size) +
2742                     round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2743                     round_to_kag(mxf->current_partition->index_byte_count,  mxf->current_partition->kag_size);
2744
2745                 if (mxf->op == OPAtom) {
2746                     /* point essence_offset to the actual data
2747                     * OPAtom has all the essence in one big KLV
2748                     */
2749                     mxf->current_partition->essence_offset = avio_tell(s->pb);
2750                     mxf->current_partition->essence_length = klv.length;
2751                 } else {
2752                     /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf)  */
2753                     mxf->current_partition->essence_offset = op1a_essence_offset;
2754                 }
2755             }
2756
2757             if (!essence_offset)
2758                 essence_offset = klv.offset;
2759
2760             /* seek to footer, previous partition or stop */
2761             if (mxf_parse_handle_essence(mxf) <= 0)
2762                 break;
2763             continue;
2764         } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
2765             /* next partition pack - keep going, seek to previous partition or stop */
2766             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2767                 break;
2768             else if (mxf->parsing_backward)
2769                 continue;
2770             /* we're still parsing forward. proceed to parsing this partition pack */
2771         }
2772
2773         for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2774             if (IS_KLV_KEY(klv.key, metadata->key)) {
2775                 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
2776                     goto fail;
2777                 break;
2778             }
2779         }
2780         if (!metadata->read) {
2781             av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
2782                             UID_ARG(klv.key));
2783             avio_skip(s->pb, klv.length);
2784         }
2785     }
2786     /* FIXME avoid seek */
2787     if (!essence_offset)  {
2788         av_log(s, AV_LOG_ERROR, "no essence\n");
2789         ret = AVERROR_INVALIDDATA;
2790         goto fail;
2791     }
2792     avio_seek(s->pb, essence_offset, SEEK_SET);
2793
2794     mxf_compute_essence_containers(mxf);
2795
2796     /* we need to do this before computing the index tables
2797      * to be able to fill in zero IndexDurations with st->duration */
2798     if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2799         goto fail;
2800
2801     mxf_handle_missing_index_segment(mxf);
2802     if ((ret = mxf_compute_index_tables(mxf)) < 0)
2803         goto fail;
2804
2805     if (mxf->nb_index_tables > 1) {
2806         /* TODO: look up which IndexSID to use via EssenceContainerData */
2807         av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2808                mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2809     } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2810         av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2811         ret = AVERROR_INVALIDDATA;
2812         goto fail;
2813     }
2814
2815     mxf_handle_small_eubc(s);
2816
2817     return 0;
2818 fail:
2819     mxf_read_close(s);
2820
2821     return ret;
2822 }
2823
2824 /**
2825  * Sets mxf->current_edit_unit based on what offset we're currently at.
2826  * @return next_ofs if OK, <0 on error
2827  */
2828 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2829 {
2830     int64_t last_ofs = -1, next_ofs = -1;
2831     MXFIndexTable *t = &mxf->index_tables[0];
2832
2833     /* this is called from the OP1a demuxing logic, which means there
2834      * may be no index tables */
2835     if (mxf->nb_index_tables <= 0)
2836         return -1;
2837
2838     /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2839     while (mxf->current_edit_unit >= 0) {
2840         if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2841             return -1;
2842
2843         if (next_ofs <= last_ofs) {
2844             /* large next_ofs didn't change or current_edit_unit wrapped
2845              * around this fixes the infinite loop on zzuf3.mxf */
2846             av_log(mxf->fc, AV_LOG_ERROR,
2847                    "next_ofs didn't change. not deriving packet timestamps\n");
2848             return -1;
2849         }
2850
2851         if (next_ofs > current_offset)
2852             break;
2853
2854         last_ofs = next_ofs;
2855         mxf->current_edit_unit++;
2856     }
2857
2858     /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2859     if (mxf->current_edit_unit < 0)
2860         return -1;
2861
2862     return next_ofs;
2863 }
2864
2865 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
2866                                     uint64_t *sample_count)
2867 {
2868     int i, total = 0, size = 0;
2869     AVStream *st = mxf->fc->streams[stream_index];
2870     MXFTrack *track = st->priv_data;
2871     AVRational time_base = av_inv_q(track->edit_rate);
2872     AVRational sample_rate = av_inv_q(st->time_base);
2873     const MXFSamplesPerFrame *spf = NULL;
2874
2875     if ((sample_rate.num / sample_rate.den) == 48000)
2876         spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2877     if (!spf) {
2878         int remainder = (sample_rate.num * time_base.num) %
2879                         (time_base.den * sample_rate.den);
2880         *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2881                                         av_mul_q(sample_rate, time_base)));
2882         if (remainder)
2883             av_log(mxf->fc, AV_LOG_WARNING,
2884                    "seeking detected on stream #%d with time base (%d/%d) and "
2885                    "sample rate (%d/%d), audio pts won't be accurate.\n",
2886                    stream_index, time_base.num, time_base.den,
2887                    sample_rate.num, sample_rate.den);
2888         return 0;
2889     }
2890
2891     while (spf->samples_per_frame[size]) {
2892         total += spf->samples_per_frame[size];
2893         size++;
2894     }
2895
2896     av_assert2(size);
2897
2898     *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2899     for (i = 0; i < mxf->current_edit_unit % size; i++) {
2900         *sample_count += spf->samples_per_frame[i];
2901     }
2902
2903     return 0;
2904 }
2905
2906 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec,
2907                              AVPacket *pkt)
2908 {
2909     MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2910     int64_t bits_per_sample = codec->bits_per_coded_sample;
2911
2912     if (!bits_per_sample)
2913         bits_per_sample = av_get_bits_per_sample(codec->codec_id);
2914
2915     pkt->pts = track->sample_count;
2916
2917     if (   codec->channels <= 0
2918         || bits_per_sample <= 0
2919         || codec->channels * (int64_t)bits_per_sample < 8)
2920         return AVERROR(EINVAL);
2921     track->sample_count += pkt->size / (codec->channels * (int64_t)bits_per_sample / 8);
2922     return 0;
2923 }
2924
2925 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2926 {
2927     KLVPacket klv;
2928     MXFContext *mxf = s->priv_data;
2929     int ret;
2930
2931     while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
2932         PRINT_KEY(s, "read packet", klv.key);
2933         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2934         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2935             ret = mxf_decrypt_triplet(s, pkt, &klv);
2936             if (ret < 0) {
2937                 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2938                 return ret;
2939             }
2940             return 0;
2941         }
2942         if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2943             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2944             int index = mxf_get_stream_index(s, &klv);
2945             int64_t next_ofs, next_klv;
2946             AVStream *st;
2947             MXFTrack *track;
2948             AVCodecContext *codec;
2949
2950             if (index < 0) {
2951                 av_log(s, AV_LOG_ERROR,
2952                        "error getting stream index %"PRIu32"\n",
2953                        AV_RB32(klv.key + 12));
2954                 goto skip;
2955             }
2956
2957             st = s->streams[index];
2958             track = st->priv_data;
2959
2960             if (s->streams[index]->discard == AVDISCARD_ALL)
2961                 goto skip;
2962
2963             next_klv = avio_tell(s->pb) + klv.length;
2964             next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2965
2966             if (next_ofs >= 0 && next_klv > next_ofs) {
2967                 /* if this check is hit then it's possible OPAtom was treated as OP1a
2968                  * truncate the packet since it's probably very large (>2 GiB is common) */
2969                 avpriv_request_sample(s,
2970                                       "OPAtom misinterpreted as OP1a? "
2971                                       "KLV for edit unit %i extending into "
2972                                       "next edit unit",
2973                                       mxf->current_edit_unit);
2974                 klv.length = next_ofs - avio_tell(s->pb);
2975             }
2976
2977             /* check for 8 channels AES3 element */
2978             if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2979                 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
2980                                               pkt, klv.length);
2981                 if (ret < 0) {
2982                     av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2983                     return ret;
2984                 }
2985             } else {
2986                 ret = av_get_packet(s->pb, pkt, klv.length);
2987                 if (ret < 0)
2988                     return ret;
2989             }
2990             pkt->stream_index = index;
2991             pkt->pos = klv.offset;
2992
2993             codec = st->codec;
2994
2995             if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2996                 /* mxf->current_edit_unit good - see if we have an
2997                  * index table to derive timestamps from */
2998                 MXFIndexTable *t = &mxf->index_tables[0];
2999
3000                 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
3001                     pkt->dts = mxf->current_edit_unit + t->first_dts;
3002                     pkt->pts = t->ptses[mxf->current_edit_unit];
3003                 } else if (track->intra_only) {
3004                     /* intra-only -> PTS = EditUnit.
3005                      * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3006                     pkt->pts = mxf->current_edit_unit;
3007                 }
3008             } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3009                 ret = mxf_set_audio_pts(mxf, codec, pkt);
3010                 if (ret < 0)
3011                     return ret;
3012             }
3013
3014             /* seek for truncated packets */
3015             avio_seek(s->pb, next_klv, SEEK_SET);
3016
3017             return 0;
3018         } else
3019         skip:
3020             avio_skip(s->pb, klv.length);
3021     }
3022     return avio_feof(s->pb) ? AVERROR_EOF : ret;
3023 }
3024
3025 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3026 {
3027     MXFContext *mxf = s->priv_data;
3028     int ret, size;
3029     int64_t ret64, pos, next_pos;
3030     AVStream *st;
3031     MXFIndexTable *t;
3032     int edit_units;
3033
3034     if (mxf->op != OPAtom)
3035         return mxf_read_packet_old(s, pkt);
3036
3037     // If we have no streams then we basically are at EOF
3038     if (s->nb_streams < 1)
3039         return AVERROR_EOF;
3040
3041     /* OPAtom - clip wrapped demuxing */
3042     /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
3043     st = s->streams[0];
3044     t = &mxf->index_tables[0];
3045
3046     if (mxf->current_edit_unit >= st->duration)
3047         return AVERROR_EOF;
3048
3049     edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
3050
3051     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
3052         return ret;
3053
3054     /* compute size by finding the next edit unit or the end of the essence container
3055      * not pretty, but it works */
3056     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
3057         (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3058         av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3059         return AVERROR_INVALIDDATA;
3060     }
3061
3062     if ((size = next_pos - pos) <= 0) {
3063         av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
3064         return AVERROR_INVALIDDATA;
3065     }
3066
3067     if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
3068         return ret64;
3069
3070     if ((size = av_get_packet(s->pb, pkt, size)) < 0)
3071         return size;
3072
3073     pkt->stream_index = 0;
3074
3075     if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
3076         mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
3077         pkt->dts = mxf->current_edit_unit + t->first_dts;
3078         pkt->pts = t->ptses[mxf->current_edit_unit];
3079     } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3080         int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
3081         if (ret < 0)
3082             return ret;
3083     }
3084
3085     mxf->current_edit_unit += edit_units;
3086
3087     return 0;
3088 }
3089
3090 static int mxf_read_close(AVFormatContext *s)
3091 {
3092     MXFContext *mxf = s->priv_data;
3093     int i;
3094
3095     av_freep(&mxf->packages_refs);
3096
3097     for (i = 0; i < s->nb_streams; i++)
3098         s->streams[i]->priv_data = NULL;
3099
3100     for (i = 0; i < mxf->metadata_sets_count; i++) {
3101         mxf_free_metadataset(mxf->metadata_sets + i, 1);
3102     }
3103     av_freep(&mxf->partitions);
3104     av_freep(&mxf->metadata_sets);
3105     av_freep(&mxf->aesc);
3106     av_freep(&mxf->local_tags);
3107
3108     if (mxf->index_tables) {
3109         for (i = 0; i < mxf->nb_index_tables; i++) {
3110             av_freep(&mxf->index_tables[i].segments);
3111             av_freep(&mxf->index_tables[i].ptses);
3112             av_freep(&mxf->index_tables[i].fake_index);
3113             av_freep(&mxf->index_tables[i].offsets);
3114         }
3115     }
3116     av_freep(&mxf->index_tables);
3117
3118     return 0;
3119 }
3120
3121 static int mxf_probe(AVProbeData *p) {
3122     const uint8_t *bufp = p->buf;
3123     const uint8_t *end = p->buf + p->buf_size;
3124
3125     if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3126         return 0;
3127
3128     /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3129     end -= sizeof(mxf_header_partition_pack_key);
3130
3131     for (; bufp < end;) {
3132         if (!((bufp[13] - 1) & 0xF2)){
3133             if (AV_RN32(bufp   ) == AV_RN32(mxf_header_partition_pack_key   ) &&
3134                 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3135                 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3136                 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3137                 return AVPROBE_SCORE_MAX;
3138             bufp ++;
3139         } else
3140             bufp += 10;
3141     }
3142
3143     return 0;
3144 }
3145
3146 /* rudimentary byte seek */
3147 /* XXX: use MXF Index */
3148 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3149 {
3150     AVStream *st = s->streams[stream_index];
3151     int64_t seconds;
3152     MXFContext* mxf = s->priv_data;
3153     int64_t seekpos;
3154     int i, ret;
3155     MXFIndexTable *t;
3156     MXFTrack *source_track = st->priv_data;
3157
3158     /* if audio then truncate sample_time to EditRate */
3159     if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
3160         sample_time = av_rescale_q(sample_time, st->time_base,
3161                                    av_inv_q(source_track->edit_rate));
3162
3163     if (mxf->nb_index_tables <= 0) {
3164     if (!s->bit_rate)
3165         return AVERROR_INVALIDDATA;
3166     if (sample_time < 0)
3167         sample_time = 0;
3168     seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3169
3170     seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3171     if (seekpos < 0)
3172         return seekpos;
3173
3174     ff_update_cur_dts(s, st, sample_time);
3175     mxf->current_edit_unit = sample_time;
3176     } else {
3177         t = &mxf->index_tables[0];
3178
3179         /* clamp above zero, else ff_index_search_timestamp() returns negative
3180          * this also means we allow seeking before the start */
3181         sample_time = FFMAX(sample_time, 0);
3182
3183         if (t->fake_index) {
3184             /* behave as if we have a proper index */
3185             if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3186                 return sample_time;
3187             /* get the stored order index from the display order index */
3188             sample_time += t->offsets[sample_time];
3189         } else {
3190             /* no IndexEntryArray (one or more CBR segments)
3191              * make sure we don't seek past the end */
3192             sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3193         }
3194
3195         if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
3196             return ret;
3197
3198         ff_update_cur_dts(s, st, sample_time);
3199         mxf->current_edit_unit = sample_time;
3200         avio_seek(s->pb, seekpos, SEEK_SET);
3201     }
3202
3203     // Update all tracks sample count
3204     for (i = 0; i < s->nb_streams; i++) {
3205         AVStream *cur_st = s->streams[i];
3206         MXFTrack *cur_track = cur_st->priv_data;
3207         uint64_t current_sample_count = 0;
3208         if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3209             ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
3210             if (ret < 0)
3211                 return ret;
3212
3213             cur_track->sample_count = current_sample_count;
3214         }
3215     }
3216     return 0;
3217 }
3218
3219 AVInputFormat ff_mxf_demuxer = {
3220     .name           = "mxf",
3221     .long_name      = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3222     .flags          = AVFMT_SEEK_TO_PTS,
3223     .priv_data_size = sizeof(MXFContext),
3224     .read_probe     = mxf_probe,
3225     .read_header    = mxf_read_header,
3226     .read_packet    = mxf_read_packet,
3227     .read_close     = mxf_read_close,
3228     .read_seek      = mxf_read_seek,
3229 };