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