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