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