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