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