git.sesse.net Git - ffmpeg/blob - libavformat/mxfdec.c

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