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