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

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