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 = nb_segments = 0; i < mxf->metadata_sets_count; i++) {
1352         if (mxf->metadata_sets[i]->type == IndexTableSegment) {
1353             MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1354             if (s->edit_unit_byte_count || s->nb_index_entries)
1355                 unsorted_segments[nb_segments++] = s;
1356             else
1357                 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1358                        s->index_sid, s->index_start_position);
1359         }
1360     }
1361
1362     if (!nb_segments) {
1363         av_freep(sorted_segments);
1364         av_free(unsorted_segments);
1365         return AVERROR_INVALIDDATA;
1366     }
1367
1368     *nb_sorted_segments = 0;
1369
1370     /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1371     for (i = 0; i < nb_segments; i++) {
1372         int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1373         uint64_t best_index_duration = 0;
1374
1375         for (j = 0; j < nb_segments; j++) {
1376             MXFIndexTableSegment *s = unsorted_segments[j];
1377
1378             /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1379              * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1380              * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1381              */
1382             if ((i == 0 ||
1383                  s->body_sid >  last_body_sid ||
1384                  s->body_sid == last_body_sid && s->index_sid >  last_index_sid ||
1385                  s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1386                 (best == -1 ||
1387                  s->body_sid <  best_body_sid ||
1388                  s->body_sid == best_body_sid && s->index_sid <  best_index_sid ||
1389                  s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position <  best_index_start ||
1390                  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)) {
1391                 best             = j;
1392                 best_body_sid    = s->body_sid;
1393                 best_index_sid   = s->index_sid;
1394                 best_index_start = s->index_start_position;
1395                 best_index_duration = s->index_duration;
1396             }
1397         }
1398
1399         /* no suitable entry found -> we're done */
1400         if (best == -1)
1401             break;
1402
1403         (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1404         last_body_sid    = best_body_sid;
1405         last_index_sid   = best_index_sid;
1406         last_index_start = best_index_start;
1407     }
1408
1409     av_free(unsorted_segments);
1410
1411     return 0;
1412 }
1413
1414 /**
1415  * Computes the absolute file offset of the given essence container offset
1416  */
1417 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
1418 {
1419     MXFPartition *last_p = NULL;
1420     int a, b, m, m0;
1421
1422     if (offset < 0)
1423         return AVERROR(EINVAL);
1424
1425     a = -1;
1426     b = mxf->partitions_count;
1427
1428     while (b - a > 1) {
1429         m0 = m = (a + b) >> 1;
1430
1431         while (m < b && mxf->partitions[m].body_sid != body_sid)
1432             m++;
1433
1434         if (m < b && mxf->partitions[m].body_offset <= offset)
1435             a = m;
1436         else
1437             b = m0;
1438     }
1439
1440     if (a >= 0)
1441         last_p = &mxf->partitions[a];
1442
1443     if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1444         *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1445         if (partition_out)
1446             *partition_out = last_p;
1447         return 0;
1448     }
1449
1450     av_log(mxf->fc, AV_LOG_ERROR,
1451            "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1452            offset, body_sid);
1453
1454     return AVERROR_INVALIDDATA;
1455 }
1456
1457 /**
1458  * Returns the end position of the essence container with given BodySID, or zero if unknown
1459  */
1460 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1461 {
1462     int x;
1463     int64_t ret = 0;
1464
1465     for (x = 0; x < mxf->partitions_count; x++) {
1466         MXFPartition *p = &mxf->partitions[x];
1467
1468         if (p->body_sid != body_sid)
1469             continue;
1470
1471         if (!p->essence_length)
1472             return 0;
1473
1474         ret = p->essence_offset + p->essence_length;
1475     }
1476
1477     return ret;
1478 }
1479
1480 /* EditUnit -> absolute offset */
1481 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)
1482 {
1483     int i;
1484     int64_t offset_temp = 0;
1485
1486     edit_unit = av_rescale_q(edit_unit, index_table->segments[0]->index_edit_rate, edit_rate);
1487
1488     for (i = 0; i < index_table->nb_segments; i++) {
1489         MXFIndexTableSegment *s = index_table->segments[i];
1490
1491         edit_unit = FFMAX(edit_unit, s->index_start_position);  /* clamp if trying to seek before start */
1492
1493         if (edit_unit < s->index_start_position + s->index_duration) {
1494             int64_t index = edit_unit - s->index_start_position;
1495
1496             if (s->edit_unit_byte_count)
1497                 offset_temp += s->edit_unit_byte_count * index;
1498             else {
1499                 if (s->nb_index_entries == 2 * s->index_duration + 1)
1500                     index *= 2;     /* Avid index */
1501
1502                 if (index < 0 || index >= s->nb_index_entries) {
1503                     av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1504                            index_table->index_sid, s->index_start_position);
1505                     return AVERROR_INVALIDDATA;
1506                 }
1507
1508                 offset_temp = s->stream_offset_entries[index];
1509             }
1510
1511             if (edit_unit_out)
1512                 *edit_unit_out = av_rescale_q(edit_unit, edit_rate, s->index_edit_rate);
1513
1514             return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out, partition_out);
1515         } else {
1516             /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1517             offset_temp += s->edit_unit_byte_count * s->index_duration;
1518         }
1519     }
1520
1521     if (nag)
1522         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);
1523
1524     return AVERROR_INVALIDDATA;
1525 }
1526
1527 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1528 {
1529     int i, j, x;
1530     int8_t max_temporal_offset = -128;
1531     uint8_t *flags;
1532
1533     /* first compute how many entries we have */
1534     for (i = 0; i < index_table->nb_segments; i++) {
1535         MXFIndexTableSegment *s = index_table->segments[i];
1536
1537         if (!s->nb_index_entries) {
1538             index_table->nb_ptses = 0;
1539             return 0;                               /* no TemporalOffsets */
1540         }
1541
1542         if (s->index_duration > INT_MAX - index_table->nb_ptses) {
1543             index_table->nb_ptses = 0;
1544             av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration is too large\n", s->index_sid);
1545             return 0;
1546         }
1547
1548         index_table->nb_ptses += s->index_duration;
1549     }
1550
1551     /* paranoid check */
1552     if (index_table->nb_ptses <= 0)
1553         return 0;
1554
1555     if (!(index_table->ptses      = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1556         !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1557         !(index_table->offsets    = av_calloc(index_table->nb_ptses, sizeof(int8_t))) ||
1558         !(flags                   = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) {
1559         av_freep(&index_table->ptses);
1560         av_freep(&index_table->fake_index);
1561         av_freep(&index_table->offsets);
1562         return AVERROR(ENOMEM);
1563     }
1564
1565     /* we may have a few bad TemporalOffsets
1566      * make sure the corresponding PTSes don't have the bogus value 0 */
1567     for (x = 0; x < index_table->nb_ptses; x++)
1568         index_table->ptses[x] = AV_NOPTS_VALUE;
1569
1570     /**
1571      * We have this:
1572      *
1573      * x  TemporalOffset
1574      * 0:  0
1575      * 1:  1
1576      * 2:  1
1577      * 3: -2
1578      * 4:  1
1579      * 5:  1
1580      * 6: -2
1581      *
1582      * We want to transform it into this:
1583      *
1584      * x  DTS PTS
1585      * 0: -1   0
1586      * 1:  0   3
1587      * 2:  1   1
1588      * 3:  2   2
1589      * 4:  3   6
1590      * 5:  4   4
1591      * 6:  5   5
1592      *
1593      * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1594      * then settings mxf->first_dts = -max(TemporalOffset[x]).
1595      * The latter makes DTS <= PTS.
1596      */
1597     for (i = x = 0; i < index_table->nb_segments; i++) {
1598         MXFIndexTableSegment *s = index_table->segments[i];
1599         int index_delta = 1;
1600         int n = s->nb_index_entries;
1601
1602         if (s->nb_index_entries == 2 * s->index_duration + 1) {
1603             index_delta = 2;    /* Avid index */
1604             /* ignore the last entry - it's the size of the essence container */
1605             n--;
1606         }
1607
1608         for (j = 0; j < n; j += index_delta, x++) {
1609             int offset = s->temporal_offset_entries[j] / index_delta;
1610             int index  = x + offset;
1611
1612             if (x >= index_table->nb_ptses) {
1613                 av_log(mxf->fc, AV_LOG_ERROR,
1614                        "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1615                        s->nb_index_entries, s->index_duration);
1616                 break;
1617             }
1618
1619             flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1620
1621             if (index < 0 || index >= index_table->nb_ptses) {
1622                 av_log(mxf->fc, AV_LOG_ERROR,
1623                        "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1624                        x, offset, index);
1625                 continue;
1626             }
1627
1628             index_table->offsets[x] = offset;
1629             index_table->ptses[index] = x;
1630             max_temporal_offset = FFMAX(max_temporal_offset, offset);
1631         }
1632     }
1633
1634     /* calculate the fake index table in display order */
1635     for (x = 0; x < index_table->nb_ptses; x++) {
1636         index_table->fake_index[x].timestamp = x;
1637         if (index_table->ptses[x] != AV_NOPTS_VALUE)
1638             index_table->fake_index[index_table->ptses[x]].flags = flags[x];
1639     }
1640     av_freep(&flags);
1641
1642     index_table->first_dts = -max_temporal_offset;
1643
1644     return 0;
1645 }
1646
1647 /**
1648  * Sorts and collects index table segments into index tables.
1649  * Also computes PTSes if possible.
1650  */
1651 static int mxf_compute_index_tables(MXFContext *mxf)
1652 {
1653     int i, j, k, ret, nb_sorted_segments;
1654     MXFIndexTableSegment **sorted_segments = NULL;
1655
1656     if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1657         nb_sorted_segments <= 0) {
1658         av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1659         return 0;
1660     }
1661
1662     /* sanity check and count unique BodySIDs/IndexSIDs */
1663     for (i = 0; i < nb_sorted_segments; i++) {
1664         if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1665             mxf->nb_index_tables++;
1666         else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1667             av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1668             ret = AVERROR_INVALIDDATA;
1669             goto finish_decoding_index;
1670         }
1671     }
1672
1673     mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1674                                          sizeof(*mxf->index_tables));
1675     if (!mxf->index_tables) {
1676         av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1677         ret = AVERROR(ENOMEM);
1678         goto finish_decoding_index;
1679     }
1680
1681     /* distribute sorted segments to index tables */
1682     for (i = j = 0; i < nb_sorted_segments; i++) {
1683         if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1684             /* next IndexSID */
1685             j++;
1686         }
1687
1688         mxf->index_tables[j].nb_segments++;
1689     }
1690
1691     for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1692         MXFIndexTable *t = &mxf->index_tables[j];
1693         MXFTrack *mxf_track = NULL;
1694
1695         t->segments = av_mallocz_array(t->nb_segments,
1696                                        sizeof(*t->segments));
1697
1698         if (!t->segments) {
1699             av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1700                    " pointer array\n");
1701             ret = AVERROR(ENOMEM);
1702             goto finish_decoding_index;
1703         }
1704
1705         if (sorted_segments[i]->index_start_position)
1706             av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1707                    sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1708
1709         memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1710         t->index_sid = sorted_segments[i]->index_sid;
1711         t->body_sid = sorted_segments[i]->body_sid;
1712
1713         if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1714             goto finish_decoding_index;
1715
1716         for (k = 0; k < mxf->fc->nb_streams; k++) {
1717             MXFTrack *track = mxf->fc->streams[k]->priv_data;
1718             if (track && track->index_sid == t->index_sid) {
1719                 mxf_track = track;
1720                 break;
1721             }
1722         }
1723
1724         /* fix zero IndexDurations */
1725         for (k = 0; k < t->nb_segments; k++) {
1726             if (!t->segments[k]->index_edit_rate.num || !t->segments[k]->index_edit_rate.den) {
1727                 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has invalid IndexEditRate\n",
1728                        t->index_sid, k);
1729                 if (mxf_track)
1730                     t->segments[k]->index_edit_rate = mxf_track->edit_rate;
1731             }
1732
1733             if (t->segments[k]->index_duration)
1734                 continue;
1735
1736             if (t->nb_segments > 1)
1737                 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1738                        t->index_sid, k);
1739
1740             if (!mxf_track) {
1741                 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1742                 break;
1743             }
1744
1745             /* assume the first stream's duration is reasonable
1746              * leave index_duration = 0 on further segments in case we have any (unlikely)
1747              */
1748             t->segments[k]->index_duration = mxf_track->original_duration;
1749             break;
1750         }
1751     }
1752
1753     ret = 0;
1754 finish_decoding_index:
1755     av_free(sorted_segments);
1756     return ret;
1757 }
1758
1759 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1760 {
1761     return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1762                             &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1763            mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1764                             &descriptor->essence_codec_ul)->id     != AV_CODEC_ID_NONE;
1765 }
1766
1767 static int mxf_uid_to_str(UID uid, char **str)
1768 {
1769     int i;
1770     char *p;
1771     p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1772     if (!p)
1773         return AVERROR(ENOMEM);
1774     for (i = 0; i < sizeof(UID); i++) {
1775         snprintf(p, 2 + 1, "%.2x", uid[i]);
1776         p += 2;
1777         if (i == 3 || i == 5 || i == 7 || i == 9) {
1778             snprintf(p, 1 + 1, "-");
1779             p++;
1780         }
1781     }
1782     return 0;
1783 }
1784
1785 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1786 {
1787     int i;
1788     char *p;
1789     p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1790     if (!p)
1791         return AVERROR(ENOMEM);
1792     snprintf(p, 2 + 1, "0x");
1793     p += 2;
1794     for (i = 0; i < sizeof(UID); i++) {
1795         snprintf(p, 2 + 1, "%.2X", ul[i]);
1796         p += 2;
1797
1798     }
1799     for (i = 0; i < sizeof(UID); i++) {
1800         snprintf(p, 2 + 1, "%.2X", uid[i]);
1801         p += 2;
1802     }
1803     return 0;
1804 }
1805
1806 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1807 {
1808     char *str;
1809     int ret;
1810     if (!package)
1811         return 0;
1812     if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1813         return ret;
1814     av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1815     return 0;
1816 }
1817
1818 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1819 {
1820     char buf[AV_TIMECODE_STR_SIZE];
1821     av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1822
1823     return 0;
1824 }
1825
1826 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
1827 {
1828     MXFStructuralComponent *component = NULL;
1829     MXFPulldownComponent *pulldown = NULL;
1830
1831     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1832     if (!component)
1833         return NULL;
1834
1835     switch (component->type) {
1836     case TimecodeComponent:
1837         return (MXFTimecodeComponent*)component;
1838     case PulldownComponent: /* timcode component may be located on a pulldown component */
1839         pulldown = (MXFPulldownComponent*)component;
1840         return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
1841     default:
1842         break;
1843     }
1844     return NULL;
1845 }
1846
1847 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
1848 {
1849     MXFPackage *package = NULL;
1850     int i;
1851
1852     for (i = 0; i < mxf->packages_count; i++) {
1853         package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1854         if (!package)
1855             continue;
1856
1857         if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
1858             return package;
1859     }
1860     return NULL;
1861 }
1862
1863 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1864 {
1865     MXFDescriptor *sub_descriptor = NULL;
1866     int i;
1867
1868     if (!descriptor)
1869         return NULL;
1870
1871     if (descriptor->type == MultipleDescriptor) {
1872         for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1873             sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1874
1875             if (!sub_descriptor) {
1876                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1877                 continue;
1878             }
1879             if (sub_descriptor->linked_track_id == track_id) {
1880                 return sub_descriptor;
1881             }
1882         }
1883     } else if (descriptor->type == Descriptor)
1884         return descriptor;
1885
1886     return NULL;
1887 }
1888
1889 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
1890 {
1891     MXFStructuralComponent *component = NULL;
1892     MXFPackage *package = NULL;
1893     MXFDescriptor *descriptor = NULL;
1894     int i;
1895
1896     if (!essence_group || !essence_group->structural_components_count)
1897         return NULL;
1898
1899     /* essence groups contains multiple representations of the same media,
1900        this return the first components with a valid Descriptor typically index 0 */
1901     for (i =0; i < essence_group->structural_components_count; i++){
1902         component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1903         if (!component)
1904             continue;
1905
1906         if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
1907             continue;
1908
1909         descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1910         if (descriptor)
1911             return component;
1912     }
1913     return NULL;
1914 }
1915
1916 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
1917 {
1918     MXFStructuralComponent *component = NULL;
1919
1920     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1921     if (!component)
1922         return NULL;
1923     switch (component->type) {
1924         case SourceClip:
1925             return component;
1926         case EssenceGroup:
1927             return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
1928         default:
1929             break;
1930     }
1931     return NULL;
1932 }
1933
1934 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
1935 {
1936     MXFTaggedValue *tag;
1937     int size, i;
1938     char *key = NULL;
1939
1940     for (i = 0; i < package->comment_count; i++) {
1941         tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
1942         if (!tag || !tag->name || !tag->value)
1943             continue;
1944
1945         size = strlen(tag->name) + 8 + 1;
1946         key = av_mallocz(size);
1947         if (!key)
1948             return AVERROR(ENOMEM);
1949
1950         snprintf(key, size, "comment_%s", tag->name);
1951         av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
1952     }
1953     return 0;
1954 }
1955
1956 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
1957 {
1958     MXFPackage *physical_package = NULL;
1959     MXFTrack *physical_track = NULL;
1960     MXFStructuralComponent *sourceclip = NULL;
1961     MXFTimecodeComponent *mxf_tc = NULL;
1962     int i, j, k;
1963     AVTimecode tc;
1964     int flags;
1965     int64_t start_position;
1966
1967     for (i = 0; i < source_track->sequence->structural_components_count; i++) {
1968         sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
1969         if (!sourceclip)
1970             continue;
1971
1972         if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
1973             break;
1974
1975         mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
1976
1977         /* the name of physical source package is name of the reel or tape */
1978         if (physical_package->name && physical_package->name[0])
1979             av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
1980
1981         /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
1982          * to the start_frame of the timecode component located on one of the tracks of the physical source package.
1983          */
1984         for (j = 0; j < physical_package->tracks_count; j++) {
1985             if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
1986                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1987                 continue;
1988             }
1989
1990             if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
1991                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1992                 continue;
1993             }
1994
1995         if (physical_track->edit_rate.num <= 0 ||
1996             physical_track->edit_rate.den <= 0) {
1997             av_log(mxf->fc, AV_LOG_WARNING,
1998                    "Invalid edit rate (%d/%d) found on structural"
1999                    " component #%d, defaulting to 25/1\n",
2000                    physical_track->edit_rate.num,
2001                    physical_track->edit_rate.den, i);
2002             physical_track->edit_rate = (AVRational){25, 1};
2003         }
2004
2005             for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
2006                 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
2007                     continue;
2008
2009                 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2010                 /* scale sourceclip start_position to match physical track edit rate */
2011                 start_position = av_rescale_q(sourceclip->start_position,
2012                                               physical_track->edit_rate,
2013                                               source_track->edit_rate);
2014
2015                 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
2016                     mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
2017                     return 0;
2018                 }
2019             }
2020         }
2021     }
2022
2023     return 0;
2024 }
2025
2026 static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
2027 {
2028     MXFStructuralComponent *component = NULL;
2029     const MXFCodecUL *codec_ul = NULL;
2030     MXFPackage tmp_package;
2031     AVStream *st;
2032     int j;
2033
2034     for (j = 0; j < track->sequence->structural_components_count; j++) {
2035         component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
2036         if (!component)
2037             continue;
2038         break;
2039     }
2040     if (!component)
2041         return 0;
2042
2043     st = avformat_new_stream(mxf->fc, NULL);
2044     if (!st) {
2045         av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
2046         return AVERROR(ENOMEM);
2047     }
2048
2049     st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
2050     st->codecpar->codec_id = AV_CODEC_ID_NONE;
2051     st->id = track->track_id;
2052
2053     memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
2054     memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
2055     mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
2056     if (track->name && track->name[0])
2057         av_dict_set(&st->metadata, "track_name", track->name, 0);
2058
2059     codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
2060     av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
2061     return 0;
2062 }
2063
2064 static int mxf_parse_structural_metadata(MXFContext *mxf)
2065 {
2066     MXFPackage *material_package = NULL;
2067     int i, j, k, ret;
2068
2069     av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
2070     /* TODO: handle multiple material packages (OP3x) */
2071     for (i = 0; i < mxf->packages_count; i++) {
2072         material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2073         if (material_package) break;
2074     }
2075     if (!material_package) {
2076         av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2077         return AVERROR_INVALIDDATA;
2078     }
2079
2080     mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2081     if (material_package->name && material_package->name[0])
2082         av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2083     mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2084
2085     for (i = 0; i < material_package->tracks_count; i++) {
2086         MXFPackage *source_package = NULL;
2087         MXFTrack *material_track = NULL;
2088         MXFTrack *source_track = NULL;
2089         MXFTrack *temp_track = NULL;
2090         MXFDescriptor *descriptor = NULL;
2091         MXFStructuralComponent *component = NULL;
2092         MXFTimecodeComponent *mxf_tc = NULL;
2093         UID *essence_container_ul = NULL;
2094         const MXFCodecUL *codec_ul = NULL;
2095         const MXFCodecUL *container_ul = NULL;
2096         const MXFCodecUL *pix_fmt_ul = NULL;
2097         AVStream *st;
2098         AVTimecode tc;
2099         int flags;
2100
2101         if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2102             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2103             continue;
2104         }
2105
2106         if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2107             mxf_tc = (MXFTimecodeComponent*)component;
2108             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2109             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2110                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2111             }
2112         }
2113
2114         if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2115             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2116             continue;
2117         }
2118
2119         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2120             component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2121             if (!component)
2122                 continue;
2123
2124             mxf_tc = (MXFTimecodeComponent*)component;
2125             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2126             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2127                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2128                 break;
2129             }
2130         }
2131
2132         /* TODO: handle multiple source clips, only finds first valid source clip */
2133         if(material_track->sequence->structural_components_count > 1)
2134             av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2135                        material_track->track_id, material_track->sequence->structural_components_count);
2136
2137         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2138             component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2139             if (!component)
2140                 continue;
2141
2142             source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2143             if (!source_package) {
2144                 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2145                 continue;
2146             }
2147             for (k = 0; k < source_package->tracks_count; k++) {
2148                 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2149                     av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2150                     ret = AVERROR_INVALIDDATA;
2151                     goto fail_and_free;
2152                 }
2153                 if (temp_track->track_id == component->source_track_id) {
2154                     source_track = temp_track;
2155                     break;
2156                 }
2157             }
2158             if (!source_track) {
2159                 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2160                 break;
2161             }
2162
2163             for (k = 0; k < mxf->essence_container_data_count; k++) {
2164                 MXFEssenceContainerData *essence_data;
2165
2166                 if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2167                     av_log(mxf->fc, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2168                     continue;
2169                 }
2170                 if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2171                     source_track->body_sid = essence_data->body_sid;
2172                     source_track->index_sid = essence_data->index_sid;
2173                     break;
2174                 }
2175             }
2176
2177             if(source_track && component)
2178                 break;
2179         }
2180         if (!source_track || !component || !source_package) {
2181             if((ret = mxf_add_metadata_stream(mxf, material_track)))
2182                 goto fail_and_free;
2183             continue;
2184         }
2185
2186         if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2187             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2188             ret = AVERROR_INVALIDDATA;
2189             goto fail_and_free;
2190         }
2191
2192         /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2193          * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2194         if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2195             av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2196             continue;
2197         }
2198
2199         st = avformat_new_stream(mxf->fc, NULL);
2200         if (!st) {
2201             av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2202             ret = AVERROR(ENOMEM);
2203             goto fail_and_free;
2204         }
2205         st->id = material_track->track_id;
2206         st->priv_data = source_track;
2207
2208         source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2209         descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2210
2211         /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2212          * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2213         if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2214             source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2215         else
2216             source_track->original_duration = st->duration = component->duration;
2217
2218         if (st->duration == -1)
2219             st->duration = AV_NOPTS_VALUE;
2220         st->start_time = component->start_position;
2221         if (material_track->edit_rate.num <= 0 ||
2222             material_track->edit_rate.den <= 0) {
2223             av_log(mxf->fc, AV_LOG_WARNING,
2224                    "Invalid edit rate (%d/%d) found on stream #%d, "
2225                    "defaulting to 25/1\n",
2226                    material_track->edit_rate.num,
2227                    material_track->edit_rate.den, st->index);
2228             material_track->edit_rate = (AVRational){25, 1};
2229         }
2230         avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2231
2232         /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2233          * the former is accessible via st->priv_data */
2234         source_track->edit_rate = material_track->edit_rate;
2235
2236         PRINT_KEY(mxf->fc, "data definition   ul", source_track->sequence->data_definition_ul);
2237         codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2238         st->codecpar->codec_type = codec_ul->id;
2239
2240         if (!descriptor) {
2241             av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2242             continue;
2243         }
2244         PRINT_KEY(mxf->fc, "essence codec     ul", descriptor->essence_codec_ul);
2245         PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2246         essence_container_ul = &descriptor->essence_container_ul;
2247         source_track->wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_kind(essence_container_ul);
2248         if (source_track->wrapping == UnknownWrapped)
2249             av_log(mxf->fc, AV_LOG_INFO, "wrapping of stream %d is unknown\n", st->index);
2250         /* HACK: replacing the original key with mxf_encrypted_essence_container
2251          * is not allowed according to s429-6, try to find correct information anyway */
2252         if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2253             av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2254             for (k = 0; k < mxf->metadata_sets_count; k++) {
2255                 MXFMetadataSet *metadata = mxf->metadata_sets[k];
2256                 if (metadata->type == CryptoContext) {
2257                     essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2258                     break;
2259                 }
2260             }
2261         }
2262
2263         /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2264         codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2265         st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2266         if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2267             codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2268             st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2269         }
2270
2271         av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2272                avcodec_get_name(st->codecpar->codec_id));
2273         for (k = 0; k < 16; k++) {
2274             av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2275                    descriptor->essence_codec_ul[k]);
2276             if (!(k+1 & 19) || k == 5)
2277                 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2278         }
2279         av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2280
2281         mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2282         if (source_package->name && source_package->name[0])
2283             av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2284         if (material_track->name && material_track->name[0])
2285             av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2286
2287         mxf_parse_physical_source_package(mxf, source_track, st);
2288
2289         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2290             source_track->intra_only = mxf_is_intra_only(descriptor);
2291             container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2292             if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2293                 st->codecpar->codec_id = container_ul->id;
2294             st->codecpar->width = descriptor->width;
2295             st->codecpar->height = descriptor->height; /* Field height, not frame height */
2296             switch (descriptor->frame_layout) {
2297                 case FullFrame:
2298                     st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2299                     break;
2300                 case OneField:
2301                     /* Every other line is stored and needs to be duplicated. */
2302                     av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2303                     break; /* The correct thing to do here is fall through, but by breaking we might be
2304                               able to decode some streams at half the vertical resolution, rather than not al all.
2305                               It's also for compatibility with the old behavior. */
2306                 case MixedFields:
2307                     break;
2308                 case SegmentedFrame:
2309                     st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2310                 case SeparateFields:
2311                     av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2312                            descriptor->video_line_map[0], descriptor->video_line_map[1],
2313                            descriptor->field_dominance);
2314                     if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2315                         /* Detect coded field order from VideoLineMap:
2316                          *  (even, even) => bottom field coded first
2317                          *  (even, odd)  => top field coded first
2318                          *  (odd, even)  => top field coded first
2319                          *  (odd, odd)   => bottom field coded first
2320                          */
2321                         if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2322                             switch (descriptor->field_dominance) {
2323                                 case MXF_FIELD_DOMINANCE_DEFAULT:
2324                                 case MXF_FIELD_DOMINANCE_FF:
2325                                     st->codecpar->field_order = AV_FIELD_TT;
2326                                     break;
2327                                 case MXF_FIELD_DOMINANCE_FL:
2328                                     st->codecpar->field_order = AV_FIELD_TB;
2329                                     break;
2330                                 default:
2331                                     avpriv_request_sample(mxf->fc,
2332                                                           "Field dominance %d support",
2333                                                           descriptor->field_dominance);
2334                             }
2335                         } else {
2336                             switch (descriptor->field_dominance) {
2337                                 case MXF_FIELD_DOMINANCE_DEFAULT:
2338                                 case MXF_FIELD_DOMINANCE_FF:
2339                                     st->codecpar->field_order = AV_FIELD_BB;
2340                                     break;
2341                                 case MXF_FIELD_DOMINANCE_FL:
2342                                     st->codecpar->field_order = AV_FIELD_BT;
2343                                     break;
2344                                 default:
2345                                     avpriv_request_sample(mxf->fc,
2346                                                           "Field dominance %d support",
2347                                                           descriptor->field_dominance);
2348                             }
2349                         }
2350                     }
2351                     /* Turn field height into frame height. */
2352                     st->codecpar->height *= 2;
2353                     break;
2354                 default:
2355                     av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2356             }
2357             if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2358                 st->codecpar->format = descriptor->pix_fmt;
2359                 if (st->codecpar->format == AV_PIX_FMT_NONE) {
2360                     pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2361                                                   &descriptor->essence_codec_ul);
2362                     st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2363                     if (st->codecpar->format== AV_PIX_FMT_NONE) {
2364                         st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2365                                                                    &descriptor->essence_codec_ul)->id;
2366                         if (!st->codecpar->codec_tag) {
2367                             /* support files created before RP224v10 by defaulting to UYVY422
2368                                if subsampling is 4:2:2 and component depth is 8-bit */
2369                             if (descriptor->horiz_subsampling == 2 &&
2370                                 descriptor->vert_subsampling == 1 &&
2371                                 descriptor->component_depth == 8) {
2372                                 st->codecpar->format = AV_PIX_FMT_UYVY422;
2373                             }
2374                         }
2375                     }
2376                 }
2377             }
2378             st->need_parsing = AVSTREAM_PARSE_HEADERS;
2379             if (material_track->sequence->origin) {
2380                 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2381             }
2382             if (source_track->sequence->origin) {
2383                 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2384             }
2385             if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2386                 st->display_aspect_ratio = descriptor->aspect_ratio;
2387         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2388             container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2389             /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2390             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))
2391                 st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2392             st->codecpar->channels = descriptor->channels;
2393
2394             if (descriptor->sample_rate.den > 0) {
2395                 st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2396                 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2397             } else {
2398                 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2399                        "found for stream #%d, time base forced to 1/48000\n",
2400                        descriptor->sample_rate.num, descriptor->sample_rate.den,
2401                        st->index);
2402                 avpriv_set_pts_info(st, 64, 1, 48000);
2403             }
2404
2405             /* if duration is set, rescale it from EditRate to SampleRate */
2406             if (st->duration != AV_NOPTS_VALUE)
2407                 st->duration = av_rescale_q(st->duration,
2408                                             av_inv_q(material_track->edit_rate),
2409                                             st->time_base);
2410
2411             /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2412             if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2413                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2414                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
2415                 else if (descriptor->bits_per_sample == 32)
2416                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
2417             } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2418                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2419                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
2420                 else if (descriptor->bits_per_sample == 32)
2421                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
2422             } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2423                 st->need_parsing = AVSTREAM_PARSE_FULL;
2424             }
2425             st->codecpar->bits_per_coded_sample = av_get_bits_per_sample(st->codecpar->codec_id);
2426         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2427             enum AVMediaType type;
2428             container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
2429             if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2430                 st->codecpar->codec_id = container_ul->id;
2431             type = avcodec_get_type(st->codecpar->codec_id);
2432             if (type == AVMEDIA_TYPE_SUBTITLE)
2433                 st->codecpar->codec_type = type;
2434             if (container_ul->desc)
2435                 av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
2436         }
2437         if (descriptor->extradata) {
2438             if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2439                 memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2440             }
2441         } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2442             int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2443                                                &descriptor->essence_codec_ul)->id;
2444             if (coded_width)
2445                 st->codecpar->width = coded_width;
2446             ret = ff_generate_avci_extradata(st);
2447             if (ret < 0)
2448                 return ret;
2449         }
2450         if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && source_track->wrapping != FrameWrapped) {
2451             /* TODO: decode timestamps */
2452             st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2453         }
2454     }
2455
2456     ret = 0;
2457 fail_and_free:
2458     return ret;
2459 }
2460
2461 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
2462 {
2463     struct tm time = { 0 };
2464     time.tm_year = (timestamp >> 48) - 1900;
2465     time.tm_mon  = (timestamp >> 40 & 0xFF) - 1;
2466     time.tm_mday = (timestamp >> 32 & 0xFF);
2467     time.tm_hour = (timestamp >> 24 & 0xFF);
2468     time.tm_min  = (timestamp >> 16 & 0xFF);
2469     time.tm_sec  = (timestamp >> 8  & 0xFF);
2470
2471     /* msvcrt versions of strftime calls the invalid parameter handler
2472      * (aborting the process if one isn't set) if the parameters are out
2473      * of range. */
2474     time.tm_mon  = av_clip(time.tm_mon,  0, 11);
2475     time.tm_mday = av_clip(time.tm_mday, 1, 31);
2476     time.tm_hour = av_clip(time.tm_hour, 0, 23);
2477     time.tm_min  = av_clip(time.tm_min,  0, 59);
2478     time.tm_sec  = av_clip(time.tm_sec,  0, 59);
2479
2480     return (int64_t)av_timegm(&time) * 1000000;
2481 }
2482
2483 #define SET_STR_METADATA(pb, name, str) do { \
2484     if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2485         return ret; \
2486     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2487 } while (0)
2488
2489 #define SET_UID_METADATA(pb, name, var, str) do { \
2490     avio_read(pb, var, 16); \
2491     if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2492         return ret; \
2493     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2494 } while (0)
2495
2496 #define SET_TS_METADATA(pb, name, var, str) do { \
2497     var = avio_rb64(pb); \
2498     if ((ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var)) < 0)) \
2499         return ret; \
2500 } while (0)
2501
2502 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2503 {
2504     MXFContext *mxf = arg;
2505     AVFormatContext *s = mxf->fc;
2506     int ret;
2507     UID uid = { 0 };
2508     char *str = NULL;
2509     uint64_t ts;
2510     switch (tag) {
2511     case 0x3C01:
2512         SET_STR_METADATA(pb, "company_name", str);
2513         break;
2514     case 0x3C02:
2515         SET_STR_METADATA(pb, "product_name", str);
2516         break;
2517     case 0x3C04:
2518         SET_STR_METADATA(pb, "product_version", str);
2519         break;
2520     case 0x3C05:
2521         SET_UID_METADATA(pb, "product_uid", uid, str);
2522         break;
2523     case 0x3C06:
2524         SET_TS_METADATA(pb, "modification_date", ts, str);
2525         break;
2526     case 0x3C08:
2527         SET_STR_METADATA(pb, "application_platform", str);
2528         break;
2529     case 0x3C09:
2530         SET_UID_METADATA(pb, "generation_uid", uid, str);
2531         break;
2532     case 0x3C0A:
2533         SET_UID_METADATA(pb, "uid", uid, str);
2534         break;
2535     }
2536     return 0;
2537 }
2538
2539 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2540 {
2541     MXFContext *mxf = arg;
2542     AVFormatContext *s = mxf->fc;
2543     int ret;
2544     char *str = NULL;
2545
2546     if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2547         SET_STR_METADATA(pb, "project_name", str);
2548     }
2549     return 0;
2550 }
2551
2552 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2553     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2554     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2555     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2556     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2557     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2558     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2559     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2560     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2561     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2562     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2563     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2564     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2565     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2566     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2567     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2568     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2569     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2570     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2571     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2572     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2573     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2574     { { 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 */
2575     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2576     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2577     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2578     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2579     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2580     { { 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 */
2581     { { 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 */
2582     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2583     { { 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 */
2584     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2585     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2586     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2587     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2588     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2589     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2590     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
2591     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2592 };
2593
2594 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2595 {
2596     switch (type){
2597     case MultipleDescriptor:
2598     case Descriptor:
2599         ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2600         ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2601         break;
2602     default:
2603         break;
2604     }
2605     return 0;
2606 }
2607
2608 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2609 {
2610     AVIOContext *pb = mxf->fc->pb;
2611     MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2612     uint64_t klv_end = avio_tell(pb) + klv->length;
2613
2614     if (!ctx)
2615         return AVERROR(ENOMEM);
2616     mxf_metadataset_init(ctx, type);
2617     while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2618         int ret;
2619         int tag = avio_rb16(pb);
2620         int size = avio_rb16(pb); /* KLV specified by 0x53 */
2621         uint64_t next = avio_tell(pb) + size;
2622         UID uid = {0};
2623
2624         av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2625         if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2626             av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2627             continue;
2628         }
2629         if (tag > 0x7FFF) { /* dynamic tag */
2630             int i;
2631             for (i = 0; i < mxf->local_tags_count; i++) {
2632                 int local_tag = AV_RB16(mxf->local_tags+i*18);
2633                 if (local_tag == tag) {
2634                     memcpy(uid, mxf->local_tags+i*18+2, 16);
2635                     av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2636                     PRINT_KEY(mxf->fc, "uid", uid);
2637                 }
2638             }
2639         }
2640         if (ctx_size && tag == 0x3C0A) {
2641             avio_read(pb, ctx->uid, 16);
2642         } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2643             if (ctx_size)
2644                 mxf_free_metadataset(&ctx, 1);
2645             return ret;
2646         }
2647
2648         /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2649          * it extending past the end of the KLV though (zzuf5.mxf). */
2650         if (avio_tell(pb) > klv_end) {
2651             if (ctx_size) {
2652                 ctx->type = type;
2653                 mxf_free_metadataset(&ctx, 1);
2654             }
2655
2656             av_log(mxf->fc, AV_LOG_ERROR,
2657                    "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2658                    tag, klv->offset);
2659             return AVERROR_INVALIDDATA;
2660         } else if (avio_tell(pb) <= next)   /* only seek forward, else this can loop for a long time */
2661             avio_seek(pb, next, SEEK_SET);
2662     }
2663     if (ctx_size) ctx->type = type;
2664     return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2665 }
2666
2667 /**
2668  * Matches any partition pack key, in other words:
2669  * - HeaderPartition
2670  * - BodyPartition
2671  * - FooterPartition
2672  * @return non-zero if the key is a partition pack key, zero otherwise
2673  */
2674 static int mxf_is_partition_pack_key(UID key)
2675 {
2676     //NOTE: this is a little lax since it doesn't constraint key[14]
2677     return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2678             key[13] >= 2 && key[13] <= 4;
2679 }
2680
2681 /**
2682  * Parses a metadata KLV
2683  * @return <0 on error, 0 otherwise
2684  */
2685 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2686                                      int ctx_size, enum MXFMetadataSetType type)
2687 {
2688     AVFormatContext *s = mxf->fc;
2689     int res;
2690     if (klv.key[5] == 0x53) {
2691         res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2692     } else {
2693         uint64_t next = avio_tell(s->pb) + klv.length;
2694         res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2695
2696         /* only seek forward, else this can loop for a long time */
2697         if (avio_tell(s->pb) > next) {
2698             av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2699                    klv.offset);
2700             return AVERROR_INVALIDDATA;
2701         }
2702
2703         avio_seek(s->pb, next, SEEK_SET);
2704     }
2705     if (res < 0) {
2706         av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2707         return res;
2708     }
2709     return 0;
2710 }
2711
2712 /**
2713  * Seeks to the previous partition and parses it, if possible
2714  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2715  */
2716 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2717 {
2718     AVIOContext *pb = mxf->fc->pb;
2719     KLVPacket klv;
2720     int64_t current_partition_ofs;
2721     int ret;
2722
2723     if (!mxf->current_partition ||
2724         mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2725         return 0;   /* we've parsed all partitions */
2726
2727     /* seek to previous partition */
2728     current_partition_ofs = mxf->current_partition->pack_ofs;   //includes run-in
2729     avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2730     mxf->current_partition = NULL;
2731
2732     av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
2733
2734     /* Make sure this is actually a PartitionPack, and if so parse it.
2735      * See deadlock2.mxf
2736      */
2737     if ((ret = klv_read_packet(&klv, pb)) < 0) {
2738         av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2739         return ret;
2740     }
2741
2742     if (!mxf_is_partition_pack_key(klv.key)) {
2743         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2744         return AVERROR_INVALIDDATA;
2745     }
2746
2747     /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2748      * can point to just before the current partition, causing klv_read_packet()
2749      * to sync back up to it. See deadlock3.mxf
2750      */
2751     if (klv.offset >= current_partition_ofs) {
2752         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2753                PRIx64 " indirectly points to itself\n", current_partition_ofs);
2754         return AVERROR_INVALIDDATA;
2755     }
2756
2757     if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2758         return ret;
2759
2760     return 1;
2761 }
2762
2763 /**
2764  * Called when essence is encountered
2765  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2766  */
2767 static int mxf_parse_handle_essence(MXFContext *mxf)
2768 {
2769     AVIOContext *pb = mxf->fc->pb;
2770     int64_t ret;
2771
2772     if (mxf->parsing_backward) {
2773         return mxf_seek_to_previous_partition(mxf);
2774     } else {
2775         if (!mxf->footer_partition) {
2776             av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
2777             return 0;
2778         }
2779
2780         av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
2781
2782         /* remember where we were so we don't end up seeking further back than this */
2783         mxf->last_forward_tell = avio_tell(pb);
2784
2785         if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2786             av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2787             return -1;
2788         }
2789
2790         /* seek to FooterPartition and parse backward */
2791         if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2792             av_log(mxf->fc, AV_LOG_ERROR,
2793                    "failed to seek to FooterPartition @ 0x%" PRIx64
2794                    " (%"PRId64") - partial file?\n",
2795                    mxf->run_in + mxf->footer_partition, ret);
2796             return ret;
2797         }
2798
2799         mxf->current_partition = NULL;
2800         mxf->parsing_backward = 1;
2801     }
2802
2803     return 1;
2804 }
2805
2806 /**
2807  * Called when the next partition or EOF is encountered
2808  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2809  */
2810 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2811 {
2812     return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2813 }
2814
2815 static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
2816 {
2817     for (int i = 0; i < s->nb_streams; i++) {
2818         MXFTrack *track = s->streams[i]->priv_data;
2819         if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
2820             return track->wrapping;
2821     }
2822     return UnknownWrapped;
2823 }
2824
2825 /**
2826  * Figures out the proper offset and length of the essence container in each partition
2827  */
2828 static void mxf_compute_essence_containers(AVFormatContext *s)
2829 {
2830     MXFContext *mxf = s->priv_data;
2831     int x;
2832
2833     for (x = 0; x < mxf->partitions_count; x++) {
2834         MXFPartition *p = &mxf->partitions[x];
2835         MXFWrappingScheme wrapping;
2836
2837         if (!p->body_sid)
2838             continue;       /* BodySID == 0 -> no essence */
2839
2840         /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
2841          * otherwise we point essence_offset at the key of the first essence KLV.
2842          */
2843
2844         wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
2845
2846         if (wrapping == ClipWrapped) {
2847             p->essence_offset = p->first_essence_klv.next_klv - p->first_essence_klv.length;
2848             p->essence_length = p->first_essence_klv.length;
2849         } else {
2850             p->essence_offset = p->first_essence_klv.offset;
2851
2852             /* essence container spans to the next partition */
2853             if (x < mxf->partitions_count - 1)
2854                 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2855
2856             if (p->essence_length < 0) {
2857                 /* next ThisPartition < essence_offset */
2858                 p->essence_length = 0;
2859                 av_log(mxf->fc, AV_LOG_ERROR,
2860                        "partition %i: bad ThisPartition = %"PRIX64"\n",
2861                        x+1, mxf->partitions[x+1].this_partition);
2862             }
2863         }
2864     }
2865 }
2866
2867 static int is_pcm(enum AVCodecID codec_id)
2868 {
2869     /* we only care about "normal" PCM codecs until we get samples */
2870     return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2871 }
2872
2873 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
2874 {
2875     int i;
2876     for (i = 0; i < mxf->nb_index_tables; i++)
2877         if (mxf->index_tables[i].index_sid == index_sid)
2878             return &mxf->index_tables[i];
2879     return NULL;
2880 }
2881
2882 /**
2883  * Deal with the case where for some audio atoms EditUnitByteCount is
2884  * very small (2, 4..). In those cases we should read more than one
2885  * sample per call to mxf_read_packet().
2886  */
2887 static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
2888 {
2889     MXFTrack *track = st->priv_data;
2890     MXFIndexTable *t;
2891
2892     if (!track)
2893         return;
2894     track->edit_units_per_packet = 1;
2895     if (track->wrapping != ClipWrapped)
2896         return;
2897
2898     t = mxf_find_index_table(mxf, track->index_sid);
2899
2900     /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2901     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO         ||
2902         !is_pcm(st->codecpar->codec_id)                        ||
2903         !t                                                     ||
2904         t->nb_segments != 1                                    ||
2905         t->segments[0]->edit_unit_byte_count >= 32)
2906         return;
2907
2908     /* arbitrarily default to 48 kHz PAL audio frame size */
2909     /* TODO: We could compute this from the ratio between the audio
2910      *       and video edit rates for 48 kHz NTSC we could use the
2911      *       1802-1802-1802-1802-1801 pattern. */
2912     track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
2913 }
2914
2915 /**
2916  * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
2917  */
2918 static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
2919 {
2920     MXFTrack *track = st->priv_data;
2921     MXFIndexTableSegment *segment = NULL;
2922     MXFPartition *p = NULL;
2923     int essence_partition_count = 0;
2924     int edit_unit_byte_count = 0;
2925     int i, ret;
2926
2927     if (!track || track->wrapping != ClipWrapped)
2928         return 0;
2929
2930     /* check if track already has an IndexTableSegment */
2931     for (i = 0; i < mxf->metadata_sets_count; i++) {
2932         if (mxf->metadata_sets[i]->type == IndexTableSegment) {
2933             MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
2934             if (s->body_sid == track->body_sid)
2935                 return 0;
2936         }
2937     }
2938
2939     /* find the essence partition */
2940     for (i = 0; i < mxf->partitions_count; i++) {
2941         /* BodySID == 0 -> no essence */
2942         if (mxf->partitions[i].body_sid != track->body_sid)
2943             continue;
2944
2945         p = &mxf->partitions[i];
2946         essence_partition_count++;
2947     }
2948
2949     /* only handle files with a single essence partition */
2950     if (essence_partition_count != 1)
2951         return 0;
2952
2953     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && is_pcm(st->codecpar->codec_id)) {
2954         edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
2955     } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
2956         edit_unit_byte_count = p->first_essence_klv.length / st->duration;
2957     }
2958
2959     if (edit_unit_byte_count <= 0)
2960         return 0;
2961
2962     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);
2963
2964     if (!(segment = av_mallocz(sizeof(*segment))))
2965         return AVERROR(ENOMEM);
2966
2967     if ((ret = mxf_add_metadata_set(mxf, segment))) {
2968         mxf_free_metadataset((MXFMetadataSet**)&segment, 1);
2969         return ret;
2970     }
2971
2972     /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
2973      * using the same SID for index is forbidden in MXF. */
2974     if (!track->index_sid)
2975         track->index_sid = track->body_sid;
2976
2977     segment->type = IndexTableSegment;
2978     /* stream will be treated as small EditUnitByteCount */
2979     segment->edit_unit_byte_count = edit_unit_byte_count;
2980     segment->index_start_position = 0;
2981     segment->index_duration = st->duration;
2982     segment->index_edit_rate = av_inv_q(st->time_base);
2983     segment->index_sid = track->index_sid;
2984     segment->body_sid = p->body_sid;
2985     return 0;
2986 }
2987
2988 static void mxf_read_random_index_pack(AVFormatContext *s)
2989 {
2990     MXFContext *mxf = s->priv_data;
2991     uint32_t length;
2992     int64_t file_size, max_rip_length, min_rip_length;
2993     KLVPacket klv;
2994
2995     if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
2996         return;
2997
2998     file_size = avio_size(s->pb);
2999
3000     /* S377m says to check the RIP length for "silly" values, without defining "silly".
3001      * The limit below assumes a file with nothing but partition packs and a RIP.
3002      * Before changing this, consider that a muxer may place each sample in its own partition.
3003      *
3004      * 105 is the size of the smallest possible PartitionPack
3005      * 12 is the size of each RIP entry
3006      * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3007      */
3008     max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3009     max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3010
3011     /* We're only interested in RIPs with at least two entries.. */
3012     min_rip_length = 16+1+24+4;
3013
3014     /* See S377m section 11 */
3015     avio_seek(s->pb, file_size - 4, SEEK_SET);
3016     length = avio_rb32(s->pb);
3017
3018     if (length < min_rip_length || length > max_rip_length)
3019         goto end;
3020     avio_seek(s->pb, file_size - length, SEEK_SET);
3021     if (klv_read_packet(&klv, s->pb) < 0 ||
3022         !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
3023         klv.length != length - 20)
3024         goto end;
3025
3026     avio_skip(s->pb, klv.length - 12);
3027     mxf->footer_partition = avio_rb64(s->pb);
3028
3029     /* sanity check */
3030     if (mxf->run_in + mxf->footer_partition >= file_size) {
3031         av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3032         mxf->footer_partition = 0;
3033     }
3034
3035 end:
3036     avio_seek(s->pb, mxf->run_in, SEEK_SET);
3037 }
3038
3039 static int mxf_read_header(AVFormatContext *s)
3040 {
3041     MXFContext *mxf = s->priv_data;
3042     KLVPacket klv;
3043     int64_t essence_offset = 0;
3044     int ret;
3045
3046     mxf->last_forward_tell = INT64_MAX;
3047
3048     if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
3049         av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3050         return AVERROR_INVALIDDATA;
3051     }
3052     avio_seek(s->pb, -14, SEEK_CUR);
3053     mxf->fc = s;
3054     mxf->run_in = avio_tell(s->pb);
3055
3056     mxf_read_random_index_pack(s);
3057
3058     while (!avio_feof(s->pb)) {
3059         const MXFMetadataReadTableEntry *metadata;
3060
3061         if (klv_read_packet(&klv, s->pb) < 0) {
3062             /* EOF - seek to previous partition or stop */
3063             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3064                 break;
3065             else
3066                 continue;
3067         }
3068
3069         PRINT_KEY(s, "read header", klv.key);
3070         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3071         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
3072             IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3073             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3074             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
3075             IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
3076             IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
3077
3078             if (!mxf->current_partition) {
3079                 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3080                 return AVERROR_INVALIDDATA;
3081             }
3082
3083             if (!mxf->current_partition->first_essence_klv.offset)
3084                 mxf->current_partition->first_essence_klv = klv;
3085
3086             if (!essence_offset)
3087                 essence_offset = klv.offset;
3088
3089             /* seek to footer, previous partition or stop */
3090             if (mxf_parse_handle_essence(mxf) <= 0)
3091                 break;
3092             continue;
3093         } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3094             /* next partition pack - keep going, seek to previous partition or stop */
3095             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3096                 break;
3097             else if (mxf->parsing_backward)
3098                 continue;
3099             /* we're still parsing forward. proceed to parsing this partition pack */
3100         }
3101
3102         for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3103             if (IS_KLV_KEY(klv.key, metadata->key)) {
3104                 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3105                     goto fail;
3106                 break;
3107             }
3108         }
3109         if (!metadata->read) {
3110             av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3111                             UID_ARG(klv.key));
3112             avio_skip(s->pb, klv.length);
3113         }
3114     }
3115     /* FIXME avoid seek */
3116     if (!essence_offset)  {
3117         av_log(s, AV_LOG_ERROR, "no essence\n");
3118         ret = AVERROR_INVALIDDATA;
3119         goto fail;
3120     }
3121     avio_seek(s->pb, essence_offset, SEEK_SET);
3122
3123     /* we need to do this before computing the index tables
3124      * to be able to fill in zero IndexDurations with st->duration */
3125     if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3126         goto fail;
3127
3128     for (int i = 0; i < s->nb_streams; i++)
3129         mxf_handle_missing_index_segment(mxf, s->streams[i]);
3130
3131     if ((ret = mxf_compute_index_tables(mxf)) < 0)
3132         goto fail;
3133
3134     if (mxf->nb_index_tables > 1) {
3135         /* TODO: look up which IndexSID to use via EssenceContainerData */
3136         av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3137                mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3138     } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3139         av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3140         ret = AVERROR_INVALIDDATA;
3141         goto fail;
3142     }
3143
3144     mxf_compute_essence_containers(s);
3145
3146     for (int i = 0; i < s->nb_streams; i++)
3147         mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
3148
3149     return 0;
3150 fail:
3151     mxf_read_close(s);
3152
3153     return ret;
3154 }
3155
3156 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3157 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3158 {
3159     int64_t a, b, m, offset;
3160     MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3161
3162     if (!t || track->original_duration <= 0)
3163         return -1;
3164
3165     a = -1;
3166     b = track->original_duration;
3167
3168     while (b - a > 1) {
3169         m = (a + b) >> 1;
3170         if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3171             return -1;
3172         if (offset < current_offset)
3173             a = m;
3174         else
3175             b = m;
3176     }
3177
3178     *edit_unit_out = b;
3179
3180     return 0;
3181 }
3182
3183 static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st,
3184                                         int64_t edit_unit)
3185 {
3186     int i, total = 0, size = 0;
3187     MXFTrack *track = st->priv_data;
3188     AVRational time_base = av_inv_q(track->edit_rate);
3189     AVRational sample_rate = av_inv_q(st->time_base);
3190     const MXFSamplesPerFrame *spf = NULL;
3191     int64_t sample_count;
3192
3193     // For non-audio sample_count equals current edit unit
3194     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
3195         return edit_unit;
3196
3197     if ((sample_rate.num / sample_rate.den) == 48000)
3198         spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
3199     if (!spf) {
3200         int remainder = (sample_rate.num * time_base.num) %
3201                         (time_base.den * sample_rate.den);
3202         if (remainder)
3203             av_log(mxf->fc, AV_LOG_WARNING,
3204                    "seeking detected on stream #%d with time base (%d/%d) and "
3205                    "sample rate (%d/%d), audio pts won't be accurate.\n",
3206                    st->index, time_base.num, time_base.den,
3207                    sample_rate.num, sample_rate.den);
3208         return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3209     }
3210
3211     while (spf->samples_per_frame[size]) {
3212         total += spf->samples_per_frame[size];
3213         size++;
3214     }
3215
3216     av_assert2(size);
3217
3218     sample_count = (edit_unit / size) * (uint64_t)total;
3219     for (i = 0; i < edit_unit % size; i++) {
3220         sample_count += spf->samples_per_frame[i];
3221     }
3222
3223     return sample_count;
3224 }
3225
3226 /**
3227  * Make sure track->sample_count is correct based on what offset we're currently at.
3228  * Also determine the next edit unit (or packet) offset.
3229  * @return next_ofs if OK, <0 on error
3230  */
3231 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3232 {
3233     int64_t next_ofs = -1;
3234     MXFTrack *track = st->priv_data;
3235     int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3236     int64_t new_edit_unit;
3237     MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3238
3239     if (!t || track->wrapping == UnknownWrapped)
3240         return -1;
3241
3242     if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3243         (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3244         av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3245         return -1;
3246     }
3247
3248     /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3249     if (next_ofs > current_offset)
3250         return next_ofs;
3251
3252     if (!resync) {
3253         av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3254         return -1;
3255     }
3256
3257     if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3258         av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3259         return -1;
3260     }
3261
3262     new_edit_unit--;
3263     track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3264     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);
3265
3266     return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3267 }
3268
3269 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3270                              AVPacket *pkt)
3271 {
3272     AVStream *st = mxf->fc->streams[pkt->stream_index];
3273     MXFTrack *track = st->priv_data;
3274     int64_t bits_per_sample = par->bits_per_coded_sample;
3275
3276     if (!bits_per_sample)
3277         bits_per_sample = av_get_bits_per_sample(par->codec_id);
3278
3279     pkt->pts = track->sample_count;
3280
3281     if (   par->channels <= 0
3282         || bits_per_sample <= 0
3283         || par->channels * (int64_t)bits_per_sample < 8)
3284         track->sample_count = mxf_compute_sample_count(mxf, st, av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate)) + 1);
3285     else
3286         track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3287
3288     return 0;
3289 }
3290
3291 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3292 {
3293     AVCodecParameters *par = st->codecpar;
3294     MXFTrack *track = st->priv_data;
3295
3296     if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3297         /* see if we have an index table to derive timestamps from */
3298         MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3299
3300         if (t && track->sample_count < t->nb_ptses) {
3301             pkt->dts = track->sample_count + t->first_dts;
3302             pkt->pts = t->ptses[track->sample_count];
3303         } else if (track->intra_only) {
3304             /* intra-only -> PTS = EditUnit.
3305              * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3306             pkt->pts = track->sample_count;
3307         }
3308         track->sample_count++;
3309     } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3310         int ret = mxf_set_audio_pts(mxf, par, pkt);
3311         if (ret < 0)
3312             return ret;
3313     } else if (track) {
3314         track->sample_count++;
3315     }
3316     return 0;
3317 }
3318
3319 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3320 {
3321     KLVPacket klv;
3322     MXFContext *mxf = s->priv_data;
3323     int ret;
3324
3325     while (1) {
3326         int64_t max_data_size;
3327         int64_t pos = avio_tell(s->pb);
3328
3329         if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3330             mxf->current_klv_data = (KLVPacket){{0}};
3331             ret = klv_read_packet(&klv, s->pb);
3332             if (ret < 0)
3333                 break;
3334             max_data_size = klv.length;
3335             pos = klv.next_klv - klv.length;
3336             PRINT_KEY(s, "read packet", klv.key);
3337             av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3338             if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3339                 ret = mxf_decrypt_triplet(s, pkt, &klv);
3340                 if (ret < 0) {
3341                     av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3342                     return ret;
3343                 }
3344                 return 0;
3345             }
3346         } else {
3347             klv = mxf->current_klv_data;
3348             max_data_size = klv.next_klv - pos;
3349         }
3350         if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3351             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3352             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3353             int body_sid = find_body_sid_by_offset(mxf, klv.offset);
3354             int index = mxf_get_stream_index(s, &klv, body_sid);
3355             int64_t next_ofs;
3356             AVStream *st;
3357             MXFTrack *track;
3358
3359             if (index < 0) {
3360                 av_log(s, AV_LOG_ERROR,
3361                        "error getting stream index %"PRIu32"\n",
3362                        AV_RB32(klv.key + 12));
3363                 goto skip;
3364             }
3365
3366             st = s->streams[index];
3367             track = st->priv_data;
3368
3369             if (s->streams[index]->discard == AVDISCARD_ALL)
3370                 goto skip;
3371
3372             next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
3373
3374             if (track->wrapping != FrameWrapped) {
3375                 int64_t size;
3376
3377                 if (next_ofs <= 0) {
3378                     // If we have no way to packetize the data, then return it in chunks...
3379                     if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
3380                         st->need_parsing = AVSTREAM_PARSE_FULL;
3381                         avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
3382                     }
3383                     size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
3384                 } else {
3385                     if ((size = next_ofs - pos) <= 0) {
3386                         av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
3387                         ret = AVERROR_INVALIDDATA;
3388                         goto skip;
3389                     }
3390                     // We must not overread, because the next edit unit might be in another KLV
3391                     if (size > max_data_size)
3392                         size = max_data_size;
3393                 }
3394
3395                 mxf->current_klv_data = klv;
3396                 klv.offset = pos;
3397                 klv.length = size;
3398                 klv.next_klv = klv.offset + klv.length;
3399             }
3400
3401             /* check for 8 channels AES3 element */
3402             if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3403                 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3404                                               pkt, klv.length);
3405                 if (ret < 0) {
3406                     av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3407                     mxf->current_klv_data = (KLVPacket){{0}};
3408                     return ret;
3409                 }
3410             } else {
3411                 ret = av_get_packet(s->pb, pkt, klv.length);
3412                 if (ret < 0) {
3413                     mxf->current_klv_data = (KLVPacket){{0}};
3414                     return ret;
3415                 }
3416             }
3417             pkt->stream_index = index;
3418             pkt->pos = klv.offset;
3419
3420             ret = mxf_set_pts(mxf, st, pkt);
3421             if (ret < 0) {
3422                 mxf->current_klv_data = (KLVPacket){{0}};
3423                 return ret;
3424             }
3425
3426             /* seek for truncated packets */
3427             avio_seek(s->pb, klv.next_klv, SEEK_SET);
3428
3429             return 0;
3430         } else {
3431         skip:
3432             avio_skip(s->pb, max_data_size);
3433             mxf->current_klv_data = (KLVPacket){{0}};
3434         }
3435     }
3436     return avio_feof(s->pb) ? AVERROR_EOF : ret;
3437 }
3438
3439 static int mxf_read_close(AVFormatContext *s)
3440 {
3441     MXFContext *mxf = s->priv_data;
3442     int i;
3443
3444     av_freep(&mxf->packages_refs);
3445     av_freep(&mxf->essence_container_data_refs);
3446
3447     for (i = 0; i < s->nb_streams; i++)
3448         s->streams[i]->priv_data = NULL;
3449
3450     for (i = 0; i < mxf->metadata_sets_count; i++) {
3451         mxf_free_metadataset(mxf->metadata_sets + i, 1);
3452     }
3453     av_freep(&mxf->partitions);
3454     av_freep(&mxf->metadata_sets);
3455     av_freep(&mxf->aesc);
3456     av_freep(&mxf->local_tags);
3457
3458     if (mxf->index_tables) {
3459         for (i = 0; i < mxf->nb_index_tables; i++) {
3460             av_freep(&mxf->index_tables[i].segments);
3461             av_freep(&mxf->index_tables[i].ptses);
3462             av_freep(&mxf->index_tables[i].fake_index);
3463             av_freep(&mxf->index_tables[i].offsets);
3464         }
3465     }
3466     av_freep(&mxf->index_tables);
3467
3468     return 0;
3469 }
3470
3471 static int mxf_probe(AVProbeData *p) {
3472     const uint8_t *bufp = p->buf;
3473     const uint8_t *end = p->buf + p->buf_size;
3474
3475     if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3476         return 0;
3477
3478     /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3479     end -= sizeof(mxf_header_partition_pack_key);
3480
3481     for (; bufp < end;) {
3482         if (!((bufp[13] - 1) & 0xF2)){
3483             if (AV_RN32(bufp   ) == AV_RN32(mxf_header_partition_pack_key   ) &&
3484                 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3485                 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3486                 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3487                 return AVPROBE_SCORE_MAX;
3488             bufp ++;
3489         } else
3490             bufp += 10;
3491     }
3492
3493     return 0;
3494 }
3495
3496 /* rudimentary byte seek */
3497 /* XXX: use MXF Index */
3498 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3499 {
3500     AVStream *st = s->streams[stream_index];
3501     int64_t seconds;
3502     MXFContext* mxf = s->priv_data;
3503     int64_t seekpos;
3504     int i, ret;
3505     MXFIndexTable *t;
3506     MXFTrack *source_track = st->priv_data;
3507
3508     if (!source_track)
3509         return 0;
3510
3511     /* if audio then truncate sample_time to EditRate */
3512     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
3513         sample_time = av_rescale_q(sample_time, st->time_base,
3514                                    av_inv_q(source_track->edit_rate));
3515
3516     if (mxf->nb_index_tables <= 0) {
3517         if (!s->bit_rate)
3518             return AVERROR_INVALIDDATA;
3519         if (sample_time < 0)
3520             sample_time = 0;
3521         seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3522
3523         seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3524         if (seekpos < 0)
3525             return seekpos;
3526
3527         ff_update_cur_dts(s, st, sample_time);
3528         mxf->current_klv_data = (KLVPacket){{0}};
3529     } else {
3530         MXFPartition *partition;
3531
3532         t = &mxf->index_tables[0];
3533         if (t->index_sid != source_track->index_sid) {
3534             /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
3535             for (i = 0; i < s->nb_streams; i++) {
3536                 MXFTrack *new_source_track = s->streams[i]->priv_data;
3537                 if (new_source_track && new_source_track->index_sid == t->index_sid) {
3538                     sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
3539                     source_track = new_source_track;
3540                     st = s->streams[i];
3541                     break;
3542                 }
3543             }
3544             if (i == s->nb_streams)
3545                 return AVERROR_INVALIDDATA;
3546         }
3547
3548         /* clamp above zero, else ff_index_search_timestamp() returns negative
3549          * this also means we allow seeking before the start */
3550         sample_time = FFMAX(sample_time, 0);
3551
3552         if (t->fake_index) {
3553             /* The first frames may not be keyframes in presentation order, so
3554              * we have to advance the target to be able to find the first
3555              * keyframe backwards... */
3556             if (!(flags & AVSEEK_FLAG_ANY) &&
3557                 (flags & AVSEEK_FLAG_BACKWARD) &&
3558                 t->ptses[0] != AV_NOPTS_VALUE &&
3559                 sample_time < t->ptses[0] &&
3560                 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3561                 sample_time = t->ptses[0];
3562
3563             /* behave as if we have a proper index */
3564             if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3565                 return sample_time;
3566             /* get the stored order index from the display order index */
3567             sample_time += t->offsets[sample_time];
3568         } else {
3569             /* no IndexEntryArray (one or more CBR segments)
3570              * make sure we don't seek past the end */
3571             sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3572         }
3573
3574         if (source_track->wrapping == UnknownWrapped)
3575             av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
3576
3577         if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
3578             return ret;
3579
3580         ff_update_cur_dts(s, st, sample_time);
3581         if (source_track->wrapping == ClipWrapped) {
3582             KLVPacket klv = partition->first_essence_klv;
3583             if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
3584                 av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
3585                 return AVERROR_INVALIDDATA;
3586             }
3587             mxf->current_klv_data = klv;
3588         } else {
3589             mxf->current_klv_data = (KLVPacket){{0}};
3590         }
3591         avio_seek(s->pb, seekpos, SEEK_SET);
3592     }
3593
3594     // Update all tracks sample count
3595     for (i = 0; i < s->nb_streams; i++) {
3596         AVStream *cur_st = s->streams[i];
3597         MXFTrack *cur_track = cur_st->priv_data;
3598         if (cur_track) {
3599             int64_t track_edit_unit = sample_time;
3600             if (st != cur_st)
3601                 mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
3602             cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
3603         }
3604     }
3605     return 0;
3606 }
3607
3608 AVInputFormat ff_mxf_demuxer = {
3609     .name           = "mxf",
3610     .long_name      = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3611     .flags          = AVFMT_SEEK_TO_PTS,
3612     .priv_data_size = sizeof(MXFContext),
3613     .read_probe     = mxf_probe,
3614     .read_header    = mxf_read_header,
3615     .read_packet    = mxf_read_packet,
3616     .read_close     = mxf_read_close,
3617     .read_seek      = mxf_read_seek,
3618 };