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

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