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                 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
1636             }
1637             if (source_track->sequence->origin) {
1638                 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
1639             }
1640         } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1641             container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1642             /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1643             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))
1644                 st->codec->codec_id = (enum AVCodecID)container_ul->id;
1645             st->codec->channels = descriptor->channels;
1646             st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1647
1648             if (descriptor->sample_rate.den > 0) {
1649                 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1650                 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1651             } else {
1652                 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
1653                        "found for stream #%d, time base forced to 1/48000\n",
1654                        descriptor->sample_rate.num, descriptor->sample_rate.den,
1655                        st->index);
1656                 avpriv_set_pts_info(st, 64, 1, 48000);
1657             }
1658
1659             /* if duration is set, rescale it from EditRate to SampleRate */
1660             if (st->duration != AV_NOPTS_VALUE)
1661                 st->duration = av_rescale_q(st->duration,
1662                                             av_inv_q(material_track->edit_rate),
1663                                             st->time_base);
1664
1665             /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1666             if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1667                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1668                     st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1669                 else if (descriptor->bits_per_sample == 32)
1670                     st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1671             } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1672                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1673                     st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1674                 else if (descriptor->bits_per_sample == 32)
1675                     st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1676             } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1677                 st->need_parsing = AVSTREAM_PARSE_FULL;
1678             }
1679         } else if (st->codec->codec_type == AVMEDIA_TYPE_DATA) {
1680             int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls,
1681                                             essence_container_ul)->id;
1682             if (codec_id >= 0 &&
1683                 codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) {
1684                 av_dict_set(&st->metadata, "data_type",
1685                             mxf_data_essence_descriptor[codec_id], 0);
1686             }
1687         }
1688         if (descriptor->extradata) {
1689             if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) {
1690                 memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
1691             }
1692         } else if (st->codec->codec_id == AV_CODEC_ID_H264) {
1693             ret = ff_generate_avci_extradata(st);
1694             if (ret < 0)
1695                 return ret;
1696         }
1697         if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1698             /* TODO: decode timestamps */
1699             st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
1700         }
1701     }
1702
1703     ret = 0;
1704 fail_and_free:
1705     return ret;
1706 }
1707
1708 static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str)
1709 {
1710     int ret;
1711     size_t buf_size;
1712
1713     if (size < 0)
1714         return AVERROR(EINVAL);
1715
1716     buf_size = size + size / 2 + 1;
1717     *str = av_malloc(buf_size);
1718     if (!*str)
1719         return AVERROR(ENOMEM);
1720
1721     if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
1722         av_freep(str);
1723         return ret;
1724     }
1725
1726     return ret;
1727 }
1728
1729 static int mxf_uid_to_str(UID uid, char **str)
1730 {
1731     int i;
1732     char *p;
1733     p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1734     if (!p)
1735         return AVERROR(ENOMEM);
1736     for (i = 0; i < sizeof(UID); i++) {
1737         snprintf(p, 2 + 1, "%.2x", uid[i]);
1738         p += 2;
1739         if (i == 3 || i == 5 || i == 7 || i == 9) {
1740             snprintf(p, 1 + 1, "-");
1741             p++;
1742         }
1743     }
1744     return 0;
1745 }
1746
1747 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
1748 {
1749     struct tm time = { 0 };
1750     time.tm_year = (timestamp >> 48) - 1900;
1751     time.tm_mon  = (timestamp >> 40 & 0xFF) - 1;
1752     time.tm_mday = (timestamp >> 32 & 0xFF);
1753     time.tm_hour = (timestamp >> 24 & 0xFF);
1754     time.tm_min  = (timestamp >> 16 & 0xFF);
1755     time.tm_sec  = (timestamp >> 8  & 0xFF);
1756
1757     /* msvcrt versions of strftime calls the invalid parameter handler
1758      * (aborting the process if one isn't set) if the parameters are out
1759      * of range. */
1760     time.tm_mon  = av_clip(time.tm_mon,  0, 11);
1761     time.tm_mday = av_clip(time.tm_mday, 1, 31);
1762     time.tm_hour = av_clip(time.tm_hour, 0, 23);
1763     time.tm_min  = av_clip(time.tm_min,  0, 59);
1764     time.tm_sec  = av_clip(time.tm_sec,  0, 59);
1765
1766     *str = av_mallocz(32);
1767     if (!*str)
1768         return AVERROR(ENOMEM);
1769     strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time);
1770
1771     return 0;
1772 }
1773
1774 #define SET_STR_METADATA(pb, name, str) do { \
1775     if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
1776         return ret; \
1777     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1778 } while (0)
1779
1780 #define SET_UID_METADATA(pb, name, var, str) do { \
1781     avio_read(pb, var, 16); \
1782     if ((ret = mxf_uid_to_str(var, &str)) < 0) \
1783         return ret; \
1784     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1785 } while (0)
1786
1787 #define SET_TS_METADATA(pb, name, var, str) do { \
1788     var = avio_rb64(pb); \
1789     if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
1790         return ret; \
1791     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1792 } while (0)
1793
1794 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
1795 {
1796     MXFContext *mxf = arg;
1797     AVFormatContext *s = mxf->fc;
1798     int ret;
1799     UID uid = { 0 };
1800     char *str = NULL;
1801     uint64_t ts;
1802     switch (tag) {
1803     case 0x3C01:
1804         SET_STR_METADATA(pb, "company_name", str);
1805         break;
1806     case 0x3C02:
1807         SET_STR_METADATA(pb, "product_name", str);
1808         break;
1809     case 0x3C04:
1810         SET_STR_METADATA(pb, "product_version", str);
1811         break;
1812     case 0x3C05:
1813         SET_UID_METADATA(pb, "product_uid", uid, str);
1814         break;
1815     case 0x3C06:
1816         SET_TS_METADATA(pb, "modification_date", ts, str);
1817         break;
1818     case 0x3C08:
1819         SET_STR_METADATA(pb, "application_platform", str);
1820         break;
1821     case 0x3C09:
1822         SET_UID_METADATA(pb, "generation_uid", uid, str);
1823         break;
1824     case 0x3C0A:
1825         SET_UID_METADATA(pb, "uid", uid, str);
1826         break;
1827     }
1828     return 0;
1829 }
1830
1831 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
1832     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
1833     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
1834     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
1835     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
1836     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
1837     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
1838     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
1839     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
1840     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
1841     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
1842     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1843     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
1844     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
1845     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
1846     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
1847     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
1848     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
1849     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
1850     { { 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 */
1851     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
1852     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
1853     { { 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 */
1854     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
1855     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
1856     { { 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 */
1857     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
1858     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1859     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1860     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1861     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1862     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
1863 };
1864
1865 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1866 {
1867     AVIOContext *pb = mxf->fc->pb;
1868     MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
1869     uint64_t klv_end = avio_tell(pb) + klv->length;
1870
1871     if (!ctx)
1872         return AVERROR(ENOMEM);
1873     while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
1874         int ret;
1875         int tag = avio_rb16(pb);
1876         int size = avio_rb16(pb); /* KLV specified by 0x53 */
1877         uint64_t next = avio_tell(pb) + size;
1878         UID uid = {0};
1879
1880         av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
1881         if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
1882             av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
1883             continue;
1884         }
1885         if (tag > 0x7FFF) { /* dynamic tag */
1886             int i;
1887             for (i = 0; i < mxf->local_tags_count; i++) {
1888                 int local_tag = AV_RB16(mxf->local_tags+i*18);
1889                 if (local_tag == tag) {
1890                     memcpy(uid, mxf->local_tags+i*18+2, 16);
1891                     av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
1892                     PRINT_KEY(mxf->fc, "uid", uid);
1893                 }
1894             }
1895         }
1896         if (ctx_size && tag == 0x3C0A)
1897             avio_read(pb, ctx->uid, 16);
1898         else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1899             return ret;
1900
1901         /* Accept the 64k local set limit being exceeded (Avid). Don't accept
1902          * it extending past the end of the KLV though (zzuf5.mxf). */
1903         if (avio_tell(pb) > klv_end) {
1904             if (ctx_size)
1905                 av_free(ctx);
1906
1907             av_log(mxf->fc, AV_LOG_ERROR,
1908                    "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
1909                    tag, klv->offset);
1910             return AVERROR_INVALIDDATA;
1911         } else if (avio_tell(pb) <= next)   /* only seek forward, else this can loop for a long time */
1912             avio_seek(pb, next, SEEK_SET);
1913     }
1914     if (ctx_size) ctx->type = type;
1915     return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
1916 }
1917
1918 /**
1919  * Seeks to the previous partition, if possible
1920  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1921  */
1922 static int mxf_seek_to_previous_partition(MXFContext *mxf)
1923 {
1924     AVIOContext *pb = mxf->fc->pb;
1925
1926     if (!mxf->current_partition ||
1927         mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
1928         return 0;   /* we've parsed all partitions */
1929
1930     /* seek to previous partition */
1931     avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
1932     mxf->current_partition = NULL;
1933
1934     av_dlog(mxf->fc, "seeking to previous partition\n");
1935
1936     return 1;
1937 }
1938
1939 /**
1940  * Called when essence is encountered
1941  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1942  */
1943 static int mxf_parse_handle_essence(MXFContext *mxf)
1944 {
1945     AVIOContext *pb = mxf->fc->pb;
1946     int64_t ret;
1947
1948     if (mxf->parsing_backward) {
1949         return mxf_seek_to_previous_partition(mxf);
1950     } else {
1951         uint64_t offset = mxf->footer_partition ? mxf->footer_partition
1952                                                 : mxf->last_partition;
1953
1954         if (!offset) {
1955             av_dlog(mxf->fc, "no last partition\n");
1956             return 0;
1957         }
1958
1959         av_dlog(mxf->fc, "seeking to last partition\n");
1960
1961         /* remember where we were so we don't end up seeking further back than this */
1962         mxf->last_forward_tell = avio_tell(pb);
1963
1964         if (!pb->seekable) {
1965             av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing last partition\n");
1966             return -1;
1967         }
1968
1969         /* seek to last partition and parse backward */
1970         if ((ret = avio_seek(pb, mxf->run_in + offset, SEEK_SET)) < 0) {
1971             av_log(mxf->fc, AV_LOG_ERROR,
1972                    "failed to seek to last partition @ 0x%" PRIx64
1973                    " (%"PRId64") - partial file?\n",
1974                    mxf->run_in + offset, ret);
1975             return ret;
1976         }
1977
1978         mxf->current_partition = NULL;
1979         mxf->parsing_backward = 1;
1980     }
1981
1982     return 1;
1983 }
1984
1985 /**
1986  * Called when the next partition or EOF is encountered
1987  * @return <= 0 if we should stop parsing, > 0 if we should keep going
1988  */
1989 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
1990 {
1991     return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
1992 }
1993
1994 /**
1995  * Figures out the proper offset and length of the essence container in each partition
1996  */
1997 static void mxf_compute_essence_containers(MXFContext *mxf)
1998 {
1999     int x;
2000
2001     /* everything is already correct */
2002     if (mxf->op == OPAtom)
2003         return;
2004
2005     for (x = 0; x < mxf->partitions_count; x++) {
2006         MXFPartition *p = &mxf->partitions[x];
2007
2008         if (!p->body_sid)
2009             continue;       /* BodySID == 0 -> no essence */
2010
2011         if (x >= mxf->partitions_count - 1)
2012             break;          /* last partition - can't compute length (and we don't need to) */
2013
2014         /* essence container spans to the next partition */
2015         p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2016
2017         if (p->essence_length < 0) {
2018             /* next ThisPartition < essence_offset */
2019             p->essence_length = 0;
2020             av_log(mxf->fc, AV_LOG_ERROR,
2021                    "partition %i: bad ThisPartition = %"PRIX64"\n",
2022                    x+1, mxf->partitions[x+1].this_partition);
2023         }
2024     }
2025 }
2026
2027 static int64_t round_to_kag(int64_t position, int kag_size)
2028 {
2029     /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2030     /* NOTE: kag_size may be any integer between 1 - 2^10 */
2031     int64_t ret = (position / kag_size) * kag_size;
2032     return ret == position ? ret : ret + kag_size;
2033 }
2034
2035 static int is_pcm(enum AVCodecID codec_id)
2036 {
2037     /* we only care about "normal" PCM codecs until we get samples */
2038     return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2039 }
2040
2041 /**
2042  * Deal with the case where for some audio atoms EditUnitByteCount is
2043  * very small (2, 4..). In those cases we should read more than one
2044  * sample per call to mxf_read_packet().
2045  */
2046 static void mxf_handle_small_eubc(AVFormatContext *s)
2047 {
2048     MXFContext *mxf = s->priv_data;
2049
2050     /* assuming non-OPAtom == frame wrapped
2051      * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2052     if (mxf->op != OPAtom)
2053         return;
2054
2055     /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2056     if (s->nb_streams != 1                                     ||
2057         s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
2058         !is_pcm(s->streams[0]->codec->codec_id)                ||
2059         mxf->nb_index_tables != 1                              ||
2060         mxf->index_tables[0].nb_segments != 1                  ||
2061         mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2062         return;
2063
2064     /* arbitrarily default to 48 kHz PAL audio frame size */
2065     /* TODO: We could compute this from the ratio between the audio
2066      *       and video edit rates for 48 kHz NTSC we could use the
2067      *       1802-1802-1802-1802-1801 pattern. */
2068     mxf->edit_units_per_packet = 1920;
2069 }
2070
2071 static void mxf_read_random_index_pack(AVFormatContext *s)
2072 {
2073     MXFContext *mxf = s->priv_data;
2074     uint32_t length;
2075     int64_t file_size;
2076     KLVPacket klv;
2077
2078     if (!s->pb->seekable)
2079         return;
2080
2081     file_size = avio_size(s->pb);
2082     avio_seek(s->pb, file_size - 4, SEEK_SET);
2083     length = avio_rb32(s->pb);
2084     if (length <= 32 || length >= FFMIN(file_size, INT_MAX))
2085         goto end;
2086     avio_seek(s->pb, file_size - length, SEEK_SET);
2087     if (klv_read_packet(&klv, s->pb) < 0 ||
2088         !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2089         klv.length != length - 20)
2090         goto end;
2091
2092     avio_skip(s->pb, klv.length - 12);
2093     mxf->last_partition = avio_rb64(s->pb);
2094
2095 end:
2096     avio_seek(s->pb, mxf->run_in, SEEK_SET);
2097 }
2098
2099 static int mxf_read_header(AVFormatContext *s)
2100 {
2101     MXFContext *mxf = s->priv_data;
2102     KLVPacket klv;
2103     int64_t essence_offset = 0;
2104     int64_t last_pos = -1;
2105     uint64_t last_pos_index = 1;
2106     int ret;
2107
2108     mxf->last_forward_tell = INT64_MAX;
2109     mxf->edit_units_per_packet = 1;
2110
2111     if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2112         av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2113         return AVERROR_INVALIDDATA;
2114     }
2115     avio_seek(s->pb, -14, SEEK_CUR);
2116     mxf->fc = s;
2117     mxf->run_in = avio_tell(s->pb);
2118
2119     mxf_read_random_index_pack(s);
2120
2121     while (!avio_feof(s->pb)) {
2122         const MXFMetadataReadTableEntry *metadata;
2123         if (avio_tell(s->pb) == last_pos) {
2124             av_log(mxf->fc, AV_LOG_ERROR, "MXF structure loop detected\n");
2125             return AVERROR_INVALIDDATA;
2126         }
2127         if ((1ULL<<61) % last_pos_index++ == 0)
2128             last_pos = avio_tell(s->pb);
2129         if (klv_read_packet(&klv, s->pb) < 0) {
2130             /* EOF - seek to previous partition or stop */
2131             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2132                 break;
2133             else
2134                 continue;
2135         }
2136
2137         PRINT_KEY(s, "read header", klv.key);
2138         av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2139         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2140             IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2141             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2142             IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2143
2144             if (!mxf->current_partition) {
2145                 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2146                 return AVERROR_INVALIDDATA;
2147             }
2148
2149             if (!mxf->current_partition->essence_offset) {
2150                 /* for OP1a we compute essence_offset
2151                  * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2152                  * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2153                  *       for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2154                  */
2155                 int64_t op1a_essence_offset =
2156                     round_to_kag(mxf->current_partition->this_partition +
2157                                  mxf->current_partition->pack_length,       mxf->current_partition->kag_size) +
2158                     round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2159                     round_to_kag(mxf->current_partition->index_byte_count,  mxf->current_partition->kag_size);
2160
2161                 if (mxf->op == OPAtom) {
2162                     /* point essence_offset to the actual data
2163                     * OPAtom has all the essence in one big KLV
2164                     */
2165                     mxf->current_partition->essence_offset = avio_tell(s->pb);
2166                     mxf->current_partition->essence_length = klv.length;
2167                 } else {
2168                     /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf)  */
2169                     mxf->current_partition->essence_offset = op1a_essence_offset;
2170                 }
2171             }
2172
2173             if (!essence_offset)
2174                 essence_offset = klv.offset;
2175
2176             /* seek to footer, previous partition or stop */
2177             if (mxf_parse_handle_essence(mxf) <= 0)
2178                 break;
2179             continue;
2180         } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
2181                    klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
2182             /* next partition pack - keep going, seek to previous partition or stop */
2183             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2184                 break;
2185             else if (mxf->parsing_backward)
2186                 continue;
2187             /* we're still parsing forward. proceed to parsing this partition pack */
2188         }
2189
2190         for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2191             if (IS_KLV_KEY(klv.key, metadata->key)) {
2192                 int res;
2193                 if (klv.key[5] == 0x53) {
2194                     res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
2195                 } else {
2196                     uint64_t next = avio_tell(s->pb) + klv.length;
2197                     res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2198
2199                     /* only seek forward, else this can loop for a long time */
2200                     if (avio_tell(s->pb) > next) {
2201                         av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2202                                klv.offset);
2203                         return AVERROR_INVALIDDATA;
2204                     }
2205
2206                     avio_seek(s->pb, next, SEEK_SET);
2207                 }
2208                 if (res < 0) {
2209                     av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2210                     return res;
2211                 }
2212                 break;
2213             } else {
2214                 av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
2215                        UID_ARG(klv.key));
2216             }
2217         }
2218         if (!metadata->read)
2219             avio_skip(s->pb, klv.length);
2220     }
2221     /* FIXME avoid seek */
2222     if (!essence_offset)  {
2223         av_log(s, AV_LOG_ERROR, "no essence\n");
2224         return AVERROR_INVALIDDATA;
2225     }
2226     avio_seek(s->pb, essence_offset, SEEK_SET);
2227
2228     mxf_compute_essence_containers(mxf);
2229
2230     /* we need to do this before computing the index tables
2231      * to be able to fill in zero IndexDurations with st->duration */
2232     if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2233         goto fail;
2234
2235     if ((ret = mxf_compute_index_tables(mxf)) < 0)
2236         goto fail;
2237
2238     if (mxf->nb_index_tables > 1) {
2239         /* TODO: look up which IndexSID to use via EssenceContainerData */
2240         av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2241                mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2242     } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2243         av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2244         ret = AVERROR_INVALIDDATA;
2245         goto fail;
2246     }
2247
2248     mxf_handle_small_eubc(s);
2249
2250     return 0;
2251 fail:
2252     mxf_read_close(s);
2253
2254     return ret;
2255 }
2256
2257 /**
2258  * Sets mxf->current_edit_unit based on what offset we're currently at.
2259  * @return next_ofs if OK, <0 on error
2260  */
2261 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2262 {
2263     int64_t last_ofs = -1, next_ofs = -1;
2264     MXFIndexTable *t = &mxf->index_tables[0];
2265
2266     /* this is called from the OP1a demuxing logic, which means there
2267      * may be no index tables */
2268     if (mxf->nb_index_tables <= 0)
2269         return -1;
2270
2271     /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2272     while (mxf->current_edit_unit >= 0) {
2273         if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2274             return -1;
2275
2276         if (next_ofs <= last_ofs) {
2277             /* large next_ofs didn't change or current_edit_unit wrapped
2278              * around this fixes the infinite loop on zzuf3.mxf */
2279             av_log(mxf->fc, AV_LOG_ERROR,
2280                    "next_ofs didn't change. not deriving packet timestamps\n");
2281             return -1;
2282         }
2283
2284         if (next_ofs > current_offset)
2285             break;
2286
2287         last_ofs = next_ofs;
2288         mxf->current_edit_unit++;
2289     }
2290
2291     /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2292     if (mxf->current_edit_unit < 0)
2293         return -1;
2294
2295     return next_ofs;
2296 }
2297
2298 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
2299                                     uint64_t *sample_count)
2300 {
2301     int i, total = 0, size = 0;
2302     AVStream *st = mxf->fc->streams[stream_index];
2303     MXFTrack *track = st->priv_data;
2304     AVRational time_base = av_inv_q(track->edit_rate);
2305     AVRational sample_rate = av_inv_q(st->time_base);
2306     const MXFSamplesPerFrame *spf = NULL;
2307
2308     if ((sample_rate.num / sample_rate.den) == 48000)
2309         spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2310     if (!spf) {
2311         int remainder = (sample_rate.num * time_base.num) %
2312                         (time_base.den * sample_rate.den);
2313         *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2314                                         av_mul_q(sample_rate, time_base)));
2315         if (remainder)
2316             av_log(mxf->fc, AV_LOG_WARNING,
2317                    "seeking detected on stream #%d with time base (%d/%d) and "
2318                    "sample rate (%d/%d), audio pts won't be accurate.\n",
2319                    stream_index, time_base.num, time_base.den,
2320                    sample_rate.num, sample_rate.den);
2321         return 0;
2322     }
2323
2324     while (spf->samples_per_frame[size]) {
2325         total += spf->samples_per_frame[size];
2326         size++;
2327     }
2328
2329     av_assert2(size);
2330
2331     *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2332     for (i = 0; i < mxf->current_edit_unit % size; i++) {
2333         *sample_count += spf->samples_per_frame[i];
2334     }
2335
2336     return 0;
2337 }
2338
2339 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec,
2340                              AVPacket *pkt)
2341 {
2342     MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2343     int64_t bits_per_sample = av_get_bits_per_sample(codec->codec_id);
2344
2345     pkt->pts = track->sample_count;
2346
2347     if (   codec->channels <= 0
2348         || bits_per_sample <= 0
2349         || codec->channels * (int64_t)bits_per_sample < 8)
2350         return AVERROR(EINVAL);
2351     track->sample_count += pkt->size / (codec->channels * (int64_t)bits_per_sample / 8);
2352     return 0;
2353 }
2354
2355 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2356 {
2357     KLVPacket klv;
2358     MXFContext *mxf = s->priv_data;
2359     int ret;
2360
2361     while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
2362         PRINT_KEY(s, "read packet", klv.key);
2363         av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2364         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2365             ret = mxf_decrypt_triplet(s, pkt, &klv);
2366             if (ret < 0) {
2367                 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2368                 return ret;
2369             }
2370             return 0;
2371         }
2372         if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2373             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2374             int index = mxf_get_stream_index(s, &klv);
2375             int64_t next_ofs, next_klv;
2376             AVStream *st;
2377             MXFTrack *track;
2378             AVCodecContext *codec;
2379
2380             if (index < 0) {
2381                 av_log(s, AV_LOG_ERROR,
2382                        "error getting stream index %"PRIu32"\n",
2383                        AV_RB32(klv.key + 12));
2384                 goto skip;
2385             }
2386
2387             st = s->streams[index];
2388             track = st->priv_data;
2389
2390             if (s->streams[index]->discard == AVDISCARD_ALL)
2391                 goto skip;
2392
2393             next_klv = avio_tell(s->pb) + klv.length;
2394             next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2395
2396             if (next_ofs >= 0 && next_klv > next_ofs) {
2397                 /* if this check is hit then it's possible OPAtom was treated as OP1a
2398                  * truncate the packet since it's probably very large (>2 GiB is common) */
2399                 avpriv_request_sample(s,
2400                                       "OPAtom misinterpreted as OP1a?"
2401                                       "KLV for edit unit %i extending into "
2402                                       "next edit unit",
2403                                       mxf->current_edit_unit);
2404                 klv.length = next_ofs - avio_tell(s->pb);
2405             }
2406
2407             /* check for 8 channels AES3 element */
2408             if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2409                 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
2410                                               pkt, klv.length);
2411                 if (ret < 0) {
2412                     av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2413                     return ret;
2414                 }
2415             } else {
2416                 ret = av_get_packet(s->pb, pkt, klv.length);
2417                 if (ret < 0)
2418                     return ret;
2419             }
2420             pkt->stream_index = index;
2421             pkt->pos = klv.offset;
2422
2423             codec = s->streams[index]->codec;
2424
2425             if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2426                 /* mxf->current_edit_unit good - see if we have an
2427                  * index table to derive timestamps from */
2428                 MXFIndexTable *t = &mxf->index_tables[0];
2429
2430                 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2431                     pkt->dts = mxf->current_edit_unit + t->first_dts;
2432                     pkt->pts = t->ptses[mxf->current_edit_unit];
2433                 } else if (track->intra_only) {
2434                     /* intra-only -> PTS = EditUnit.
2435                      * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2436                     pkt->pts = mxf->current_edit_unit;
2437                 }
2438             } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2439                 ret = mxf_set_audio_pts(mxf, codec, pkt);
2440                 if (ret < 0)
2441                     return ret;
2442             }
2443
2444             /* seek for truncated packets */
2445             avio_seek(s->pb, next_klv, SEEK_SET);
2446
2447             return 0;
2448         } else
2449         skip:
2450             avio_skip(s->pb, klv.length);
2451     }
2452     return avio_feof(s->pb) ? AVERROR_EOF : ret;
2453 }
2454
2455 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2456 {
2457     MXFContext *mxf = s->priv_data;
2458     int ret, size;
2459     int64_t ret64, pos, next_pos;
2460     AVStream *st;
2461     MXFIndexTable *t;
2462     int edit_units;
2463
2464     if (mxf->op != OPAtom)
2465         return mxf_read_packet_old(s, pkt);
2466
2467     /* OPAtom - clip wrapped demuxing */
2468     /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2469     st = s->streams[0];
2470     t = &mxf->index_tables[0];
2471
2472     if (mxf->current_edit_unit >= st->duration)
2473         return AVERROR_EOF;
2474
2475     edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2476
2477     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2478         return ret;
2479
2480     /* compute size by finding the next edit unit or the end of the essence container
2481      * not pretty, but it works */
2482     if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2483         (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2484         av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2485         return AVERROR_INVALIDDATA;
2486     }
2487
2488     if ((size = next_pos - pos) <= 0) {
2489         av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2490         return AVERROR_INVALIDDATA;
2491     }
2492
2493     if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2494         return ret64;
2495
2496     if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2497         return size;
2498
2499     pkt->stream_index = 0;
2500
2501     if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2502         mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2503         pkt->dts = mxf->current_edit_unit + t->first_dts;
2504         pkt->pts = t->ptses[mxf->current_edit_unit];
2505     } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2506         int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2507         if (ret < 0)
2508             return ret;
2509     }
2510
2511     mxf->current_edit_unit += edit_units;
2512
2513     return 0;
2514 }
2515
2516 static int mxf_read_close(AVFormatContext *s)
2517 {
2518     MXFContext *mxf = s->priv_data;
2519     MXFIndexTableSegment *seg;
2520     int i;
2521
2522     av_freep(&mxf->packages_refs);
2523
2524     for (i = 0; i < s->nb_streams; i++)
2525         s->streams[i]->priv_data = NULL;
2526
2527     for (i = 0; i < mxf->metadata_sets_count; i++) {
2528         switch (mxf->metadata_sets[i]->type) {
2529         case Descriptor:
2530             av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
2531             break;
2532         case MultipleDescriptor:
2533             av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2534             break;
2535         case Sequence:
2536             av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2537             break;
2538         case SourcePackage:
2539         case MaterialPackage:
2540             av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2541             break;
2542         case IndexTableSegment:
2543             seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2544             av_freep(&seg->temporal_offset_entries);
2545             av_freep(&seg->flag_entries);
2546             av_freep(&seg->stream_offset_entries);
2547             break;
2548         default:
2549             break;
2550         }
2551         av_freep(&mxf->metadata_sets[i]);
2552     }
2553     av_freep(&mxf->partitions);
2554     av_freep(&mxf->metadata_sets);
2555     av_freep(&mxf->aesc);
2556     av_freep(&mxf->local_tags);
2557
2558     if (mxf->index_tables) {
2559         for (i = 0; i < mxf->nb_index_tables; i++) {
2560             av_freep(&mxf->index_tables[i].segments);
2561             av_freep(&mxf->index_tables[i].ptses);
2562             av_freep(&mxf->index_tables[i].fake_index);
2563         }
2564     }
2565     av_freep(&mxf->index_tables);
2566
2567     return 0;
2568 }
2569
2570 static int mxf_probe(AVProbeData *p) {
2571     const uint8_t *bufp = p->buf;
2572     const uint8_t *end = p->buf + p->buf_size;
2573
2574     if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2575         return 0;
2576
2577     /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2578     end -= sizeof(mxf_header_partition_pack_key);
2579
2580     for (; bufp < end;) {
2581         if (!((bufp[13] - 1) & 0xF2)){
2582             if (AV_RN32(bufp   ) == AV_RN32(mxf_header_partition_pack_key   ) &&
2583                 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
2584                 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
2585                 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
2586                 return AVPROBE_SCORE_MAX;
2587             bufp ++;
2588         } else
2589             bufp += 10;
2590     }
2591
2592     return 0;
2593 }
2594
2595 /* rudimentary byte seek */
2596 /* XXX: use MXF Index */
2597 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2598 {
2599     AVStream *st = s->streams[stream_index];
2600     int64_t seconds;
2601     MXFContext* mxf = s->priv_data;
2602     int64_t seekpos;
2603     int i, ret;
2604     MXFIndexTable *t;
2605     MXFTrack *source_track = st->priv_data;
2606
2607     /* if audio then truncate sample_time to EditRate */
2608     if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2609         sample_time = av_rescale_q(sample_time, st->time_base,
2610                                    av_inv_q(source_track->edit_rate));
2611
2612     if (mxf->nb_index_tables <= 0) {
2613     if (!s->bit_rate)
2614         return AVERROR_INVALIDDATA;
2615     if (sample_time < 0)
2616         sample_time = 0;
2617     seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2618
2619     seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
2620     if (seekpos < 0)
2621         return seekpos;
2622
2623     ff_update_cur_dts(s, st, sample_time);
2624     mxf->current_edit_unit = sample_time;
2625     } else {
2626         t = &mxf->index_tables[0];
2627
2628         /* clamp above zero, else ff_index_search_timestamp() returns negative
2629          * this also means we allow seeking before the start */
2630         sample_time = FFMAX(sample_time, 0);
2631
2632         if (t->fake_index) {
2633             /* behave as if we have a proper index */
2634             if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2635                 return sample_time;
2636         } else {
2637             /* no IndexEntryArray (one or more CBR segments)
2638              * make sure we don't seek past the end */
2639             sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2640         }
2641
2642         if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
2643             return ret;
2644
2645         ff_update_cur_dts(s, st, sample_time);
2646         mxf->current_edit_unit = sample_time;
2647         avio_seek(s->pb, seekpos, SEEK_SET);
2648     }
2649
2650     // Update all tracks sample count
2651     for (i = 0; i < s->nb_streams; i++) {
2652         AVStream *cur_st = s->streams[i];
2653         MXFTrack *cur_track = cur_st->priv_data;
2654         uint64_t current_sample_count = 0;
2655         if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2656             ret = mxf_compute_sample_count(mxf, i, &current_sample_count);
2657             if (ret < 0)
2658                 return ret;
2659
2660             cur_track->sample_count = current_sample_count;
2661         }
2662     }
2663     return 0;
2664 }
2665
2666 AVInputFormat ff_mxf_demuxer = {
2667     .name           = "mxf",
2668     .long_name      = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2669     .priv_data_size = sizeof(MXFContext),
2670     .read_probe     = mxf_probe,
2671     .read_header    = mxf_read_header,
2672     .read_packet    = mxf_read_packet,
2673     .read_close     = mxf_read_close,
2674     .read_seek      = mxf_read_seek,
2675 };