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