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