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