git.sesse.net Git - ffmpeg/blob - libavformat/mxfdec.c

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