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