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 //#define DEBUG
  47
  48 #include "libavutil/aes.h"
  49 #include "libavutil/mathematics.h"
  50 #include "libavcodec/bytestream.h"
  51 #include "libavutil/timecode.h"
  52 #include "avformat.h"
  53 #include "internal.h"
  54 #include "mxf.h"
  55
  56 typedef enum {
  57     Header,
  58     BodyPartition,
  59     Footer
  60 } MXFPartitionType;
  61
  62 typedef enum {
  63     OP1a = 1,
  64     OP1b,
  65     OP1c,
  66     OP2a,
  67     OP2b,
  68     OP2c,
  69     OP3a,
  70     OP3b,
  71     OP3c,
  72     OPAtom,
  73     OPSONYOpt,  /* FATE sample, violates the spec in places */
  74 } MXFOP;
  75
  76 typedef struct {
  77     int closed;
  78     int complete;
  79     MXFPartitionType type;
  80     uint64_t previous_partition;
  81     int index_sid;
  82     int body_sid;
  83     int64_t this_partition;
  84     int64_t essence_offset;         ///< absolute offset of essence
  85     int64_t essence_length;
  86     int32_t kag_size;
  87     int64_t header_byte_count;
  88     int64_t index_byte_count;
  89     int pack_length;
  90 } MXFPartition;
  91
  92 typedef struct {
  93     UID uid;
  94     enum MXFMetadataSetType type;
  95     UID source_container_ul;
  96 } MXFCryptoContext;
  97
  98 typedef struct {
  99     UID uid;
 100     enum MXFMetadataSetType type;
 101     UID source_package_uid;
 102     UID data_definition_ul;
 103     int64_t duration;
 104     int64_t start_position;
 105     int source_track_id;
 106 } MXFStructuralComponent;
 107
 108 typedef struct {
 109     UID uid;
 110     enum MXFMetadataSetType type;
 111     UID data_definition_ul;
 112     UID *structural_components_refs;
 113     int structural_components_count;
 114     int64_t duration;
 115 } MXFSequence;
 116
 117 typedef struct {
 118     UID uid;
 119     enum MXFMetadataSetType type;
 120     int drop_frame;
 121     int start_frame;
 122     struct AVRational rate;
 123     AVTimecode tc;
 124 } MXFTimecodeComponent;
 125
 126 typedef struct {
 127     UID uid;
 128     enum MXFMetadataSetType type;
 129     MXFSequence *sequence; /* mandatory, and only one */
 130     UID sequence_ref;
 131     int track_id;
 132     uint8_t track_number[4];
 133     AVRational edit_rate;
 134     int intra_only;
 135 } MXFTrack;
 136
 137 typedef struct {
 138     UID uid;
 139     enum MXFMetadataSetType type;
 140     UID essence_container_ul;
 141     UID essence_codec_ul;
 142     AVRational sample_rate;
 143     AVRational aspect_ratio;
 144     int width;
 145     int height; /* Field height, not frame height */
 146     int frame_layout; /* See MXFFrameLayout enum */
 147     int channels;
 148     int bits_per_sample;
 149     unsigned int component_depth;
 150     unsigned int horiz_subsampling;
 151     unsigned int vert_subsampling;
 152     UID *sub_descriptors_refs;
 153     int sub_descriptors_count;
 154     int linked_track_id;
 155     uint8_t *extradata;
 156     int extradata_size;
 157     enum AVPixelFormat pix_fmt;
 158 } MXFDescriptor;
 159
 160 typedef struct {
 161     UID uid;
 162     enum MXFMetadataSetType type;
 163     int edit_unit_byte_count;
 164     int index_sid;
 165     int body_sid;
 166     AVRational index_edit_rate;
 167     uint64_t index_start_position;
 168     uint64_t index_duration;
 169     int8_t *temporal_offset_entries;
 170     int *flag_entries;
 171     uint64_t *stream_offset_entries;
 172     int nb_index_entries;
 173 } MXFIndexTableSegment;
 174
 175 typedef struct {
 176     UID uid;
 177     enum MXFMetadataSetType type;
 178     UID package_uid;
 179     UID *tracks_refs;
 180     int tracks_count;
 181     MXFDescriptor *descriptor; /* only one */
 182     UID descriptor_ref;
 183 } MXFPackage;
 184
 185 typedef struct {
 186     UID uid;
 187     enum MXFMetadataSetType type;
 188 } MXFMetadataSet;
 189
 190 /* decoded index table */
 191 typedef struct {
 192     int index_sid;
 193     int body_sid;
 194     int nb_ptses;               /* number of PTSes or total duration of index */
 195     int64_t first_dts;          /* DTS = EditUnit + first_dts */
 196     int64_t *ptses;             /* maps EditUnit -> PTS */
 197     int nb_segments;
 198     MXFIndexTableSegment **segments;    /* sorted by IndexStartPosition */
 199     AVIndexEntry *fake_index;   /* used for calling ff_index_search_timestamp() */
 200 } MXFIndexTable;
 201
 202 typedef struct {
 203     MXFPartition *partitions;
 204     unsigned partitions_count;
 205     MXFOP op;
 206     UID *packages_refs;
 207     int packages_count;
 208     MXFMetadataSet **metadata_sets;
 209     int metadata_sets_count;
 210     AVFormatContext *fc;
 211     struct AVAES *aesc;
 212     uint8_t *local_tags;
 213     int local_tags_count;
 214     uint64_t footer_partition;
 215     KLVPacket current_klv_data;
 216     int current_klv_index;
 217     int run_in;
 218     MXFPartition *current_partition;
 219     int parsing_backward;
 220     int64_t last_forward_tell;
 221     int last_forward_partition;
 222     int current_edit_unit;
 223     int nb_index_tables;
 224     MXFIndexTable *index_tables;
 225     int edit_units_per_packet;      ///< how many edit units to read at a time (PCM, OPAtom)
 226 } MXFContext;
 227
 228 enum MXFWrappingScheme {
 229     Frame,
 230     Clip,
 231 };
 232
 233 /* NOTE: klv_offset is not set (-1) for local keys */
 234 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
 235
 236 typedef struct {
 237     const UID key;
 238     MXFMetadataReadFunc *read;
 239     int ctx_size;
 240     enum MXFMetadataSetType type;
 241 } MXFMetadataReadTableEntry;
 242
 243 static int mxf_read_close(AVFormatContext *s);
 244
 245 /* partial keys to match */
 246 static const uint8_t mxf_header_partition_pack_key[]       = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
 247 static const uint8_t mxf_essence_element_key[]             = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
 248 static const uint8_t mxf_avid_essence_element_key[]        = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
 249 static const uint8_t mxf_system_item_key[]                 = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04 };
 250 static const uint8_t mxf_klv_key[]                         = { 0x06,0x0e,0x2b,0x34 };
 251 /* complete keys to match */
 252 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 };
 253 static const uint8_t mxf_encrypted_triplet_key[]           = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
 254 static const uint8_t mxf_encrypted_essence_container[]     = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
 255 static const uint8_t mxf_sony_mpeg4_extradata[]            = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
 256
 257 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
 258
 259 static int64_t klv_decode_ber_length(AVIOContext *pb)
 260 {
 261     uint64_t size = avio_r8(pb);
 262     if (size & 0x80) { /* long form */
 263         int bytes_num = size & 0x7f;
 264         /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
 265         if (bytes_num > 8)
 266             return AVERROR_INVALIDDATA;
 267         size = 0;
 268         while (bytes_num--)
 269             size = size << 8 | avio_r8(pb);
 270     }
 271     return size;
 272 }
 273
 274 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
 275 {
 276     int i, b;
 277     for (i = 0; i < size && !url_feof(pb); i++) {
 278         b = avio_r8(pb);
 279         if (b == key[0])
 280             i = 0;
 281         else if (b != key[i])
 282             i = -1;
 283     }
 284     return i == size;
 285 }
 286
 287 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
 288 {
 289     if (!mxf_read_sync(pb, mxf_klv_key, 4))
 290         return AVERROR_INVALIDDATA;
 291     klv->offset = avio_tell(pb) - 4;
 292     memcpy(klv->key, mxf_klv_key, 4);
 293     avio_read(pb, klv->key + 4, 12);
 294     klv->length = klv_decode_ber_length(pb);
 295     return klv->length == -1 ? -1 : 0;
 296 }
 297
 298 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
 299 {
 300     int i;
 301
 302     for (i = 0; i < s->nb_streams; i++) {
 303         MXFTrack *track = s->streams[i]->priv_data;
 304         /* SMPTE 379M 7.3 */
 305         if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
 306             return i;
 307     }
 308     /* return 0 if only one stream, for OP Atom files with 0 as track number */
 309     return s->nb_streams == 1 ? 0 : -1;
 310 }
 311
 312 /* XXX: use AVBitStreamFilter */
 313 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
 314 {
 315     const uint8_t *buf_ptr, *end_ptr;
 316     uint8_t *data_ptr;
 317     int i;
 318
 319     if (length > 61444) /* worst case PAL 1920 samples 8 channels */
 320         return AVERROR_INVALIDDATA;
 321     length = av_get_packet(pb, pkt, length);
 322     if (length < 0)
 323         return length;
 324     data_ptr = pkt->data;
 325     end_ptr = pkt->data + length;
 326     buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
 327     for (; buf_ptr + st->codec->channels*4 <= end_ptr; ) {
 328         for (i = 0; i < st->codec->channels; i++) {
 329             uint32_t sample = bytestream_get_le32(&buf_ptr);
 330             if (st->codec->bits_per_coded_sample == 24)
 331                 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
 332             else
 333                 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
 334         }
 335         buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M
 336     }
 337     av_shrink_packet(pkt, data_ptr - pkt->data);
 338     return 0;
 339 }
 340
 341 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
 342 {
 343     static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
 344     MXFContext *mxf = s->priv_data;
 345     AVIOContext *pb = s->pb;
 346     int64_t end = avio_tell(pb) + klv->length;
 347     int64_t size;
 348     uint64_t orig_size;
 349     uint64_t plaintext_size;
 350     uint8_t ivec[16];
 351     uint8_t tmpbuf[16];
 352     int index;
 353
 354     if (!mxf->aesc && s->key && s->keylen == 16) {
 355         mxf->aesc = av_aes_alloc();
 356         if (!mxf->aesc)
 357             return AVERROR(ENOMEM);
 358         av_aes_init(mxf->aesc, s->key, 128, 1);
 359     }
 360     // crypto context
 361     avio_skip(pb, klv_decode_ber_length(pb));
 362     // plaintext offset
 363     klv_decode_ber_length(pb);
 364     plaintext_size = avio_rb64(pb);
 365     // source klv key
 366     klv_decode_ber_length(pb);
 367     avio_read(pb, klv->key, 16);
 368     if (!IS_KLV_KEY(klv, mxf_essence_element_key))
 369         return AVERROR_INVALIDDATA;
 370     index = mxf_get_stream_index(s, klv);
 371     if (index < 0)
 372         return AVERROR_INVALIDDATA;
 373     // source size
 374     klv_decode_ber_length(pb);
 375     orig_size = avio_rb64(pb);
 376     if (orig_size < plaintext_size)
 377         return AVERROR_INVALIDDATA;
 378     // enc. code
 379     size = klv_decode_ber_length(pb);
 380     if (size < 32 || size - 32 < orig_size)
 381         return AVERROR_INVALIDDATA;
 382     avio_read(pb, ivec, 16);
 383     avio_read(pb, tmpbuf, 16);
 384     if (mxf->aesc)
 385         av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
 386     if (memcmp(tmpbuf, checkv, 16))
 387         av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
 388     size -= 32;
 389     size = av_get_packet(pb, pkt, size);
 390     if (size < 0)
 391         return size;
 392     else if (size < plaintext_size)
 393         return AVERROR_INVALIDDATA;
 394     size -= plaintext_size;
 395     if (mxf->aesc)
 396         av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
 397                      &pkt->data[plaintext_size], size >> 4, ivec, 1);
 398     av_shrink_packet(pkt, orig_size);
 399     pkt->stream_index = index;
 400     avio_skip(pb, end - avio_tell(pb));
 401     return 0;
 402 }
 403
 404 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 405 {
 406     MXFContext *mxf = arg;
 407     int item_num = avio_rb32(pb);
 408     int item_len = avio_rb32(pb);
 409
 410     if (item_len != 18) {
 411         av_log_ask_for_sample(pb, "unsupported primer pack item length %d\n",
 412                               item_len);
 413         return AVERROR_PATCHWELCOME;
 414     }
 415     if (item_num > 65536) {
 416         av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
 417         return AVERROR_INVALIDDATA;
 418     }
 419     mxf->local_tags = av_calloc(item_num, item_len);
 420     if (!mxf->local_tags)
 421         return AVERROR(ENOMEM);
 422     mxf->local_tags_count = item_num;
 423     avio_read(pb, mxf->local_tags, item_num*item_len);
 424     return 0;
 425 }
 426
 427 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 428 {
 429     MXFContext *mxf = arg;
 430     MXFPartition *partition, *tmp_part;
 431     UID op;
 432     uint64_t footer_partition;
 433     uint32_t nb_essence_containers;
 434
 435     if (mxf->partitions_count+1 >= UINT_MAX / sizeof(*mxf->partitions))
 436         return AVERROR(ENOMEM);
 437
 438     tmp_part = av_realloc(mxf->partitions, (mxf->partitions_count + 1) * sizeof(*mxf->partitions));
 439     if (!tmp_part)
 440         return AVERROR(ENOMEM);
 441     mxf->partitions = tmp_part;
 442
 443     if (mxf->parsing_backward) {
 444         /* insert the new partition pack in the middle
 445          * this makes the entries in mxf->partitions sorted by offset */
 446         memmove(&mxf->partitions[mxf->last_forward_partition+1],
 447                 &mxf->partitions[mxf->last_forward_partition],
 448                 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
 449         partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
 450     } else {
 451         mxf->last_forward_partition++;
 452         partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
 453     }
 454
 455     memset(partition, 0, sizeof(*partition));
 456     mxf->partitions_count++;
 457     partition->pack_length = avio_tell(pb) - klv_offset + size;
 458
 459     switch(uid[13]) {
 460     case 2:
 461         partition->type = Header;
 462         break;
 463     case 3:
 464         partition->type = BodyPartition;
 465         break;
 466     case 4:
 467         partition->type = Footer;
 468         break;
 469     default:
 470         av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
 471         return AVERROR_INVALIDDATA;
 472     }
 473
 474     /* consider both footers to be closed (there is only Footer and CompleteFooter) */
 475     partition->closed = partition->type == Footer || !(uid[14] & 1);
 476     partition->complete = uid[14] > 2;
 477     avio_skip(pb, 4);
 478     partition->kag_size = avio_rb32(pb);
 479     partition->this_partition = avio_rb64(pb);
 480     partition->previous_partition = avio_rb64(pb);
 481     footer_partition = avio_rb64(pb);
 482     partition->header_byte_count = avio_rb64(pb);
 483     partition->index_byte_count = avio_rb64(pb);
 484     partition->index_sid = avio_rb32(pb);
 485     avio_skip(pb, 8);
 486     partition->body_sid = avio_rb32(pb);
 487     avio_read(pb, op, sizeof(UID));
 488     nb_essence_containers = avio_rb32(pb);
 489
 490     /* some files don'thave FooterPartition set in every partition */
 491     if (footer_partition) {
 492         if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
 493             av_log(mxf->fc, AV_LOG_ERROR,
 494                    "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
 495                    mxf->footer_partition, footer_partition);
 496         } else {
 497             mxf->footer_partition = footer_partition;
 498         }
 499     }
 500
 501     av_dlog(mxf->fc,
 502             "PartitionPack: ThisPartition = 0x%"PRIX64
 503             ", PreviousPartition = 0x%"PRIX64", "
 504             "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
 505             partition->this_partition,
 506             partition->previous_partition, footer_partition,
 507             partition->index_sid, partition->body_sid);
 508
 509     /* sanity check PreviousPartition if set */
 510     if (partition->previous_partition &&
 511         mxf->run_in + partition->previous_partition >= klv_offset) {
 512         av_log(mxf->fc, AV_LOG_ERROR,
 513                "PreviousPartition points to this partition or forward\n");
 514         return AVERROR_INVALIDDATA;
 515     }
 516
 517     if      (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
 518     else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
 519     else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
 520     else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
 521     else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
 522     else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
 523     else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
 524     else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
 525     else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
 526     else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
 527     else if (op[12] == 0x10) {
 528         /* SMPTE 390m: "There shall be exactly one essence container"
 529          * The following block deals with files that violate this, namely:
 530          * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
 531          * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
 532         if (nb_essence_containers != 1) {
 533             MXFOP op = nb_essence_containers ? OP1a : OPAtom;
 534
 535             /* only nag once */
 536             if (!mxf->op)
 537                 av_log(mxf->fc, AV_LOG_WARNING, "\"OPAtom\" with %u ECs - assuming %s\n",
 538                        nb_essence_containers, op == OP1a ? "OP1a" : "OPAtom");
 539
 540             mxf->op = op;
 541         } else
 542             mxf->op = OPAtom;
 543     } else {
 544         av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
 545         mxf->op = OP1a;
 546     }
 547
 548     if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
 549         av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %i - guessing ", partition->kag_size);
 550
 551         if (mxf->op == OPSONYOpt)
 552             partition->kag_size = 512;
 553         else
 554             partition->kag_size = 1;
 555
 556         av_log(mxf->fc, AV_LOG_WARNING, "%i\n", partition->kag_size);
 557     }
 558
 559     return 0;
 560 }
 561
 562 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
 563 {
 564     MXFMetadataSet **tmp;
 565     if (mxf->metadata_sets_count+1 >= UINT_MAX / sizeof(*mxf->metadata_sets))
 566         return AVERROR(ENOMEM);
 567     tmp = av_realloc(mxf->metadata_sets, (mxf->metadata_sets_count + 1) * sizeof(*mxf->metadata_sets));
 568     if (!tmp)
 569         return AVERROR(ENOMEM);
 570     mxf->metadata_sets = tmp;
 571     mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
 572     mxf->metadata_sets_count++;
 573     return 0;
 574 }
 575
 576 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 577 {
 578     MXFCryptoContext *cryptocontext = arg;
 579     if (size != 16)
 580         return AVERROR_INVALIDDATA;
 581     if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
 582         avio_read(pb, cryptocontext->source_container_ul, 16);
 583     return 0;
 584 }
 585
 586 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 587 {
 588     MXFContext *mxf = arg;
 589     switch (tag) {
 590     case 0x1901:
 591         mxf->packages_count = avio_rb32(pb);
 592         mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID));
 593         if (!mxf->packages_refs)
 594             return AVERROR(ENOMEM);
 595         avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
 596         avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));
 597         break;
 598     }
 599     return 0;
 600 }
 601
 602 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 603 {
 604     MXFStructuralComponent *source_clip = arg;
 605     switch(tag) {
 606     case 0x0202:
 607         source_clip->duration = avio_rb64(pb);
 608         break;
 609     case 0x1201:
 610         source_clip->start_position = avio_rb64(pb);
 611         break;
 612     case 0x1101:
 613         /* UMID, only get last 16 bytes */
 614         avio_skip(pb, 16);
 615         avio_read(pb, source_clip->source_package_uid, 16);
 616         break;
 617     case 0x1102:
 618         source_clip->source_track_id = avio_rb32(pb);
 619         break;
 620     }
 621     return 0;
 622 }
 623
 624 static int mxf_read_material_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 625 {
 626     MXFPackage *package = arg;
 627     switch(tag) {
 628     case 0x4403:
 629         package->tracks_count = avio_rb32(pb);
 630         package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
 631         if (!package->tracks_refs)
 632             return AVERROR(ENOMEM);
 633         avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
 634         avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
 635         break;
 636     }
 637     return 0;
 638 }
 639
 640 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 641 {
 642     MXFTimecodeComponent *mxf_timecode = arg;
 643     switch(tag) {
 644     case 0x1501:
 645         mxf_timecode->start_frame = avio_rb64(pb);
 646         break;
 647     case 0x1502:
 648         mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
 649         break;
 650     case 0x1503:
 651         mxf_timecode->drop_frame = avio_r8(pb);
 652         break;
 653     }
 654     return 0;
 655 }
 656
 657 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 658 {
 659     MXFTrack *track = arg;
 660     switch(tag) {
 661     case 0x4801:
 662         track->track_id = avio_rb32(pb);
 663         break;
 664     case 0x4804:
 665         avio_read(pb, track->track_number, 4);
 666         break;
 667     case 0x4B01:
 668         track->edit_rate.num = avio_rb32(pb);
 669         track->edit_rate.den = avio_rb32(pb);
 670         break;
 671     case 0x4803:
 672         avio_read(pb, track->sequence_ref, 16);
 673         break;
 674     }
 675     return 0;
 676 }
 677
 678 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 679 {
 680     MXFSequence *sequence = arg;
 681     switch(tag) {
 682     case 0x0202:
 683         sequence->duration = avio_rb64(pb);
 684         break;
 685     case 0x0201:
 686         avio_read(pb, sequence->data_definition_ul, 16);
 687         break;
 688     case 0x1001:
 689         sequence->structural_components_count = avio_rb32(pb);
 690         sequence->structural_components_refs = av_calloc(sequence->structural_components_count, sizeof(UID));
 691         if (!sequence->structural_components_refs)
 692             return AVERROR(ENOMEM);
 693         avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
 694         avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
 695         break;
 696     }
 697     return 0;
 698 }
 699
 700 static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 701 {
 702     MXFPackage *package = arg;
 703     switch(tag) {
 704     case 0x4403:
 705         package->tracks_count = avio_rb32(pb);
 706         package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
 707         if (!package->tracks_refs)
 708             return AVERROR(ENOMEM);
 709         avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
 710         avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
 711         break;
 712     case 0x4401:
 713         /* UMID, only get last 16 bytes */
 714         avio_skip(pb, 16);
 715         avio_read(pb, package->package_uid, 16);
 716         break;
 717     case 0x4701:
 718         avio_read(pb, package->descriptor_ref, 16);
 719         break;
 720     }
 721     return 0;
 722 }
 723
 724 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
 725 {
 726     int i, length;
 727
 728     segment->nb_index_entries = avio_rb32(pb);
 729
 730     length = avio_rb32(pb);
 731
 732     if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
 733         !(segment->flag_entries          = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
 734         !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries))))
 735         return AVERROR(ENOMEM);
 736
 737     for (i = 0; i < segment->nb_index_entries; i++) {
 738         segment->temporal_offset_entries[i] = avio_r8(pb);
 739         avio_r8(pb);                                        /* KeyFrameOffset */
 740         segment->flag_entries[i] = avio_r8(pb);
 741         segment->stream_offset_entries[i] = avio_rb64(pb);
 742         avio_skip(pb, length - 11);
 743     }
 744     return 0;
 745 }
 746
 747 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 748 {
 749     MXFIndexTableSegment *segment = arg;
 750     switch(tag) {
 751     case 0x3F05:
 752         segment->edit_unit_byte_count = avio_rb32(pb);
 753         av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
 754         break;
 755     case 0x3F06:
 756         segment->index_sid = avio_rb32(pb);
 757         av_dlog(NULL, "IndexSID %d\n", segment->index_sid);
 758         break;
 759     case 0x3F07:
 760         segment->body_sid = avio_rb32(pb);
 761         av_dlog(NULL, "BodySID %d\n", segment->body_sid);
 762         break;
 763     case 0x3F0A:
 764         av_dlog(NULL, "IndexEntryArray found\n");
 765         return mxf_read_index_entry_array(pb, segment);
 766     case 0x3F0B:
 767         segment->index_edit_rate.num = avio_rb32(pb);
 768         segment->index_edit_rate.den = avio_rb32(pb);
 769         av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
 770                 segment->index_edit_rate.den);
 771         break;
 772     case 0x3F0C:
 773         segment->index_start_position = avio_rb64(pb);
 774         av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
 775         break;
 776     case 0x3F0D:
 777         segment->index_duration = avio_rb64(pb);
 778         av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration);
 779         break;
 780     }
 781     return 0;
 782 }
 783
 784 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
 785 {
 786     int code, value, ofs = 0;
 787     char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
 788
 789     do {
 790         code = avio_r8(pb);
 791         value = avio_r8(pb);
 792         av_dlog(NULL, "pixel layout: code %#x\n", code);
 793
 794         if (ofs <= 14) {
 795             layout[ofs++] = code;
 796             layout[ofs++] = value;
 797         } else
 798             break;  /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
 799     } while (code != 0); /* SMPTE 377M E.2.46 */
 800
 801     ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
 802 }
 803
 804 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 805 {
 806     MXFDescriptor *descriptor = arg;
 807     descriptor->pix_fmt = AV_PIX_FMT_NONE;
 808     switch(tag) {
 809     case 0x3F01:
 810         descriptor->sub_descriptors_count = avio_rb32(pb);
 811         descriptor->sub_descriptors_refs = av_calloc(descriptor->sub_descriptors_count, sizeof(UID));
 812         if (!descriptor->sub_descriptors_refs)
 813             return AVERROR(ENOMEM);
 814         avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
 815         avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
 816         break;
 817     case 0x3004:
 818         avio_read(pb, descriptor->essence_container_ul, 16);
 819         break;
 820     case 0x3006:
 821         descriptor->linked_track_id = avio_rb32(pb);
 822         break;
 823     case 0x3201: /* PictureEssenceCoding */
 824         avio_read(pb, descriptor->essence_codec_ul, 16);
 825         break;
 826     case 0x3203:
 827         descriptor->width = avio_rb32(pb);
 828         break;
 829     case 0x3202:
 830         descriptor->height = avio_rb32(pb);
 831         break;
 832     case 0x320C:
 833         descriptor->frame_layout = avio_r8(pb);
 834         break;
 835     case 0x320E:
 836         descriptor->aspect_ratio.num = avio_rb32(pb);
 837         descriptor->aspect_ratio.den = avio_rb32(pb);
 838         break;
 839     case 0x3301:
 840         descriptor->component_depth = avio_rb32(pb);
 841         break;
 842     case 0x3302:
 843         descriptor->horiz_subsampling = avio_rb32(pb);
 844         break;
 845     case 0x3308:
 846         descriptor->vert_subsampling = avio_rb32(pb);
 847         break;
 848     case 0x3D03:
 849         descriptor->sample_rate.num = avio_rb32(pb);
 850         descriptor->sample_rate.den = avio_rb32(pb);
 851         break;
 852     case 0x3D06: /* SoundEssenceCompression */
 853         avio_read(pb, descriptor->essence_codec_ul, 16);
 854         break;
 855     case 0x3D07:
 856         descriptor->channels = avio_rb32(pb);
 857         break;
 858     case 0x3D01:
 859         descriptor->bits_per_sample = avio_rb32(pb);
 860         break;
 861     case 0x3401:
 862         mxf_read_pixel_layout(pb, descriptor);
 863         break;
 864     default:
 865         /* Private uid used by SONY C0023S01.mxf */
 866         if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
 867             descriptor->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 868             if (!descriptor->extradata)
 869                 return AVERROR(ENOMEM);
 870             descriptor->extradata_size = size;
 871             avio_read(pb, descriptor->extradata, size);
 872         }
 873         break;
 874     }
 875     return 0;
 876 }
 877
 878 /*
 879  * Match an uid independently of the version byte and up to len common bytes
 880  * Returns: boolean
 881  */
 882 static int mxf_match_uid(const UID key, const UID uid, int len)
 883 {
 884     int i;
 885     for (i = 0; i < len; i++) {
 886         if (i != 7 && key[i] != uid[i])
 887             return 0;
 888     }
 889     return 1;
 890 }
 891
 892 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
 893 {
 894     while (uls->uid[0]) {
 895         if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
 896             break;
 897         uls++;
 898     }
 899     return uls;
 900 }
 901
 902 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
 903 {
 904     int i;
 905
 906     if (!strong_ref)
 907         return NULL;
 908     for (i = 0; i < mxf->metadata_sets_count; i++) {
 909         if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
 910             (type == AnyType || mxf->metadata_sets[i]->type == type)) {
 911             return mxf->metadata_sets[i];
 912         }
 913     }
 914     return NULL;
 915 }
 916
 917 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
 918     // video essence container uls
 919     { { 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 */
 920     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14,    AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
 921     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14,   AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
 922     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,      AV_CODEC_ID_NONE },
 923 };
 924
 925 /* EC ULs for intra-only formats */
 926 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
 927     { { 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 */
 928     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,       AV_CODEC_ID_NONE },
 929 };
 930
 931 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
 932 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
 933     { { 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 */
 934     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,       AV_CODEC_ID_NONE },
 935 };
 936
 937 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
 938     // sound essence container uls
 939     { { 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 */
 940     { { 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 */
 941     { { 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 */
 942     { { 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 */
 943     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,      AV_CODEC_ID_NONE },
 944 };
 945
 946 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
 947 {
 948     int i, j, nb_segments = 0;
 949     MXFIndexTableSegment **unsorted_segments;
 950     int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
 951
 952     /* count number of segments, allocate arrays and copy unsorted segments */
 953     for (i = 0; i < mxf->metadata_sets_count; i++)
 954         if (mxf->metadata_sets[i]->type == IndexTableSegment)
 955             nb_segments++;
 956
 957     if (!nb_segments)
 958         return AVERROR_INVALIDDATA;
 959
 960     if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
 961         !(*sorted_segments  = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
 962         av_freep(sorted_segments);
 963         av_free(unsorted_segments);
 964         return AVERROR(ENOMEM);
 965     }
 966
 967     for (i = j = 0; i < mxf->metadata_sets_count; i++)
 968         if (mxf->metadata_sets[i]->type == IndexTableSegment)
 969             unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
 970
 971     *nb_sorted_segments = 0;
 972
 973     /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
 974     for (i = 0; i < nb_segments; i++) {
 975         int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
 976         uint64_t best_index_duration = 0;
 977
 978         for (j = 0; j < nb_segments; j++) {
 979             MXFIndexTableSegment *s = unsorted_segments[j];
 980
 981             /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
 982              * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
 983              * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
 984              */
 985             if ((i == 0     || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
 986                 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
 987                 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
 988                 best             = j;
 989                 best_body_sid    = s->body_sid;
 990                 best_index_sid   = s->index_sid;
 991                 best_index_start = s->index_start_position;
 992                 best_index_duration = s->index_duration;
 993             }
 994         }
 995
 996         /* no suitable entry found -> we're done */
 997         if (best == -1)
 998             break;
 999
1000         (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1001         last_body_sid    = best_body_sid;
1002         last_index_sid   = best_index_sid;
1003         last_index_start = best_index_start;
1004     }
1005
1006     av_free(unsorted_segments);
1007
1008     return 0;
1009 }
1010
1011 /**
1012  * Computes the absolute file offset of the given essence container offset
1013  */
1014 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1015 {
1016     int x;
1017     int64_t offset_in = offset;     /* for logging */
1018
1019     for (x = 0; x < mxf->partitions_count; x++) {
1020         MXFPartition *p = &mxf->partitions[x];
1021
1022         if (p->body_sid != body_sid)
1023             continue;
1024
1025         if (offset < p->essence_length || !p->essence_length) {
1026             *offset_out = p->essence_offset + offset;
1027             return 0;
1028         }
1029
1030         offset -= p->essence_length;
1031     }
1032
1033     av_log(mxf->fc, AV_LOG_ERROR,
1034            "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1035            offset_in, body_sid);
1036
1037     return AVERROR_INVALIDDATA;
1038 }
1039
1040 /**
1041  * Returns the end position of the essence container with given BodySID, or zero if unknown
1042  */
1043 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1044 {
1045     int x;
1046     int64_t ret = 0;
1047
1048     for (x = 0; x < mxf->partitions_count; x++) {
1049         MXFPartition *p = &mxf->partitions[x];
1050
1051         if (p->body_sid != body_sid)
1052             continue;
1053
1054         if (!p->essence_length)
1055             return 0;
1056
1057         ret = p->essence_offset + p->essence_length;
1058     }
1059
1060     return ret;
1061 }
1062
1063 /* EditUnit -> absolute offset */
1064 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)
1065 {
1066     int i;
1067     int64_t offset_temp = 0;
1068
1069     for (i = 0; i < index_table->nb_segments; i++) {
1070         MXFIndexTableSegment *s = index_table->segments[i];
1071
1072         edit_unit = FFMAX(edit_unit, s->index_start_position);  /* clamp if trying to seek before start */
1073
1074         if (edit_unit < s->index_start_position + s->index_duration) {
1075             int64_t index = edit_unit - s->index_start_position;
1076
1077             if (s->edit_unit_byte_count)
1078                 offset_temp += s->edit_unit_byte_count * index;
1079             else if (s->nb_index_entries) {
1080                 if (s->nb_index_entries == 2 * s->index_duration + 1)
1081                     index *= 2;     /* Avid index */
1082
1083                 if (index < 0 || index >= s->nb_index_entries) {
1084                     av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1085                            index_table->index_sid, s->index_start_position);
1086                     return AVERROR_INVALIDDATA;
1087                 }
1088
1089                 offset_temp = s->stream_offset_entries[index];
1090             } else {
1091                 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1092                        index_table->index_sid, s->index_start_position);
1093                 return AVERROR_INVALIDDATA;
1094             }
1095
1096             if (edit_unit_out)
1097                 *edit_unit_out = edit_unit;
1098
1099             return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1100         } else {
1101             /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1102             offset_temp += s->edit_unit_byte_count * s->index_duration;
1103         }
1104     }
1105
1106     if (nag)
1107         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);
1108
1109     return AVERROR_INVALIDDATA;
1110 }
1111
1112 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1113 {
1114     int i, j, x;
1115     int8_t max_temporal_offset = -128;
1116
1117     /* first compute how many entries we have */
1118     for (i = 0; i < index_table->nb_segments; i++) {
1119         MXFIndexTableSegment *s = index_table->segments[i];
1120
1121         if (!s->nb_index_entries) {
1122             index_table->nb_ptses = 0;
1123             return 0;                               /* no TemporalOffsets */
1124         }
1125
1126         index_table->nb_ptses += s->index_duration;
1127     }
1128
1129     /* paranoid check */
1130     if (index_table->nb_ptses <= 0)
1131         return 0;
1132
1133     if (!(index_table->ptses      = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1134         !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1135         av_freep(&index_table->ptses);
1136         return AVERROR(ENOMEM);
1137     }
1138
1139     /* we may have a few bad TemporalOffsets
1140      * make sure the corresponding PTSes don't have the bogus value 0 */
1141     for (x = 0; x < index_table->nb_ptses; x++)
1142         index_table->ptses[x] = AV_NOPTS_VALUE;
1143
1144     /**
1145      * We have this:
1146      *
1147      * x  TemporalOffset
1148      * 0:  0
1149      * 1:  1
1150      * 2:  1
1151      * 3: -2
1152      * 4:  1
1153      * 5:  1
1154      * 6: -2
1155      *
1156      * We want to transform it into this:
1157      *
1158      * x  DTS PTS
1159      * 0: -1   0
1160      * 1:  0   3
1161      * 2:  1   1
1162      * 3:  2   2
1163      * 4:  3   6
1164      * 5:  4   4
1165      * 6:  5   5
1166      *
1167      * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1168      * then settings mxf->first_dts = -max(TemporalOffset[x]).
1169      * The latter makes DTS <= PTS.
1170      */
1171     for (i = x = 0; i < index_table->nb_segments; i++) {
1172         MXFIndexTableSegment *s = index_table->segments[i];
1173         int index_delta = 1;
1174         int n = s->nb_index_entries;
1175
1176         if (s->nb_index_entries == 2 * s->index_duration + 1) {
1177             index_delta = 2;    /* Avid index */
1178             /* ignore the last entry - it's the size of the essence container */
1179             n--;
1180         }
1181
1182         for (j = 0; j < n; j += index_delta, x++) {
1183             int offset = s->temporal_offset_entries[j] / index_delta;
1184             int index  = x + offset;
1185
1186             if (x >= index_table->nb_ptses) {
1187                 av_log(mxf->fc, AV_LOG_ERROR,
1188                        "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1189                        s->nb_index_entries, s->index_duration);
1190                 break;
1191             }
1192
1193             index_table->fake_index[x].timestamp = x;
1194             index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1195
1196             if (index < 0 || index >= index_table->nb_ptses) {
1197                 av_log(mxf->fc, AV_LOG_ERROR,
1198                        "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1199                        x, offset, index);
1200                 continue;
1201             }
1202
1203             index_table->ptses[index] = x;
1204             max_temporal_offset = FFMAX(max_temporal_offset, offset);
1205         }
1206     }
1207
1208     index_table->first_dts = -max_temporal_offset;
1209
1210     return 0;
1211 }
1212
1213 /**
1214  * Sorts and collects index table segments into index tables.
1215  * Also computes PTSes if possible.
1216  */
1217 static int mxf_compute_index_tables(MXFContext *mxf)
1218 {
1219     int i, j, k, ret, nb_sorted_segments;
1220     MXFIndexTableSegment **sorted_segments = NULL;
1221
1222     if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1223         nb_sorted_segments <= 0) {
1224         av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1225         return 0;
1226     }
1227
1228     /* sanity check and count unique BodySIDs/IndexSIDs */
1229     for (i = 0; i < nb_sorted_segments; i++) {
1230         if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1231             mxf->nb_index_tables++;
1232         else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1233             av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1234             ret = AVERROR_INVALIDDATA;
1235             goto finish_decoding_index;
1236         }
1237     }
1238
1239     if (!(mxf->index_tables = av_calloc(mxf->nb_index_tables, sizeof(MXFIndexTable)))) {
1240         av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1241         ret = AVERROR(ENOMEM);
1242         goto finish_decoding_index;
1243     }
1244
1245     /* distribute sorted segments to index tables */
1246     for (i = j = 0; i < nb_sorted_segments; i++) {
1247         if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1248             /* next IndexSID */
1249             j++;
1250         }
1251
1252         mxf->index_tables[j].nb_segments++;
1253     }
1254
1255     for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1256         MXFIndexTable *t = &mxf->index_tables[j];
1257
1258         if (!(t->segments = av_calloc(t->nb_segments, sizeof(MXFIndexTableSegment*)))) {
1259             av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment pointer array\n");
1260             ret = AVERROR(ENOMEM);
1261             goto finish_decoding_index;
1262         }
1263
1264         if (sorted_segments[i]->index_start_position)
1265             av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1266                    sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1267
1268         memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1269         t->index_sid = sorted_segments[i]->index_sid;
1270         t->body_sid = sorted_segments[i]->body_sid;
1271
1272         if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1273             goto finish_decoding_index;
1274
1275         /* fix zero IndexDurations */
1276         for (k = 0; k < t->nb_segments; k++) {
1277             if (t->segments[k]->index_duration)
1278                 continue;
1279
1280             if (t->nb_segments > 1)
1281                 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1282                        t->index_sid, k);
1283
1284             if (mxf->fc->nb_streams <= 0) {
1285                 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1286                 break;
1287             }
1288
1289             /* assume the first stream's duration is reasonable
1290              * leave index_duration = 0 on further segments in case we have any (unlikely)
1291              */
1292             t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1293             break;
1294         }
1295     }
1296
1297     ret = 0;
1298 finish_decoding_index:
1299     av_free(sorted_segments);
1300     return ret;
1301 }
1302
1303 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1304 {
1305     return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1306                             &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1307            mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1308                             &descriptor->essence_codec_ul)->id     != AV_CODEC_ID_NONE;
1309 }
1310
1311 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1312 {
1313     char buf[AV_TIMECODE_STR_SIZE];
1314     av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1315
1316     return 0;
1317 }
1318
1319 static int mxf_parse_structural_metadata(MXFContext *mxf)
1320 {
1321     MXFPackage *material_package = NULL;
1322     MXFPackage *temp_package = NULL;
1323     int i, j, k, ret;
1324
1325     av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1326     /* TODO: handle multiple material packages (OP3x) */
1327     for (i = 0; i < mxf->packages_count; i++) {
1328         material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1329         if (material_package) break;
1330     }
1331     if (!material_package) {
1332         av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1333         return AVERROR_INVALIDDATA;
1334     }
1335
1336     for (i = 0; i < material_package->tracks_count; i++) {
1337         MXFPackage *source_package = NULL;
1338         MXFTrack *material_track = NULL;
1339         MXFTrack *source_track = NULL;
1340         MXFTrack *temp_track = NULL;
1341         MXFDescriptor *descriptor = NULL;
1342         MXFStructuralComponent *component = NULL;
1343         MXFTimecodeComponent *mxf_tc = NULL;
1344         UID *essence_container_ul = NULL;
1345         const MXFCodecUL *codec_ul = NULL;
1346         const MXFCodecUL *container_ul = NULL;
1347         const MXFCodecUL *pix_fmt_ul = NULL;
1348         AVStream *st;
1349         AVTimecode tc;
1350         int flags;
1351
1352         if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1353             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1354             continue;
1355         }
1356
1357         if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1358             mxf_tc = (MXFTimecodeComponent*)component;
1359             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1360             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1361                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1362             }
1363         }
1364
1365         if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1366             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1367             continue;
1368         }
1369
1370         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1371             component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1372             if (!component)
1373                 continue;
1374
1375             mxf_tc = (MXFTimecodeComponent*)component;
1376             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1377             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1378                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1379                 break;
1380             }
1381         }
1382
1383         /* TODO: handle multiple source clips */
1384         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1385             component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], SourceClip);
1386             if (!component)
1387                 continue;
1388
1389             for (k = 0; k < mxf->packages_count; k++) {
1390                 temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[k], SourcePackage);
1391                 if (!temp_package)
1392                     continue;
1393                 if (!memcmp(temp_package->package_uid, component->source_package_uid, 16)) {
1394                     source_package = temp_package;
1395                     break;
1396                 }
1397             }
1398             if (!source_package) {
1399                 av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1400                 break;
1401             }
1402             for (k = 0; k < source_package->tracks_count; k++) {
1403                 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1404                     av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1405                     ret = AVERROR_INVALIDDATA;
1406                     goto fail_and_free;
1407                 }
1408                 if (temp_track->track_id == component->source_track_id) {
1409                     source_track = temp_track;
1410                     break;
1411                 }
1412             }
1413             if (!source_track) {
1414                 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1415                 break;
1416             }
1417         }
1418         if (!source_track || !component)
1419             continue;
1420
1421         if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1422             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1423             ret = AVERROR_INVALIDDATA;
1424             goto fail_and_free;
1425         }
1426
1427         /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1428          * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1429         if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1430             av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1431             continue;
1432         }
1433
1434         st = avformat_new_stream(mxf->fc, NULL);
1435         if (!st) {
1436             av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1437             ret = AVERROR(ENOMEM);
1438             goto fail_and_free;
1439         }
1440         st->id = source_track->track_id;
1441         st->priv_data = source_track;
1442         st->duration = component->duration;
1443         if (st->duration == -1)
1444             st->duration = AV_NOPTS_VALUE;
1445         st->start_time = component->start_position;
1446         avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1447
1448         PRINT_KEY(mxf->fc, "data definition   ul", source_track->sequence->data_definition_ul);
1449         codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1450         st->codec->codec_type = codec_ul->id;
1451
1452         source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1453         if (source_package->descriptor) {
1454             if (source_package->descriptor->type == MultipleDescriptor) {
1455                 for (j = 0; j < source_package->descriptor->sub_descriptors_count; j++) {
1456                     MXFDescriptor *sub_descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor->sub_descriptors_refs[j], Descriptor);
1457
1458                     if (!sub_descriptor) {
1459                         av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1460                         continue;
1461                     }
1462                     if (sub_descriptor->linked_track_id == source_track->track_id) {
1463                         descriptor = sub_descriptor;
1464                         break;
1465                     }
1466                 }
1467             } else if (source_package->descriptor->type == Descriptor)
1468                 descriptor = source_package->descriptor;
1469         }
1470         if (!descriptor) {
1471             av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1472             continue;
1473         }
1474         PRINT_KEY(mxf->fc, "essence codec     ul", descriptor->essence_codec_ul);
1475         PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1476         essence_container_ul = &descriptor->essence_container_ul;
1477         /* HACK: replacing the original key with mxf_encrypted_essence_container
1478          * is not allowed according to s429-6, try to find correct information anyway */
1479         if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1480             av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1481             for (k = 0; k < mxf->metadata_sets_count; k++) {
1482                 MXFMetadataSet *metadata = mxf->metadata_sets[k];
1483                 if (metadata->type == CryptoContext) {
1484                     essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1485                     break;
1486                 }
1487             }
1488         }
1489
1490         /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1491         codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1492         st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1493         if (descriptor->extradata) {
1494             st->codec->extradata = descriptor->extradata;
1495             st->codec->extradata_size = descriptor->extradata_size;
1496         }
1497         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1498             source_track->intra_only = mxf_is_intra_only(descriptor);
1499             container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1500             if (st->codec->codec_id == AV_CODEC_ID_NONE)
1501                 st->codec->codec_id = container_ul->id;
1502             st->codec->width = descriptor->width;
1503             st->codec->height = descriptor->height; /* Field height, not frame height */
1504             switch (descriptor->frame_layout) {
1505                 case SegmentedFrame:
1506                     /* This one is a weird layout I don't fully understand. */
1507                     av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1508                     break;
1509                 case FullFrame:
1510                     break;
1511                 case OneField:
1512                     /* Every other line is stored and needs to be duplicated. */
1513                     av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1514                     break; /* The correct thing to do here is fall through, but by breaking we might be
1515                               able to decode some streams at half the vertical resolution, rather than not al all.
1516                               It's also for compatibility with the old behavior. */
1517                 case MixedFields:
1518                     break;
1519                 case SeparateFields:
1520                     st->codec->height *= 2; /* Turn field height into frame height. */
1521                     break;
1522                 default:
1523                     av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1524             }
1525             if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1526                 st->codec->pix_fmt = descriptor->pix_fmt;
1527                 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1528                     pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1529                                                   &descriptor->essence_codec_ul);
1530                     st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1531                     if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1532                         /* support files created before RP224v10 by defaulting to UYVY422
1533                            if subsampling is 4:2:2 and component depth is 8-bit */
1534                         if (descriptor->horiz_subsampling == 2 &&
1535                             descriptor->vert_subsampling == 1 &&
1536                             descriptor->component_depth == 8) {
1537                             st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1538                         }
1539                     }
1540                 }
1541             }
1542             st->need_parsing = AVSTREAM_PARSE_HEADERS;
1543         } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1544             container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1545             /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1546             if (st->codec->codec_id == AV_CODEC_ID_NONE || (st->codec->codec_id == AV_CODEC_ID_PCM_ALAW && (enum AVCodecID)container_ul->id != AV_CODEC_ID_NONE))
1547                 st->codec->codec_id = (enum AVCodecID)container_ul->id;
1548             st->codec->channels = descriptor->channels;
1549             st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1550
1551             if (descriptor->sample_rate.den > 0)
1552                 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1553
1554             /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1555             if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1556                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1557                     st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1558                 else if (descriptor->bits_per_sample == 32)
1559                     st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1560             } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1561                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1562                     st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1563                 else if (descriptor->bits_per_sample == 32)
1564                     st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1565             } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1566                 st->need_parsing = AVSTREAM_PARSE_FULL;
1567             }
1568         }
1569         if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1570             /* TODO: decode timestamps */
1571             st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
1572         }
1573     }
1574
1575     ret = 0;
1576 fail_and_free:
1577     return ret;
1578 }
1579
1580 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
1581     { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
1582     { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
1583     { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
1584     { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
1585     { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
1586     { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
1587     { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
1588     { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
1589     { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
1590     { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
1591     { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1592     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
1593     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
1594     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
1595     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
1596     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
1597     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
1598     { { 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 */
1599     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
1600     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
1601     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG 2 Video */
1602     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
1603     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
1604     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
1605     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1606     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1607     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1608     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1609     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
1610 };
1611
1612 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1613 {
1614     AVIOContext *pb = mxf->fc->pb;
1615     MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
1616     uint64_t klv_end = avio_tell(pb) + klv->length;
1617
1618     if (!ctx)
1619         return AVERROR(ENOMEM);
1620     while (avio_tell(pb) + 4 < klv_end && !url_feof(pb)) {
1621         int ret;
1622         int tag = avio_rb16(pb);
1623         int size = avio_rb16(pb); /* KLV specified by 0x53 */
1624         uint64_t next = avio_tell(pb) + size;
1625         UID uid = {0};
1626
1627         av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
1628         if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
1629             av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
1630             continue;
1631         }
1632         if (tag > 0x7FFF) { /* dynamic tag */
1633             int i;
1634             for (i = 0; i < mxf->local_tags_count; i++) {
1635                 int local_tag = AV_RB16(mxf->local_tags+i*18);
1636                 if (local_tag == tag) {
1637                     memcpy(uid, mxf->local_tags+i*18+2, 16);
1638                     av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
1639                     PRINT_KEY(mxf->fc, "uid", uid);
1640                 }
1641             }
1642         }
1643         if (ctx_size && tag == 0x3C0A)
1644             avio_read(pb, ctx->uid, 16);
1645         else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1646             return ret;
1647
1648         /* Accept the 64k local set limit being exceeded (Avid). Don't accept
1649          * it extending past the end of the KLV though (zzuf5.mxf). */
1650         if (avio_tell(pb) > klv_end) {
1651             if (ctx_size)
1652                 av_free(ctx);
1653
1654             av_log(mxf->fc, AV_LOG_ERROR,
1655                    "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
1656                    tag, klv->offset);
1657             return AVERROR_INVALIDDATA;
1658         } else if (avio_tell(pb) <= next)   /* only seek forward, else this can loop for a long time */
1659             avio_seek(pb, next, SEEK_SET);
1660     }
1661     if (ctx_size) ctx->type = type;
1662     return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
1663 }
1664
1665 /**
1666  * Seeks to the previous partition, if possible
1667  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1668  */
1669 static int mxf_seek_to_previous_partition(MXFContext *mxf)
1670 {
1671     AVIOContext *pb = mxf->fc->pb;
1672
1673     if (!mxf->current_partition ||
1674         mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
1675         return 0;   /* we've parsed all partitions */
1676
1677     /* seek to previous partition */
1678     avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
1679     mxf->current_partition = NULL;
1680
1681     av_dlog(mxf->fc, "seeking to previous partition\n");
1682
1683     return 1;
1684 }
1685
1686 /**
1687  * Called when essence is encountered
1688  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1689  */
1690 static int mxf_parse_handle_essence(MXFContext *mxf)
1691 {
1692     AVIOContext *pb = mxf->fc->pb;
1693     int64_t ret;
1694
1695     if (mxf->parsing_backward) {
1696         return mxf_seek_to_previous_partition(mxf);
1697     } else {
1698         if (!mxf->footer_partition) {
1699             av_dlog(mxf->fc, "no footer\n");
1700             return 0;
1701         }
1702
1703         av_dlog(mxf->fc, "seeking to footer\n");
1704
1705         /* remember where we were so we don't end up seeking further back than this */
1706         mxf->last_forward_tell = avio_tell(pb);
1707
1708         if (!pb->seekable) {
1709             av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing footer\n");
1710             return -1;
1711         }
1712
1713         /* seek to footer partition and parse backward */
1714         if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
1715             av_log(mxf->fc, AV_LOG_ERROR, "failed to seek to footer @ 0x%"PRIx64" (%"PRId64") - partial file?\n",
1716                    mxf->run_in + mxf->footer_partition, ret);
1717             return ret;
1718         }
1719
1720         mxf->current_partition = NULL;
1721         mxf->parsing_backward = 1;
1722     }
1723
1724     return 1;
1725 }
1726
1727 /**
1728  * Called when the next partition or EOF is encountered
1729  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1730  */
1731 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
1732 {
1733     return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
1734 }
1735
1736 /**
1737  * Figures out the proper offset and length of the essence container in each partition
1738  */
1739 static void mxf_compute_essence_containers(MXFContext *mxf)
1740 {
1741     int x;
1742
1743     /* everything is already correct */
1744     if (mxf->op == OPAtom)
1745         return;
1746
1747     for (x = 0; x < mxf->partitions_count; x++) {
1748         MXFPartition *p = &mxf->partitions[x];
1749
1750         if (!p->body_sid)
1751             continue;       /* BodySID == 0 -> no essence */
1752
1753         if (x >= mxf->partitions_count - 1)
1754             break;          /* last partition - can't compute length (and we don't need to) */
1755
1756         /* essence container spans to the next partition */
1757         p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
1758
1759         if (p->essence_length < 0) {
1760             /* next ThisPartition < essence_offset */
1761             p->essence_length = 0;
1762             av_log(mxf->fc, AV_LOG_ERROR,
1763                    "partition %i: bad ThisPartition = %"PRIX64"\n",
1764                    x+1, mxf->partitions[x+1].this_partition);
1765         }
1766     }
1767 }
1768
1769 static int64_t round_to_kag(int64_t position, int kag_size)
1770 {
1771     /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
1772     /* NOTE: kag_size may be any integer between 1 - 2^10 */
1773     int64_t ret = (position / kag_size) * kag_size;
1774     return ret == position ? ret : ret + kag_size;
1775 }
1776
1777 static int is_pcm(enum AVCodecID codec_id)
1778 {
1779     /* we only care about "normal" PCM codecs until we get samples */
1780     return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
1781 }
1782
1783 /**
1784  * Deal with the case where for some audio atoms EditUnitByteCount is
1785  * very small (2, 4..). In those cases we should read more than one
1786  * sample per call to mxf_read_packet().
1787  */
1788 static void mxf_handle_small_eubc(AVFormatContext *s)
1789 {
1790     MXFContext *mxf = s->priv_data;
1791
1792     /* assuming non-OPAtom == frame wrapped
1793      * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
1794     if (mxf->op != OPAtom)
1795         return;
1796
1797     /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
1798     if (s->nb_streams != 1                                     ||
1799         s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
1800         !is_pcm(s->streams[0]->codec->codec_id)                ||
1801         mxf->nb_index_tables != 1                              ||
1802         mxf->index_tables[0].nb_segments != 1                  ||
1803         mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
1804         return;
1805
1806     /* arbitrarily default to 48 kHz PAL audio frame size */
1807     /* TODO: We could compute this from the ratio between the audio
1808      *       and video edit rates for 48 kHz NTSC we could use the
1809      *       1802-1802-1802-1802-1801 pattern. */
1810     mxf->edit_units_per_packet = 1920;
1811 }
1812
1813 static int mxf_read_header(AVFormatContext *s)
1814 {
1815     MXFContext *mxf = s->priv_data;
1816     KLVPacket klv;
1817     int64_t essence_offset = 0;
1818     int ret;
1819
1820     mxf->last_forward_tell = INT64_MAX;
1821     mxf->edit_units_per_packet = 1;
1822
1823     if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
1824         av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
1825         return AVERROR_INVALIDDATA;
1826     }
1827     avio_seek(s->pb, -14, SEEK_CUR);
1828     mxf->fc = s;
1829     mxf->run_in = avio_tell(s->pb);
1830
1831     while (!url_feof(s->pb)) {
1832         const MXFMetadataReadTableEntry *metadata;
1833
1834         if (klv_read_packet(&klv, s->pb) < 0) {
1835             /* EOF - seek to previous partition or stop */
1836             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
1837                 break;
1838             else
1839                 continue;
1840         }
1841
1842         PRINT_KEY(s, "read header", klv.key);
1843         av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
1844         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
1845             IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
1846             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
1847             IS_KLV_KEY(klv.key, mxf_system_item_key)) {
1848
1849             if (!mxf->current_partition) {
1850                 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
1851                 return AVERROR_INVALIDDATA;
1852             }
1853
1854             if (!mxf->current_partition->essence_offset) {
1855                 /* for OP1a we compute essence_offset
1856                  * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
1857                  * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
1858                  *       for OPAtom we still need the actual essence_offset though (the KL's length can vary)
1859                  */
1860                 int64_t op1a_essence_offset =
1861                     round_to_kag(mxf->current_partition->this_partition +
1862                                  mxf->current_partition->pack_length,       mxf->current_partition->kag_size) +
1863                     round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
1864                     round_to_kag(mxf->current_partition->index_byte_count,  mxf->current_partition->kag_size);
1865
1866                 if (mxf->op == OPAtom) {
1867                     /* point essence_offset to the actual data
1868                     * OPAtom has all the essence in one big KLV
1869                     */
1870                     mxf->current_partition->essence_offset = avio_tell(s->pb);
1871                     mxf->current_partition->essence_length = klv.length;
1872                 } else {
1873                     /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf)  */
1874                     mxf->current_partition->essence_offset = op1a_essence_offset;
1875                 }
1876             }
1877
1878             if (!essence_offset)
1879                 essence_offset = klv.offset;
1880
1881             /* seek to footer, previous partition or stop */
1882             if (mxf_parse_handle_essence(mxf) <= 0)
1883                 break;
1884             continue;
1885         } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
1886                    klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
1887             /* next partition pack - keep going, seek to previous partition or stop */
1888             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
1889                 break;
1890             else if (mxf->parsing_backward)
1891                 continue;
1892             /* we're still parsing forward. proceed to parsing this partition pack */
1893         }
1894
1895         for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
1896             if (IS_KLV_KEY(klv.key, metadata->key)) {
1897                 int res;
1898                 if (klv.key[5] == 0x53) {
1899                     res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
1900                 } else {
1901                     uint64_t next = avio_tell(s->pb) + klv.length;
1902                     res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
1903
1904                     /* only seek forward, else this can loop for a long time */
1905                     if (avio_tell(s->pb) > next) {
1906                         av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
1907                                klv.offset);
1908                         return AVERROR_INVALIDDATA;
1909                     }
1910
1911                     avio_seek(s->pb, next, SEEK_SET);
1912                 }
1913                 if (res < 0) {
1914                     av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
1915                     return res;
1916                 }
1917                 break;
1918             }
1919         }
1920         if (!metadata->read)
1921             avio_skip(s->pb, klv.length);
1922     }
1923     /* FIXME avoid seek */
1924     if (!essence_offset)  {
1925         av_log(s, AV_LOG_ERROR, "no essence\n");
1926         return AVERROR_INVALIDDATA;
1927     }
1928     avio_seek(s->pb, essence_offset, SEEK_SET);
1929
1930     mxf_compute_essence_containers(mxf);
1931
1932     /* we need to do this before computing the index tables
1933      * to be able to fill in zero IndexDurations with st->duration */
1934     if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
1935         goto fail;
1936
1937     if ((ret = mxf_compute_index_tables(mxf)) < 0)
1938         goto fail;
1939
1940     if (mxf->nb_index_tables > 1) {
1941         /* TODO: look up which IndexSID to use via EssenceContainerData */
1942         av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
1943                mxf->nb_index_tables, mxf->index_tables[0].index_sid);
1944     } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
1945         av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
1946         ret = AVERROR_INVALIDDATA;
1947         goto fail;
1948     }
1949
1950     mxf_handle_small_eubc(s);
1951
1952     return 0;
1953 fail:
1954     mxf_read_close(s);
1955
1956     return ret;
1957 }
1958
1959 /**
1960  * Sets mxf->current_edit_unit based on what offset we're currently at.
1961  * @return next_ofs if OK, <0 on error
1962  */
1963 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
1964 {
1965     int64_t last_ofs = -1, next_ofs = -1;
1966     MXFIndexTable *t = &mxf->index_tables[0];
1967
1968     /* this is called from the OP1a demuxing logic, which means there
1969      * may be no index tables */
1970     if (mxf->nb_index_tables <= 0)
1971         return -1;
1972
1973     /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
1974     while (mxf->current_edit_unit >= 0) {
1975         if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
1976             return -1;
1977
1978         if (next_ofs <= last_ofs) {
1979             /* large next_ofs didn't change or current_edit_unit wrapped
1980              * around this fixes the infinite loop on zzuf3.mxf */
1981             av_log(mxf->fc, AV_LOG_ERROR,
1982                    "next_ofs didn't change. not deriving packet timestamps\n");
1983             return -1;
1984         }
1985
1986         if (next_ofs > current_offset)
1987             break;
1988
1989         last_ofs = next_ofs;
1990         mxf->current_edit_unit++;
1991     }
1992
1993     /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
1994     if (mxf->current_edit_unit < 0)
1995         return -1;
1996
1997     return next_ofs;
1998 }
1999
2000 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2001 {
2002     KLVPacket klv;
2003     MXFContext *mxf = s->priv_data;
2004
2005     while (!url_feof(s->pb)) {
2006         int ret;
2007         if (klv_read_packet(&klv, s->pb) < 0)
2008             return -1;
2009         PRINT_KEY(s, "read packet", klv.key);
2010         av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2011         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2012             ret = mxf_decrypt_triplet(s, pkt, &klv);
2013             if (ret < 0) {
2014                 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2015                 return AVERROR_INVALIDDATA;
2016             }
2017             return 0;
2018         }
2019         if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2020             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2021             int index = mxf_get_stream_index(s, &klv);
2022             int64_t next_ofs, next_klv;
2023             AVStream *st;
2024             MXFTrack *track;
2025
2026             if (index < 0) {
2027                 av_log(s, AV_LOG_ERROR, "error getting stream index %d\n", AV_RB32(klv.key+12));
2028                 goto skip;
2029             }
2030
2031             st = s->streams[index];
2032             track = st->priv_data;
2033
2034             if (s->streams[index]->discard == AVDISCARD_ALL)
2035                 goto skip;
2036
2037             next_klv = avio_tell(s->pb) + klv.length;
2038             next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2039
2040             if (next_ofs >= 0 && next_klv > next_ofs) {
2041                 /* if this check is hit then it's possible OPAtom was treated as OP1a
2042                  * truncate the packet since it's probably very large (>2 GiB is common) */
2043                 av_log_ask_for_sample(s,
2044                     "KLV for edit unit %i extends into next edit unit - OPAtom misinterpreted as OP1a?\n",
2045                     mxf->current_edit_unit);
2046                 klv.length = next_ofs - avio_tell(s->pb);
2047             }
2048
2049             /* check for 8 channels AES3 element */
2050             if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2051                 if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) {
2052                     av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2053                     return AVERROR_INVALIDDATA;
2054                 }
2055             } else {
2056                 ret = av_get_packet(s->pb, pkt, klv.length);
2057                 if (ret < 0)
2058                     return ret;
2059             }
2060             pkt->stream_index = index;
2061             pkt->pos = klv.offset;
2062
2063             if (s->streams[index]->codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2064                 /* mxf->current_edit_unit good - see if we have an index table to derive timestamps from */
2065                 MXFIndexTable *t = &mxf->index_tables[0];
2066
2067                 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2068                     pkt->dts = mxf->current_edit_unit + t->first_dts;
2069                     pkt->pts = t->ptses[mxf->current_edit_unit];
2070                 } else if (track->intra_only) {
2071                     /* intra-only -> PTS = EditUnit.
2072                      * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2073                     pkt->pts = mxf->current_edit_unit;
2074                 }
2075             }
2076
2077             /* seek for truncated packets */
2078             avio_seek(s->pb, next_klv, SEEK_SET);
2079
2080             return 0;
2081         } else
2082         skip:
2083             avio_skip(s->pb, klv.length);
2084     }
2085     return AVERROR_EOF;
2086 }
2087
2088 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2089 {
2090     MXFContext *mxf = s->priv_data;
2091     int ret, size;
2092     int64_t ret64, pos, next_pos;
2093     AVStream *st;
2094     MXFIndexTable *t;
2095     int edit_units;
2096
2097     if (mxf->op != OPAtom)
2098         return mxf_read_packet_old(s, pkt);
2099
2100     /* OPAtom - clip wrapped demuxing */
2101     /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2102     st = s->streams[0];
2103     t = &mxf->index_tables[0];
2104
2105     if (mxf->current_edit_unit >= st->duration)
2106         return AVERROR_EOF;
2107
2108     edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2109
2110     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2111         return ret;
2112
2113     /* compute size by finding the next edit unit or the end of the essence container
2114      * not pretty, but it works */
2115     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2116         (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2117         av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2118         return AVERROR_INVALIDDATA;
2119     }
2120
2121     if ((size = next_pos - pos) <= 0) {
2122         av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2123         return AVERROR_INVALIDDATA;
2124     }
2125
2126     if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2127         return ret64;
2128
2129     if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2130         return size;
2131
2132     if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2133         mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2134         pkt->dts = mxf->current_edit_unit + t->first_dts;
2135         pkt->pts = t->ptses[mxf->current_edit_unit];
2136     }
2137
2138     pkt->stream_index = 0;
2139     mxf->current_edit_unit += edit_units;
2140
2141     return 0;
2142 }
2143
2144 static int mxf_read_close(AVFormatContext *s)
2145 {
2146     MXFContext *mxf = s->priv_data;
2147     MXFIndexTableSegment *seg;
2148     int i;
2149
2150     av_freep(&mxf->packages_refs);
2151
2152     for (i = 0; i < s->nb_streams; i++)
2153         s->streams[i]->priv_data = NULL;
2154
2155     for (i = 0; i < mxf->metadata_sets_count; i++) {
2156         switch (mxf->metadata_sets[i]->type) {
2157         case MultipleDescriptor:
2158             av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2159             break;
2160         case Sequence:
2161             av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2162             break;
2163         case SourcePackage:
2164         case MaterialPackage:
2165             av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2166             break;
2167         case IndexTableSegment:
2168             seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2169             av_freep(&seg->temporal_offset_entries);
2170             av_freep(&seg->flag_entries);
2171             av_freep(&seg->stream_offset_entries);
2172             break;
2173         default:
2174             break;
2175         }
2176         av_freep(&mxf->metadata_sets[i]);
2177     }
2178     av_freep(&mxf->partitions);
2179     av_freep(&mxf->metadata_sets);
2180     av_freep(&mxf->aesc);
2181     av_freep(&mxf->local_tags);
2182
2183     for (i = 0; i < mxf->nb_index_tables; i++) {
2184         av_freep(&mxf->index_tables[i].segments);
2185         av_freep(&mxf->index_tables[i].ptses);
2186         av_freep(&mxf->index_tables[i].fake_index);
2187     }
2188     av_freep(&mxf->index_tables);
2189
2190     return 0;
2191 }
2192
2193 static int mxf_probe(AVProbeData *p) {
2194     uint8_t *bufp = p->buf;
2195     uint8_t *end = p->buf + p->buf_size;
2196
2197     if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2198         return 0;
2199
2200     /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2201     end -= sizeof(mxf_header_partition_pack_key);
2202     for (; bufp < end; bufp++) {
2203         if (IS_KLV_KEY(bufp, mxf_header_partition_pack_key))
2204             return AVPROBE_SCORE_MAX;
2205     }
2206     return 0;
2207 }
2208
2209 /* rudimentary byte seek */
2210 /* XXX: use MXF Index */
2211 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2212 {
2213     AVStream *st = s->streams[stream_index];
2214     int64_t seconds;
2215     MXFContext* mxf = s->priv_data;
2216     int64_t seekpos;
2217     int ret;
2218     MXFIndexTable *t;
2219
2220     if (mxf->nb_index_tables <= 0) {
2221     if (!s->bit_rate)
2222         return AVERROR_INVALIDDATA;
2223     if (sample_time < 0)
2224         sample_time = 0;
2225     seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2226
2227     if ((ret = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET)) < 0)
2228         return ret;
2229     ff_update_cur_dts(s, st, sample_time);
2230     } else {
2231         t = &mxf->index_tables[0];
2232
2233         /* clamp above zero, else ff_index_search_timestamp() returns negative
2234          * this also means we allow seeking before the start */
2235         sample_time = FFMAX(sample_time, 0);
2236
2237         if (t->fake_index) {
2238             /* behave as if we have a proper index */
2239             if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2240                 return sample_time;
2241         } else {
2242             /* no IndexEntryArray (one or more CBR segments)
2243              * make sure we don't seek past the end */
2244             sample_time = FFMIN(sample_time, st->duration - 1);
2245         }
2246
2247         if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) << 0)
2248             return ret;
2249
2250         ff_update_cur_dts(s, st, sample_time);
2251         mxf->current_edit_unit = sample_time;
2252         avio_seek(s->pb, seekpos, SEEK_SET);
2253     }
2254     return 0;
2255 }
2256
2257 AVInputFormat ff_mxf_demuxer = {
2258     .name           = "mxf",
2259     .long_name      = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2260     .priv_data_size = sizeof(MXFContext),
2261     .read_probe     = mxf_probe,
2262     .read_header    = mxf_read_header,
2263     .read_packet    = mxf_read_packet,
2264     .read_close     = mxf_read_close,
2265     .read_seek      = mxf_read_seek,
2266 };