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