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