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

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