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

   1 /*
   2  * MXF demuxer.
   3  * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /*
  23  * References
  24  * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
  25  * SMPTE 377M MXF File Format Specifications
  26  * SMPTE 378M Operational Pattern 1a
  27  * SMPTE 379M MXF Generic Container
  28  * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
  29  * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
  30  * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
  31  *
  32  * Principle
  33  * Search for Track numbers which will identify essence element KLV packets.
  34  * Search for SourcePackage which define tracks which contains Track numbers.
  35  * Material Package contains tracks with reference to SourcePackage tracks.
  36  * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
  37  * Assign Descriptors to correct Tracks.
  38  *
  39  * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
  40  * Metadata parsing resolves Strong References to objects.
  41  *
  42  * Simple demuxer, only OP1A supported and some files might not work at all.
  43  * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
  44  */
  45
  46 #include <inttypes.h>
  47
  48 #include "libavutil/aes.h"
  49 #include "libavutil/avassert.h"
  50 #include "libavutil/mathematics.h"
  51 #include "libavcodec/bytestream.h"
  52 #include "libavutil/intreadwrite.h"
  53 #include "libavutil/parseutils.h"
  54 #include "libavutil/timecode.h"
  55 #include "libavutil/opt.h"
  56 #include "avformat.h"
  57 #include "internal.h"
  58 #include "mxf.h"
  59
  60 #define MXF_MAX_CHUNK_SIZE (32 << 20)
  61
  62 typedef enum {
  63     Header,
  64     BodyPartition,
  65     Footer
  66 } MXFPartitionType;
  67
  68 typedef enum {
  69     OP1a = 1,
  70     OP1b,
  71     OP1c,
  72     OP2a,
  73     OP2b,
  74     OP2c,
  75     OP3a,
  76     OP3b,
  77     OP3c,
  78     OPAtom,
  79     OPSONYOpt,  /* FATE sample, violates the spec in places */
  80 } MXFOP;
  81
  82 typedef enum {
  83     UnknownWrapped = 0,
  84     FrameWrapped,
  85     ClipWrapped,
  86 } MXFWrappingScheme;
  87
  88 typedef struct MXFPartition {
  89     int closed;
  90     int complete;
  91     MXFPartitionType type;
  92     uint64_t previous_partition;
  93     int index_sid;
  94     int body_sid;
  95     int64_t this_partition;
  96     int64_t essence_offset;         ///< absolute offset of essence
  97     int64_t essence_length;
  98     int32_t kag_size;
  99     int64_t header_byte_count;
 100     int64_t index_byte_count;
 101     int pack_length;
 102     int64_t pack_ofs;               ///< absolute offset of pack in file, including run-in
 103     int64_t body_offset;
 104     KLVPacket first_essence_klv;
 105 } MXFPartition;
 106
 107 typedef struct MXFCryptoContext {
 108     UID uid;
 109     enum MXFMetadataSetType type;
 110     UID source_container_ul;
 111 } MXFCryptoContext;
 112
 113 typedef struct MXFStructuralComponent {
 114     UID uid;
 115     enum MXFMetadataSetType type;
 116     UID source_package_ul;
 117     UID source_package_uid;
 118     UID data_definition_ul;
 119     int64_t duration;
 120     int64_t start_position;
 121     int source_track_id;
 122 } MXFStructuralComponent;
 123
 124 typedef struct MXFSequence {
 125     UID uid;
 126     enum MXFMetadataSetType type;
 127     UID data_definition_ul;
 128     UID *structural_components_refs;
 129     int structural_components_count;
 130     int64_t duration;
 131     uint8_t origin;
 132 } MXFSequence;
 133
 134 typedef struct MXFTimecodeComponent {
 135     UID uid;
 136     enum MXFMetadataSetType type;
 137     int drop_frame;
 138     int start_frame;
 139     struct AVRational rate;
 140     AVTimecode tc;
 141 } MXFTimecodeComponent;
 142
 143 typedef struct {
 144     UID uid;
 145     enum MXFMetadataSetType type;
 146     UID input_segment_ref;
 147 } MXFPulldownComponent;
 148
 149 typedef struct {
 150     UID uid;
 151     enum MXFMetadataSetType type;
 152     UID *structural_components_refs;
 153     int structural_components_count;
 154     int64_t duration;
 155 } MXFEssenceGroup;
 156
 157 typedef struct {
 158     UID uid;
 159     enum MXFMetadataSetType type;
 160     char *name;
 161     char *value;
 162 } MXFTaggedValue;
 163
 164 typedef struct {
 165     UID uid;
 166     enum MXFMetadataSetType type;
 167     MXFSequence *sequence; /* mandatory, and only one */
 168     UID sequence_ref;
 169     int track_id;
 170     char *name;
 171     uint8_t track_number[4];
 172     AVRational edit_rate;
 173     int intra_only;
 174     uint64_t sample_count;
 175     int64_t original_duration; /* st->duration in SampleRate/EditRate units */
 176     int index_sid;
 177     int body_sid;
 178     MXFWrappingScheme wrapping;
 179     int edit_units_per_packet; /* how many edit units to read at a time (PCM, ClipWrapped) */
 180 } MXFTrack;
 181
 182 typedef struct MXFDescriptor {
 183     UID uid;
 184     enum MXFMetadataSetType type;
 185     UID essence_container_ul;
 186     UID essence_codec_ul;
 187     UID codec_ul;
 188     AVRational sample_rate;
 189     AVRational aspect_ratio;
 190     int width;
 191     int height; /* Field height, not frame height */
 192     int frame_layout; /* See MXFFrameLayout enum */
 193     int video_line_map[2];
 194 #define MXF_FIELD_DOMINANCE_DEFAULT 0
 195 #define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */
 196 #define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */
 197     int field_dominance;
 198     int channels;
 199     int bits_per_sample;
 200     int64_t duration; /* ContainerDuration optional property */
 201     unsigned int component_depth;
 202     unsigned int horiz_subsampling;
 203     unsigned int vert_subsampling;
 204     UID *sub_descriptors_refs;
 205     int sub_descriptors_count;
 206     int linked_track_id;
 207     uint8_t *extradata;
 208     int extradata_size;
 209     enum AVPixelFormat pix_fmt;
 210 } MXFDescriptor;
 211
 212 typedef struct MXFIndexTableSegment {
 213     UID uid;
 214     enum MXFMetadataSetType type;
 215     int edit_unit_byte_count;
 216     int index_sid;
 217     int body_sid;
 218     AVRational index_edit_rate;
 219     uint64_t index_start_position;
 220     uint64_t index_duration;
 221     int8_t *temporal_offset_entries;
 222     int *flag_entries;
 223     uint64_t *stream_offset_entries;
 224     int nb_index_entries;
 225 } MXFIndexTableSegment;
 226
 227 typedef struct MXFPackage {
 228     UID uid;
 229     enum MXFMetadataSetType type;
 230     UID package_uid;
 231     UID package_ul;
 232     UID *tracks_refs;
 233     int tracks_count;
 234     MXFDescriptor *descriptor; /* only one */
 235     UID descriptor_ref;
 236     char *name;
 237     UID *comment_refs;
 238     int comment_count;
 239 } MXFPackage;
 240
 241 typedef struct MXFEssenceContainerData {
 242     UID uid;
 243     enum MXFMetadataSetType type;
 244     UID package_uid;
 245     UID package_ul;
 246     int index_sid;
 247     int body_sid;
 248 } MXFEssenceContainerData;
 249
 250 typedef struct MXFMetadataSet {
 251     UID uid;
 252     enum MXFMetadataSetType type;
 253 } MXFMetadataSet;
 254
 255 /* decoded index table */
 256 typedef struct MXFIndexTable {
 257     int index_sid;
 258     int body_sid;
 259     int nb_ptses;               /* number of PTSes or total duration of index */
 260     int64_t first_dts;          /* DTS = EditUnit + first_dts */
 261     int64_t *ptses;             /* maps EditUnit -> PTS */
 262     int nb_segments;
 263     MXFIndexTableSegment **segments;    /* sorted by IndexStartPosition */
 264     AVIndexEntry *fake_index;   /* used for calling ff_index_search_timestamp() */
 265     int8_t *offsets;            /* temporal offsets for display order to stored order conversion */
 266 } MXFIndexTable;
 267
 268 typedef struct MXFContext {
 269     const AVClass *class;     /**< Class for private options. */
 270     MXFPartition *partitions;
 271     unsigned partitions_count;
 272     MXFOP op;
 273     UID *packages_refs;
 274     int packages_count;
 275     UID *essence_container_data_refs;
 276     int essence_container_data_count;
 277     MXFMetadataSet **metadata_sets;
 278     int metadata_sets_count;
 279     AVFormatContext *fc;
 280     struct AVAES *aesc;
 281     uint8_t *local_tags;
 282     int local_tags_count;
 283     uint64_t footer_partition;
 284     KLVPacket current_klv_data;
 285     int run_in;
 286     MXFPartition *current_partition;
 287     int parsing_backward;
 288     int64_t last_forward_tell;
 289     int last_forward_partition;
 290     int nb_index_tables;
 291     MXFIndexTable *index_tables;
 292     int eia608_extract;
 293 } MXFContext;
 294
 295 /* NOTE: klv_offset is not set (-1) for local keys */
 296 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
 297
 298 typedef struct MXFMetadataReadTableEntry {
 299     const UID key;
 300     MXFMetadataReadFunc *read;
 301     int ctx_size;
 302     enum MXFMetadataSetType type;
 303 } MXFMetadataReadTableEntry;
 304
 305 static int mxf_read_close(AVFormatContext *s);
 306
 307 /* partial keys to match */
 308 static const uint8_t mxf_header_partition_pack_key[]       = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
 309 static const uint8_t mxf_essence_element_key[]             = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
 310 static const uint8_t mxf_avid_essence_element_key[]        = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
 311 static const uint8_t mxf_canopus_essence_element_key[]     = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };
 312 static const uint8_t mxf_system_item_key_cp[]              = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
 313 static const uint8_t mxf_system_item_key_gc[]              = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };
 314 static const uint8_t mxf_klv_key[]                         = { 0x06,0x0e,0x2b,0x34 };
 315 /* complete keys to match */
 316 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 };
 317 static const uint8_t mxf_encrypted_triplet_key[]           = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
 318 static const uint8_t mxf_encrypted_essence_container[]     = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
 319 static const uint8_t mxf_random_index_pack_key[]           = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x11,0x01,0x00 };
 320 static const uint8_t mxf_sony_mpeg4_extradata[]            = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
 321 static const uint8_t mxf_avid_project_name[]               = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
 322 static const uint8_t mxf_jp2k_rsiz[]                       = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 };
 323 static const uint8_t mxf_indirect_value_utf16le[]          = { 0x4c,0x00,0x02,0x10,0x01,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
 324 static const uint8_t mxf_indirect_value_utf16be[]          = { 0x42,0x01,0x10,0x02,0x00,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
 325
 326 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
 327
 328 static void mxf_free_metadataset(MXFMetadataSet **ctx, int freectx)
 329 {
 330     MXFIndexTableSegment *seg;
 331     switch ((*ctx)->type) {
 332     case Descriptor:
 333         av_freep(&((MXFDescriptor *)*ctx)->extradata);
 334         break;
 335     case MultipleDescriptor:
 336         av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
 337         break;
 338     case Sequence:
 339         av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
 340         break;
 341     case EssenceGroup:
 342         av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
 343         break;
 344     case SourcePackage:
 345     case MaterialPackage:
 346         av_freep(&((MXFPackage *)*ctx)->tracks_refs);
 347         av_freep(&((MXFPackage *)*ctx)->name);
 348         av_freep(&((MXFPackage *)*ctx)->comment_refs);
 349         break;
 350     case TaggedValue:
 351         av_freep(&((MXFTaggedValue *)*ctx)->name);
 352         av_freep(&((MXFTaggedValue *)*ctx)->value);
 353         break;
 354     case Track:
 355         av_freep(&((MXFTrack *)*ctx)->name);
 356         break;
 357     case IndexTableSegment:
 358         seg = (MXFIndexTableSegment *)*ctx;
 359         av_freep(&seg->temporal_offset_entries);
 360         av_freep(&seg->flag_entries);
 361         av_freep(&seg->stream_offset_entries);
 362     default:
 363         break;
 364     }
 365     if (freectx) {
 366         av_freep(ctx);
 367     }
 368 }
 369
 370 static int64_t klv_decode_ber_length(AVIOContext *pb)
 371 {
 372     uint64_t size = avio_r8(pb);
 373     if (size & 0x80) { /* long form */
 374         int bytes_num = size & 0x7f;
 375         /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
 376         if (bytes_num > 8)
 377             return AVERROR_INVALIDDATA;
 378         size = 0;
 379         while (bytes_num--)
 380             size = size << 8 | avio_r8(pb);
 381     }
 382     if (size > INT64_MAX)
 383         return AVERROR_INVALIDDATA;
 384     return size;
 385 }
 386
 387 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
 388 {
 389     int i, b;
 390     for (i = 0; i < size && !avio_feof(pb); i++) {
 391         b = avio_r8(pb);
 392         if (b == key[0])
 393             i = 0;
 394         else if (b != key[i])
 395             i = -1;
 396     }
 397     return i == size;
 398 }
 399
 400 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
 401 {
 402     int64_t length, pos;
 403     if (!mxf_read_sync(pb, mxf_klv_key, 4))
 404         return AVERROR_INVALIDDATA;
 405     klv->offset = avio_tell(pb) - 4;
 406     memcpy(klv->key, mxf_klv_key, 4);
 407     avio_read(pb, klv->key + 4, 12);
 408     length = klv_decode_ber_length(pb);
 409     if (length < 0)
 410         return length;
 411     klv->length = length;
 412     pos = avio_tell(pb);
 413     if (pos > INT64_MAX - length)
 414         return AVERROR_INVALIDDATA;
 415     klv->next_klv = pos + length;
 416     return 0;
 417 }
 418
 419 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
 420 {
 421     int i;
 422
 423     for (i = 0; i < s->nb_streams; i++) {
 424         MXFTrack *track = s->streams[i]->priv_data;
 425         /* SMPTE 379M 7.3 */
 426         if (track && (!body_sid || !track->body_sid || track->body_sid == body_sid) && !memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
 427             return i;
 428     }
 429     /* return 0 if only one stream, for OP Atom files with 0 as track number */
 430     return s->nb_streams == 1 && s->streams[0]->priv_data ? 0 : -1;
 431 }
 432
 433 static int find_body_sid_by_absolute_offset(MXFContext *mxf, int64_t offset)
 434 {
 435     // we look for partition where the offset is placed
 436     int a, b, m;
 437     int64_t pack_ofs;
 438
 439     a = -1;
 440     b = mxf->partitions_count;
 441
 442     while (b - a > 1) {
 443         m = (a + b) >> 1;
 444         pack_ofs = mxf->partitions[m].pack_ofs;
 445         if (pack_ofs <= offset)
 446             a = m;
 447         else
 448             b = m;
 449     }
 450
 451     if (a == -1)
 452         return 0;
 453     return mxf->partitions[a].body_sid;
 454 }
 455
 456 static int mxf_get_eia608_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt, int64_t length)
 457 {
 458     int count = avio_rb16(s->pb);
 459     int cdp_identifier, cdp_length, cdp_footer_id, ccdata_id, cc_count;
 460     int line_num, sample_coding, sample_count;
 461     int did, sdid, data_length;
 462     int i, ret;
 463
 464     if (count != 1)
 465         av_log(s, AV_LOG_WARNING, "unsupported multiple ANC packets (%d) per KLV packet\n", count);
 466
 467     for (i = 0; i < count; i++) {
 468         if (length < 6) {
 469             av_log(s, AV_LOG_ERROR, "error reading s436m packet %"PRId64"\n", length);
 470             return AVERROR_INVALIDDATA;
 471         }
 472         line_num = avio_rb16(s->pb);
 473         avio_r8(s->pb); // wrapping type
 474         sample_coding = avio_r8(s->pb);
 475         sample_count = avio_rb16(s->pb);
 476         length -= 6 + 8 + sample_count;
 477         if (line_num != 9 && line_num != 11)
 478             continue;
 479         if (sample_coding == 7 || sample_coding == 8 || sample_coding == 9) {
 480             av_log(s, AV_LOG_WARNING, "unsupported s436m 10 bit sample coding\n");
 481             continue;
 482         }
 483         if (length < 0)
 484             return AVERROR_INVALIDDATA;
 485
 486         avio_rb32(s->pb); // array count
 487         avio_rb32(s->pb); // array elem size
 488         did = avio_r8(s->pb);
 489         sdid = avio_r8(s->pb);
 490         data_length = avio_r8(s->pb);
 491         if (did != 0x61 || sdid != 1) {
 492             av_log(s, AV_LOG_WARNING, "unsupported did or sdid: %x %x\n", did, sdid);
 493             continue;
 494         }
 495         cdp_identifier = avio_rb16(s->pb); // cdp id
 496         if (cdp_identifier != 0x9669) {
 497             av_log(s, AV_LOG_ERROR, "wrong cdp identifier %x\n", cdp_identifier);
 498             return AVERROR_INVALIDDATA;
 499         }
 500         cdp_length = avio_r8(s->pb);
 501         avio_r8(s->pb); // cdp_frame_rate
 502         avio_r8(s->pb); // cdp_flags
 503         avio_rb16(s->pb); // cdp_hdr_sequence_cntr
 504         ccdata_id = avio_r8(s->pb); // ccdata_id
 505         if (ccdata_id != 0x72) {
 506             av_log(s, AV_LOG_ERROR, "wrong cdp data section %x\n", ccdata_id);
 507             return AVERROR_INVALIDDATA;
 508         }
 509         cc_count = avio_r8(s->pb) & 0x1f;
 510         ret = av_get_packet(s->pb, pkt, cc_count * 3);
 511         if (ret < 0)
 512             return ret;
 513         if (cdp_length - 9 - 4 <  cc_count * 3) {
 514             av_log(s, AV_LOG_ERROR, "wrong cdp size %d cc count %d\n", cdp_length, cc_count);
 515             return AVERROR_INVALIDDATA;
 516         }
 517         avio_skip(s->pb, data_length - 9 - 4 - cc_count * 3);
 518         cdp_footer_id = avio_r8(s->pb);
 519         if (cdp_footer_id != 0x74) {
 520             av_log(s, AV_LOG_ERROR, "wrong cdp footer section %x\n", cdp_footer_id);
 521             return AVERROR_INVALIDDATA;
 522         }
 523         avio_rb16(s->pb); // cdp_ftr_sequence_cntr
 524         avio_r8(s->pb); // packet_checksum
 525         break;
 526     }
 527
 528     return 0;
 529 }
 530
 531 /* XXX: use AVBitStreamFilter */
 532 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
 533 {
 534     const uint8_t *buf_ptr, *end_ptr;
 535     uint8_t *data_ptr;
 536     int i;
 537
 538     if (length > 61444) /* worst case PAL 1920 samples 8 channels */
 539         return AVERROR_INVALIDDATA;
 540     length = av_get_packet(pb, pkt, length);
 541     if (length < 0)
 542         return length;
 543     data_ptr = pkt->data;
 544     end_ptr = pkt->data + length;
 545     buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
 546     for (; end_ptr - buf_ptr >= st->codecpar->channels * 4; ) {
 547         for (i = 0; i < st->codecpar->channels; i++) {
 548             uint32_t sample = bytestream_get_le32(&buf_ptr);
 549             if (st->codecpar->bits_per_coded_sample == 24)
 550                 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
 551             else
 552                 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
 553         }
 554         buf_ptr += 32 - st->codecpar->channels*4; // always 8 channels stored SMPTE 331M
 555     }
 556     av_shrink_packet(pkt, data_ptr - pkt->data);
 557     return 0;
 558 }
 559
 560 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
 561 {
 562     static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
 563     MXFContext *mxf = s->priv_data;
 564     AVIOContext *pb = s->pb;
 565     int64_t end = avio_tell(pb) + klv->length;
 566     int64_t size;
 567     uint64_t orig_size;
 568     uint64_t plaintext_size;
 569     uint8_t ivec[16];
 570     uint8_t tmpbuf[16];
 571     int index;
 572     int body_sid;
 573
 574     if (!mxf->aesc && s->key && s->keylen == 16) {
 575         mxf->aesc = av_aes_alloc();
 576         if (!mxf->aesc)
 577             return AVERROR(ENOMEM);
 578         av_aes_init(mxf->aesc, s->key, 128, 1);
 579     }
 580     // crypto context
 581     size = klv_decode_ber_length(pb);
 582     if (size < 0)
 583         return size;
 584     avio_skip(pb, size);
 585     // plaintext offset
 586     klv_decode_ber_length(pb);
 587     plaintext_size = avio_rb64(pb);
 588     // source klv key
 589     klv_decode_ber_length(pb);
 590     avio_read(pb, klv->key, 16);
 591     if (!IS_KLV_KEY(klv, mxf_essence_element_key))
 592         return AVERROR_INVALIDDATA;
 593
 594     body_sid = find_body_sid_by_absolute_offset(mxf, klv->offset);
 595     index = mxf_get_stream_index(s, klv, body_sid);
 596     if (index < 0)
 597         return AVERROR_INVALIDDATA;
 598     // source size
 599     klv_decode_ber_length(pb);
 600     orig_size = avio_rb64(pb);
 601     if (orig_size < plaintext_size)
 602         return AVERROR_INVALIDDATA;
 603     // enc. code
 604     size = klv_decode_ber_length(pb);
 605     if (size < 32 || size - 32 < orig_size)
 606         return AVERROR_INVALIDDATA;
 607     avio_read(pb, ivec, 16);
 608     avio_read(pb, tmpbuf, 16);
 609     if (mxf->aesc)
 610         av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
 611     if (memcmp(tmpbuf, checkv, 16))
 612         av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
 613     size -= 32;
 614     size = av_get_packet(pb, pkt, size);
 615     if (size < 0)
 616         return size;
 617     else if (size < plaintext_size)
 618         return AVERROR_INVALIDDATA;
 619     size -= plaintext_size;
 620     if (mxf->aesc)
 621         av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
 622                      &pkt->data[plaintext_size], size >> 4, ivec, 1);
 623     av_shrink_packet(pkt, orig_size);
 624     pkt->stream_index = index;
 625     avio_skip(pb, end - avio_tell(pb));
 626     return 0;
 627 }
 628
 629 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 630 {
 631     MXFContext *mxf = arg;
 632     int item_num = avio_rb32(pb);
 633     int item_len = avio_rb32(pb);
 634
 635     if (item_len != 18) {
 636         avpriv_request_sample(pb, "Primer pack item length %d", item_len);
 637         return AVERROR_PATCHWELCOME;
 638     }
 639     if (item_num > 65536 || item_num < 0) {
 640         av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
 641         return AVERROR_INVALIDDATA;
 642     }
 643     if (mxf->local_tags)
 644         av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
 645     av_free(mxf->local_tags);
 646     mxf->local_tags_count = 0;
 647     mxf->local_tags = av_calloc(item_num, item_len);
 648     if (!mxf->local_tags)
 649         return AVERROR(ENOMEM);
 650     mxf->local_tags_count = item_num;
 651     avio_read(pb, mxf->local_tags, item_num*item_len);
 652     return 0;
 653 }
 654
 655 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 656 {
 657     MXFContext *mxf = arg;
 658     AVFormatContext *s = mxf->fc;
 659     MXFPartition *partition, *tmp_part;
 660     UID op;
 661     uint64_t footer_partition;
 662     uint32_t nb_essence_containers;
 663
 664     if (mxf->partitions_count >= INT_MAX / 2)
 665         return AVERROR_INVALIDDATA;
 666
 667     tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
 668     if (!tmp_part)
 669         return AVERROR(ENOMEM);
 670     mxf->partitions = tmp_part;
 671
 672     if (mxf->parsing_backward) {
 673         /* insert the new partition pack in the middle
 674          * this makes the entries in mxf->partitions sorted by offset */
 675         memmove(&mxf->partitions[mxf->last_forward_partition+1],
 676                 &mxf->partitions[mxf->last_forward_partition],
 677                 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
 678         partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
 679     } else {
 680         mxf->last_forward_partition++;
 681         partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
 682     }
 683
 684     memset(partition, 0, sizeof(*partition));
 685     mxf->partitions_count++;
 686     partition->pack_length = avio_tell(pb) - klv_offset + size;
 687     partition->pack_ofs    = klv_offset;
 688
 689     switch(uid[13]) {
 690     case 2:
 691         partition->type = Header;
 692         break;
 693     case 3:
 694         partition->type = BodyPartition;
 695         break;
 696     case 4:
 697         partition->type = Footer;
 698         break;
 699     default:
 700         av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
 701         return AVERROR_INVALIDDATA;
 702     }
 703
 704     /* consider both footers to be closed (there is only Footer and CompleteFooter) */
 705     partition->closed = partition->type == Footer || !(uid[14] & 1);
 706     partition->complete = uid[14] > 2;
 707     avio_skip(pb, 4);
 708     partition->kag_size = avio_rb32(pb);
 709     partition->this_partition = avio_rb64(pb);
 710     partition->previous_partition = avio_rb64(pb);
 711     footer_partition = avio_rb64(pb);
 712     partition->header_byte_count = avio_rb64(pb);
 713     partition->index_byte_count = avio_rb64(pb);
 714     partition->index_sid = avio_rb32(pb);
 715     partition->body_offset = avio_rb64(pb);
 716     partition->body_sid = avio_rb32(pb);
 717     if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
 718         av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
 719         return AVERROR_INVALIDDATA;
 720     }
 721     nb_essence_containers = avio_rb32(pb);
 722
 723     if (partition->type == Header) {
 724         char str[36];
 725         snprintf(str, sizeof(str), "%08x.%08x.%08x.%08x", AV_RB32(&op[0]), AV_RB32(&op[4]), AV_RB32(&op[8]), AV_RB32(&op[12]));
 726         av_dict_set(&s->metadata, "operational_pattern_ul", str, 0);
 727     }
 728
 729     if (partition->this_partition &&
 730         partition->previous_partition == partition->this_partition) {
 731         av_log(mxf->fc, AV_LOG_ERROR,
 732                "PreviousPartition equal to ThisPartition %"PRIx64"\n",
 733                partition->previous_partition);
 734         /* override with the actual previous partition offset */
 735         if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
 736             MXFPartition *prev =
 737                 mxf->partitions + mxf->last_forward_partition - 2;
 738             partition->previous_partition = prev->this_partition;
 739         }
 740         /* if no previous body partition are found point to the header
 741          * partition */
 742         if (partition->previous_partition == partition->this_partition)
 743             partition->previous_partition = 0;
 744         av_log(mxf->fc, AV_LOG_ERROR,
 745                "Overriding PreviousPartition with %"PRIx64"\n",
 746                partition->previous_partition);
 747     }
 748
 749     /* some files don't have FooterPartition set in every partition */
 750     if (footer_partition) {
 751         if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
 752             av_log(mxf->fc, AV_LOG_ERROR,
 753                    "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
 754                    mxf->footer_partition, footer_partition);
 755         } else {
 756             mxf->footer_partition = footer_partition;
 757         }
 758     }
 759
 760     av_log(mxf->fc, AV_LOG_TRACE,
 761             "PartitionPack: ThisPartition = 0x%"PRIX64
 762             ", PreviousPartition = 0x%"PRIX64", "
 763             "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
 764             partition->this_partition,
 765             partition->previous_partition, footer_partition,
 766             partition->index_sid, partition->body_sid);
 767
 768     /* sanity check PreviousPartition if set */
 769     //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
 770     if (partition->previous_partition &&
 771         mxf->run_in + partition->previous_partition >= klv_offset) {
 772         av_log(mxf->fc, AV_LOG_ERROR,
 773                "PreviousPartition points to this partition or forward\n");
 774         return AVERROR_INVALIDDATA;
 775     }
 776
 777     if      (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
 778     else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
 779     else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
 780     else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
 781     else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
 782     else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
 783     else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
 784     else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
 785     else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
 786     else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
 787     else if (op[12] == 0x10) {
 788         /* SMPTE 390m: "There shall be exactly one essence container"
 789          * The following block deals with files that violate this, namely:
 790          * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
 791          * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
 792         if (nb_essence_containers != 1) {
 793             MXFOP op = nb_essence_containers ? OP1a : OPAtom;
 794
 795             /* only nag once */
 796             if (!mxf->op)
 797                 av_log(mxf->fc, AV_LOG_WARNING,
 798                        "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
 799                        nb_essence_containers,
 800                        op == OP1a ? "OP1a" : "OPAtom");
 801
 802             mxf->op = op;
 803         } else
 804             mxf->op = OPAtom;
 805     } else {
 806         av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
 807         mxf->op = OP1a;
 808     }
 809
 810     if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
 811         av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
 812                partition->kag_size);
 813
 814         if (mxf->op == OPSONYOpt)
 815             partition->kag_size = 512;
 816         else
 817             partition->kag_size = 1;
 818
 819         av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
 820     }
 821
 822     return 0;
 823 }
 824
 825 static int mxf_add_metadata_set(MXFContext *mxf, MXFMetadataSet **metadata_set)
 826 {
 827     MXFMetadataSet **tmp;
 828
 829     tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
 830     if (!tmp) {
 831         mxf_free_metadataset(metadata_set, 1);
 832         return AVERROR(ENOMEM);
 833     }
 834     mxf->metadata_sets = tmp;
 835     mxf->metadata_sets[mxf->metadata_sets_count] = *metadata_set;
 836     mxf->metadata_sets_count++;
 837     return 0;
 838 }
 839
 840 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 841 {
 842     MXFCryptoContext *cryptocontext = arg;
 843     if (size != 16)
 844         return AVERROR_INVALIDDATA;
 845     if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
 846         avio_read(pb, cryptocontext->source_container_ul, 16);
 847     return 0;
 848 }
 849
 850 static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
 851 {
 852     *count = avio_rb32(pb);
 853     av_free(*refs);
 854     *refs = av_calloc(*count, sizeof(UID));
 855     if (!*refs) {
 856         *count = 0;
 857         return AVERROR(ENOMEM);
 858     }
 859     avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
 860     avio_read(pb, (uint8_t *)*refs, *count * sizeof(UID));
 861     return 0;
 862 }
 863
 864 static inline int mxf_read_utf16_string(AVIOContext *pb, int size, char** str, int be)
 865 {
 866     int ret;
 867     size_t buf_size;
 868
 869     if (size < 0 || size > INT_MAX/2)
 870         return AVERROR(EINVAL);
 871
 872     buf_size = size + size / 2 + 1;
 873     av_free(*str);
 874     *str = av_malloc(buf_size);
 875     if (!*str)
 876         return AVERROR(ENOMEM);
 877
 878     if (be)
 879         ret = avio_get_str16be(pb, size, *str, buf_size);
 880     else
 881         ret = avio_get_str16le(pb, size, *str, buf_size);
 882
 883     if (ret < 0) {
 884         av_freep(str);
 885         return ret;
 886     }
 887
 888     return ret;
 889 }
 890
 891 #define READ_STR16(type, big_endian)                                               \
 892 static int mxf_read_utf16 ## type ##_string(AVIOContext *pb, int size, char** str) \
 893 {                                                                                  \
 894 return mxf_read_utf16_string(pb, size, str, big_endian);                           \
 895 }
 896 READ_STR16(be, 1)
 897 READ_STR16(le, 0)
 898 #undef READ_STR16
 899
 900 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 901 {
 902     MXFContext *mxf = arg;
 903     switch (tag) {
 904     case 0x1901:
 905         if (mxf->packages_refs)
 906             av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
 907         return mxf_read_strong_ref_array(pb, &mxf->packages_refs, &mxf->packages_count);
 908     case 0x1902:
 909         return mxf_read_strong_ref_array(pb, &mxf->essence_container_data_refs, &mxf->essence_container_data_count);
 910     }
 911     return 0;
 912 }
 913
 914 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 915 {
 916     MXFStructuralComponent *source_clip = arg;
 917     switch(tag) {
 918     case 0x0202:
 919         source_clip->duration = avio_rb64(pb);
 920         break;
 921     case 0x1201:
 922         source_clip->start_position = avio_rb64(pb);
 923         break;
 924     case 0x1101:
 925         /* UMID, only get last 16 bytes */
 926         avio_read(pb, source_clip->source_package_ul, 16);
 927         avio_read(pb, source_clip->source_package_uid, 16);
 928         break;
 929     case 0x1102:
 930         source_clip->source_track_id = avio_rb32(pb);
 931         break;
 932     }
 933     return 0;
 934 }
 935
 936 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 937 {
 938     MXFTimecodeComponent *mxf_timecode = arg;
 939     switch(tag) {
 940     case 0x1501:
 941         mxf_timecode->start_frame = avio_rb64(pb);
 942         break;
 943     case 0x1502:
 944         mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
 945         break;
 946     case 0x1503:
 947         mxf_timecode->drop_frame = avio_r8(pb);
 948         break;
 949     }
 950     return 0;
 951 }
 952
 953 static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 954 {
 955     MXFPulldownComponent *mxf_pulldown = arg;
 956     switch(tag) {
 957     case 0x0d01:
 958         avio_read(pb, mxf_pulldown->input_segment_ref, 16);
 959         break;
 960     }
 961     return 0;
 962 }
 963
 964 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 965 {
 966     MXFTrack *track = arg;
 967     switch(tag) {
 968     case 0x4801:
 969         track->track_id = avio_rb32(pb);
 970         break;
 971     case 0x4804:
 972         avio_read(pb, track->track_number, 4);
 973         break;
 974     case 0x4802:
 975         mxf_read_utf16be_string(pb, size, &track->name);
 976         break;
 977     case 0x4b01:
 978         track->edit_rate.num = avio_rb32(pb);
 979         track->edit_rate.den = avio_rb32(pb);
 980         break;
 981     case 0x4803:
 982         avio_read(pb, track->sequence_ref, 16);
 983         break;
 984     }
 985     return 0;
 986 }
 987
 988 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
 989 {
 990     MXFSequence *sequence = arg;
 991     switch(tag) {
 992     case 0x0202:
 993         sequence->duration = avio_rb64(pb);
 994         break;
 995     case 0x0201:
 996         avio_read(pb, sequence->data_definition_ul, 16);
 997         break;
 998         case 0x4b02:
 999         sequence->origin = avio_r8(pb);
1000         break;
1001     case 0x1001:
1002         return mxf_read_strong_ref_array(pb, &sequence->structural_components_refs,
1003                                              &sequence->structural_components_count);
1004     }
1005     return 0;
1006 }
1007
1008 static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1009 {
1010     MXFEssenceGroup *essence_group = arg;
1011     switch (tag) {
1012     case 0x0202:
1013         essence_group->duration = avio_rb64(pb);
1014         break;
1015     case 0x0501:
1016         return mxf_read_strong_ref_array(pb, &essence_group->structural_components_refs,
1017                                              &essence_group->structural_components_count);
1018     }
1019     return 0;
1020 }
1021
1022 static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1023 {
1024     MXFPackage *package = arg;
1025     switch(tag) {
1026     case 0x4403:
1027         return mxf_read_strong_ref_array(pb, &package->tracks_refs,
1028                                              &package->tracks_count);
1029     case 0x4401:
1030         /* UMID */
1031         avio_read(pb, package->package_ul, 16);
1032         avio_read(pb, package->package_uid, 16);
1033         break;
1034     case 0x4701:
1035         avio_read(pb, package->descriptor_ref, 16);
1036         break;
1037     case 0x4402:
1038         return mxf_read_utf16be_string(pb, size, &package->name);
1039     case 0x4406:
1040         return mxf_read_strong_ref_array(pb, &package->comment_refs,
1041                                              &package->comment_count);
1042     }
1043     return 0;
1044 }
1045
1046 static int mxf_read_essence_container_data(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1047 {
1048     MXFEssenceContainerData *essence_data = arg;
1049     switch(tag) {
1050         case 0x2701:
1051             /* linked package umid UMID */
1052             avio_read(pb, essence_data->package_ul, 16);
1053             avio_read(pb, essence_data->package_uid, 16);
1054             break;
1055         case 0x3f06:
1056             essence_data->index_sid = avio_rb32(pb);
1057             break;
1058         case 0x3f07:
1059             essence_data->body_sid = avio_rb32(pb);
1060             break;
1061     }
1062     return 0;
1063 }
1064
1065 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
1066 {
1067     int i, length;
1068
1069     segment->nb_index_entries = avio_rb32(pb);
1070
1071     length = avio_rb32(pb);
1072     if(segment->nb_index_entries && length < 11)
1073         return AVERROR_INVALIDDATA;
1074
1075     if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
1076         !(segment->flag_entries          = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
1077         !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries)))) {
1078         av_freep(&segment->temporal_offset_entries);
1079         av_freep(&segment->flag_entries);
1080         return AVERROR(ENOMEM);
1081     }
1082
1083     for (i = 0; i < segment->nb_index_entries; i++) {
1084         if(avio_feof(pb))
1085             return AVERROR_INVALIDDATA;
1086         segment->temporal_offset_entries[i] = avio_r8(pb);
1087         avio_r8(pb);                                        /* KeyFrameOffset */
1088         segment->flag_entries[i] = avio_r8(pb);
1089         segment->stream_offset_entries[i] = avio_rb64(pb);
1090         avio_skip(pb, length - 11);
1091     }
1092     return 0;
1093 }
1094
1095 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1096 {
1097     MXFIndexTableSegment *segment = arg;
1098     switch(tag) {
1099     case 0x3F05:
1100         segment->edit_unit_byte_count = avio_rb32(pb);
1101         av_log(NULL, AV_LOG_TRACE, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
1102         break;
1103     case 0x3F06:
1104         segment->index_sid = avio_rb32(pb);
1105         av_log(NULL, AV_LOG_TRACE, "IndexSID %d\n", segment->index_sid);
1106         break;
1107     case 0x3F07:
1108         segment->body_sid = avio_rb32(pb);
1109         av_log(NULL, AV_LOG_TRACE, "BodySID %d\n", segment->body_sid);
1110         break;
1111     case 0x3F0A:
1112         av_log(NULL, AV_LOG_TRACE, "IndexEntryArray found\n");
1113         return mxf_read_index_entry_array(pb, segment);
1114     case 0x3F0B:
1115         segment->index_edit_rate.num = avio_rb32(pb);
1116         segment->index_edit_rate.den = avio_rb32(pb);
1117         av_log(NULL, AV_LOG_TRACE, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
1118                 segment->index_edit_rate.den);
1119         break;
1120     case 0x3F0C:
1121         segment->index_start_position = avio_rb64(pb);
1122         av_log(NULL, AV_LOG_TRACE, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
1123         break;
1124     case 0x3F0D:
1125         segment->index_duration = avio_rb64(pb);
1126         av_log(NULL, AV_LOG_TRACE, "IndexDuration %"PRId64"\n", segment->index_duration);
1127         break;
1128     }
1129     return 0;
1130 }
1131
1132 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
1133 {
1134     int code, value, ofs = 0;
1135     char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
1136
1137     do {
1138         code = avio_r8(pb);
1139         value = avio_r8(pb);
1140         av_log(NULL, AV_LOG_TRACE, "pixel layout: code %#x\n", code);
1141
1142         if (ofs <= 14) {
1143             layout[ofs++] = code;
1144             layout[ofs++] = value;
1145         } else
1146             break;  /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
1147     } while (code != 0); /* SMPTE 377M E.2.46 */
1148
1149     ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
1150 }
1151
1152 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1153 {
1154     MXFDescriptor *descriptor = arg;
1155     int entry_count, entry_size;
1156
1157     switch(tag) {
1158     case 0x3F01:
1159         return mxf_read_strong_ref_array(pb, &descriptor->sub_descriptors_refs,
1160                                              &descriptor->sub_descriptors_count);
1161     case 0x3002: /* ContainerDuration */
1162         descriptor->duration = avio_rb64(pb);
1163         break;
1164     case 0x3004:
1165         avio_read(pb, descriptor->essence_container_ul, 16);
1166         break;
1167     case 0x3005:
1168         avio_read(pb, descriptor->codec_ul, 16);
1169         break;
1170     case 0x3006:
1171         descriptor->linked_track_id = avio_rb32(pb);
1172         break;
1173     case 0x3201: /* PictureEssenceCoding */
1174         avio_read(pb, descriptor->essence_codec_ul, 16);
1175         break;
1176     case 0x3203:
1177         descriptor->width = avio_rb32(pb);
1178         break;
1179     case 0x3202:
1180         descriptor->height = avio_rb32(pb);
1181         break;
1182     case 0x320C:
1183         descriptor->frame_layout = avio_r8(pb);
1184         break;
1185     case 0x320D:
1186         entry_count = avio_rb32(pb);
1187         entry_size = avio_rb32(pb);
1188         if (entry_size == 4) {
1189             if (entry_count > 0)
1190                 descriptor->video_line_map[0] = avio_rb32(pb);
1191             else
1192                 descriptor->video_line_map[0] = 0;
1193             if (entry_count > 1)
1194                 descriptor->video_line_map[1] = avio_rb32(pb);
1195             else
1196                 descriptor->video_line_map[1] = 0;
1197         } else
1198             av_log(NULL, AV_LOG_WARNING, "VideoLineMap element size %d currently not supported\n", entry_size);
1199         break;
1200     case 0x320E:
1201         descriptor->aspect_ratio.num = avio_rb32(pb);
1202         descriptor->aspect_ratio.den = avio_rb32(pb);
1203         break;
1204     case 0x3212:
1205         descriptor->field_dominance = avio_r8(pb);
1206         break;
1207     case 0x3301:
1208         descriptor->component_depth = avio_rb32(pb);
1209         break;
1210     case 0x3302:
1211         descriptor->horiz_subsampling = avio_rb32(pb);
1212         break;
1213     case 0x3308:
1214         descriptor->vert_subsampling = avio_rb32(pb);
1215         break;
1216     case 0x3D03:
1217         descriptor->sample_rate.num = avio_rb32(pb);
1218         descriptor->sample_rate.den = avio_rb32(pb);
1219         break;
1220     case 0x3D06: /* SoundEssenceCompression */
1221         avio_read(pb, descriptor->essence_codec_ul, 16);
1222         break;
1223     case 0x3D07:
1224         descriptor->channels = avio_rb32(pb);
1225         break;
1226     case 0x3D01:
1227         descriptor->bits_per_sample = avio_rb32(pb);
1228         break;
1229     case 0x3401:
1230         mxf_read_pixel_layout(pb, descriptor);
1231         break;
1232     default:
1233         /* Private uid used by SONY C0023S01.mxf */
1234         if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
1235             if (descriptor->extradata)
1236                 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1237             av_free(descriptor->extradata);
1238             descriptor->extradata_size = 0;
1239             descriptor->extradata = av_malloc(size);
1240             if (!descriptor->extradata)
1241                 return AVERROR(ENOMEM);
1242             descriptor->extradata_size = size;
1243             avio_read(pb, descriptor->extradata, size);
1244         }
1245         if (IS_KLV_KEY(uid, mxf_jp2k_rsiz)) {
1246             uint32_t rsiz = avio_rb16(pb);
1247             if (rsiz == FF_PROFILE_JPEG2000_DCINEMA_2K ||
1248                 rsiz == FF_PROFILE_JPEG2000_DCINEMA_4K)
1249                 descriptor->pix_fmt = AV_PIX_FMT_XYZ12;
1250         }
1251         break;
1252     }
1253     return 0;
1254 }
1255
1256 static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
1257 {
1258     MXFTaggedValue *tagged_value = arg;
1259     uint8_t key[17];
1260
1261     if (size <= 17)
1262         return 0;
1263
1264     avio_read(pb, key, 17);
1265     /* TODO: handle other types of of indirect values */
1266     if (memcmp(key, mxf_indirect_value_utf16le, 17) == 0) {
1267         return mxf_read_utf16le_string(pb, size - 17, &tagged_value->value);
1268     } else if (memcmp(key, mxf_indirect_value_utf16be, 17) == 0) {
1269         return mxf_read_utf16be_string(pb, size - 17, &tagged_value->value);
1270     }
1271     return 0;
1272 }
1273
1274 static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1275 {
1276     MXFTaggedValue *tagged_value = arg;
1277     switch (tag){
1278     case 0x5001:
1279         return mxf_read_utf16be_string(pb, size, &tagged_value->name);
1280     case 0x5003:
1281         return mxf_read_indirect_value(tagged_value, pb, size);
1282     }
1283     return 0;
1284 }
1285
1286 /*
1287  * Match an uid independently of the version byte and up to len common bytes
1288  * Returns: boolean
1289  */
1290 static int mxf_match_uid(const UID key, const UID uid, int len)
1291 {
1292     int i;
1293     for (i = 0; i < len; i++) {
1294         if (i != 7 && key[i] != uid[i])
1295             return 0;
1296     }
1297     return 1;
1298 }
1299
1300 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1301 {
1302     while (uls->uid[0]) {
1303         if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1304             break;
1305         uls++;
1306     }
1307     return uls;
1308 }
1309
1310 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1311 {
1312     int i;
1313
1314     if (!strong_ref)
1315         return NULL;
1316     for (i = 0; i < mxf->metadata_sets_count; i++) {
1317         if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
1318             (type == AnyType || mxf->metadata_sets[i]->type == type)) {
1319             return mxf->metadata_sets[i];
1320         }
1321     }
1322     return NULL;
1323 }
1324
1325 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1326     // video essence container uls
1327     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14,   AV_CODEC_ID_JPEG2000, NULL, 14 },
1328     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x10,0x60,0x01 }, 14,       AV_CODEC_ID_H264, NULL, 15 }, /* H.264 */
1329     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x11,0x01,0x00 }, 14,      AV_CODEC_ID_DNXHD, NULL, 14 }, /* VC-3 */
1330     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x12,0x01,0x00 }, 14,        AV_CODEC_ID_VC1, NULL, 14 }, /* VC-1 */
1331     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x14,0x01,0x00 }, 14,       AV_CODEC_ID_TIFF, NULL, 14 }, /* TIFF */
1332     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x15,0x01,0x00 }, 14,      AV_CODEC_ID_DIRAC, NULL, 14 }, /* VC-2 */
1333     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1b,0x01,0x00 }, 14,       AV_CODEC_ID_CFHD, NULL, 14 }, /* VC-5 */
1334     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1c,0x01,0x00 }, 14,     AV_CODEC_ID_PRORES, NULL, 14 }, /* ProRes */
1335     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO, NULL, 15 }, /* MPEG-ES */
1336     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x04,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO, NULL, 15, D10D11Wrap }, /* SMPTE D-10 mapping */
1337     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14,    AV_CODEC_ID_DVVIDEO, NULL, 15 }, /* DV 625 25mbps */
1338     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14,   AV_CODEC_ID_RAWVIDEO, NULL, 15, RawVWrap }, /* uncompressed picture */
1339     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15,     AV_CODEC_ID_HQ_HQA },
1340     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15,        AV_CODEC_ID_HQX },
1341     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x15,0x00,0x04,0x02,0x10,0x00,0x01 }, 16,       AV_CODEC_ID_HEVC, NULL, 15 }, /* Canon XF-HEVC */
1342     { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14,   AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1343     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,      AV_CODEC_ID_NONE },
1344 };
1345
1346 /* EC ULs for intra-only formats */
1347 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1348     { { 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 */
1349     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,       AV_CODEC_ID_NONE },
1350 };
1351
1352 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1353 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1354     { { 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 */
1355     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14,   AV_CODEC_ID_JPEG2000 }, /* JPEG 2000 code stream */
1356     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,       AV_CODEC_ID_NONE },
1357 };
1358
1359 /* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1360 static const MXFCodecUL mxf_intra_only_picture_coded_width[] = {
1361     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1362     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1363     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1364     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1365     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,    0 },
1366 };
1367
1368 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1369     // sound essence container uls
1370     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14, AV_CODEC_ID_PCM_S16LE, NULL, 14, RawAWrap }, /* BWF */
1371     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14,       AV_CODEC_ID_MP2, NULL, 15 }, /* MPEG-ES */
1372     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14, AV_CODEC_ID_PCM_S16LE, NULL, 13 }, /* D-10 Mapping 50Mbps PAL Extended Template */
1373     { { 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 */
1374     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x03,0x04,0x02,0x02,0x02,0x03,0x03,0x01,0x00 }, 14,       AV_CODEC_ID_AAC }, /* MPEG-2 AAC ADTS (legacy) */
1375     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0,      AV_CODEC_ID_NONE },
1376 };
1377
1378 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1379     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0d,0x00,0x00 }, 16, AV_CODEC_ID_NONE,      "vbi_smpte_436M", 11 },
1380     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, AV_CODEC_ID_NONE, "vbi_vanc_smpte_436M", 11 },
1381     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x13,0x01,0x01 }, 16, AV_CODEC_ID_TTML },
1382     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0, AV_CODEC_ID_NONE },
1383 };
1384
1385 static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
1386 {
1387     int val;
1388     const MXFCodecUL *codec_ul;
1389
1390     codec_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1391     if (!codec_ul->uid[0])
1392         codec_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1393     if (!codec_ul->uid[0])
1394         codec_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
1395     if (!codec_ul->uid[0] || !codec_ul->wrapping_indicator_pos)
1396         return UnknownWrapped;
1397
1398     val = (*essence_container_ul)[codec_ul->wrapping_indicator_pos];
1399     switch (codec_ul->wrapping_indicator_type) {
1400         case RawVWrap:
1401             val = val % 4;
1402             break;
1403         case RawAWrap:
1404             if (val == 0x03 || val == 0x04)
1405                 val -= 0x02;
1406             break;
1407         case D10D11Wrap:
1408             if (val == 0x02)
1409                 val = 0x01;
1410             break;
1411     }
1412     if (val == 0x01)
1413         return FrameWrapped;
1414     if (val == 0x02)
1415         return ClipWrapped;
1416     return UnknownWrapped;
1417 }
1418
1419 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1420 {
1421     int i, j, nb_segments = 0;
1422     MXFIndexTableSegment **unsorted_segments;
1423     int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1424
1425     /* count number of segments, allocate arrays and copy unsorted segments */
1426     for (i = 0; i < mxf->metadata_sets_count; i++)
1427         if (mxf->metadata_sets[i]->type == IndexTableSegment)
1428             nb_segments++;
1429
1430     if (!nb_segments)
1431         return AVERROR_INVALIDDATA;
1432
1433     if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1434         !(*sorted_segments  = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1435         av_freep(sorted_segments);
1436         av_free(unsorted_segments);
1437         return AVERROR(ENOMEM);
1438     }
1439
1440     for (i = nb_segments = 0; i < mxf->metadata_sets_count; i++) {
1441         if (mxf->metadata_sets[i]->type == IndexTableSegment) {
1442             MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1443             if (s->edit_unit_byte_count || s->nb_index_entries)
1444                 unsorted_segments[nb_segments++] = s;
1445             else
1446                 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1447                        s->index_sid, s->index_start_position);
1448         }
1449     }
1450
1451     if (!nb_segments) {
1452         av_freep(sorted_segments);
1453         av_free(unsorted_segments);
1454         return AVERROR_INVALIDDATA;
1455     }
1456
1457     *nb_sorted_segments = 0;
1458
1459     /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1460     for (i = 0; i < nb_segments; i++) {
1461         int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1462         uint64_t best_index_duration = 0;
1463
1464         for (j = 0; j < nb_segments; j++) {
1465             MXFIndexTableSegment *s = unsorted_segments[j];
1466
1467             /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1468              * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1469              * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1470              */
1471             if ((i == 0 ||
1472                  s->body_sid >  last_body_sid ||
1473                  s->body_sid == last_body_sid && s->index_sid >  last_index_sid ||
1474                  s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1475                 (best == -1 ||
1476                  s->body_sid <  best_body_sid ||
1477                  s->body_sid == best_body_sid && s->index_sid <  best_index_sid ||
1478                  s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position <  best_index_start ||
1479                  s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position == best_index_start && s->index_duration > best_index_duration)) {
1480                 best             = j;
1481                 best_body_sid    = s->body_sid;
1482                 best_index_sid   = s->index_sid;
1483                 best_index_start = s->index_start_position;
1484                 best_index_duration = s->index_duration;
1485             }
1486         }
1487
1488         /* no suitable entry found -> we're done */
1489         if (best == -1)
1490             break;
1491
1492         (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1493         last_body_sid    = best_body_sid;
1494         last_index_sid   = best_index_sid;
1495         last_index_start = best_index_start;
1496     }
1497
1498     av_free(unsorted_segments);
1499
1500     return 0;
1501 }
1502
1503 /**
1504  * Computes the absolute file offset of the given essence container offset
1505  */
1506 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
1507 {
1508     MXFPartition *last_p = NULL;
1509     int a, b, m, m0;
1510
1511     if (offset < 0)
1512         return AVERROR(EINVAL);
1513
1514     a = -1;
1515     b = mxf->partitions_count;
1516
1517     while (b - a > 1) {
1518         m0 = m = (a + b) >> 1;
1519
1520         while (m < b && mxf->partitions[m].body_sid != body_sid)
1521             m++;
1522
1523         if (m < b && mxf->partitions[m].body_offset <= offset)
1524             a = m;
1525         else
1526             b = m0;
1527     }
1528
1529     if (a >= 0)
1530         last_p = &mxf->partitions[a];
1531
1532     if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1533         *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1534         if (partition_out)
1535             *partition_out = last_p;
1536         return 0;
1537     }
1538
1539     av_log(mxf->fc, AV_LOG_ERROR,
1540            "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1541            offset, body_sid);
1542
1543     return AVERROR_INVALIDDATA;
1544 }
1545
1546 /**
1547  * Returns the end position of the essence container with given BodySID, or zero if unknown
1548  */
1549 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1550 {
1551     for (int x = mxf->partitions_count - 1; x >= 0; x--) {
1552         MXFPartition *p = &mxf->partitions[x];
1553
1554         if (p->body_sid != body_sid)
1555             continue;
1556
1557         if (!p->essence_length)
1558             return 0;
1559
1560         return p->essence_offset + p->essence_length;
1561     }
1562
1563     return 0;
1564 }
1565
1566 /* EditUnit -> absolute offset */
1567 static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, AVRational edit_rate, int64_t *edit_unit_out, int64_t *offset_out, MXFPartition **partition_out, int nag)
1568 {
1569     int i;
1570     int64_t offset_temp = 0;
1571
1572     edit_unit = av_rescale_q(edit_unit, index_table->segments[0]->index_edit_rate, edit_rate);
1573
1574     for (i = 0; i < index_table->nb_segments; i++) {
1575         MXFIndexTableSegment *s = index_table->segments[i];
1576
1577         edit_unit = FFMAX(edit_unit, s->index_start_position);  /* clamp if trying to seek before start */
1578
1579         if (edit_unit < s->index_start_position + s->index_duration) {
1580             int64_t index = edit_unit - s->index_start_position;
1581
1582             if (s->edit_unit_byte_count)
1583                 offset_temp += s->edit_unit_byte_count * index;
1584             else {
1585                 if (s->nb_index_entries == 2 * s->index_duration + 1)
1586                     index *= 2;     /* Avid index */
1587
1588                 if (index < 0 || index >= s->nb_index_entries) {
1589                     av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1590                            index_table->index_sid, s->index_start_position);
1591                     return AVERROR_INVALIDDATA;
1592                 }
1593
1594                 offset_temp = s->stream_offset_entries[index];
1595             }
1596
1597             if (edit_unit_out)
1598                 *edit_unit_out = av_rescale_q(edit_unit, edit_rate, s->index_edit_rate);
1599
1600             return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out, partition_out);
1601         } else {
1602             /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1603             offset_temp += s->edit_unit_byte_count * s->index_duration;
1604         }
1605     }
1606
1607     if (nag)
1608         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);
1609
1610     return AVERROR_INVALIDDATA;
1611 }
1612
1613 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1614 {
1615     int i, j, x;
1616     int8_t max_temporal_offset = -128;
1617     uint8_t *flags;
1618
1619     /* first compute how many entries we have */
1620     for (i = 0; i < index_table->nb_segments; i++) {
1621         MXFIndexTableSegment *s = index_table->segments[i];
1622
1623         if (!s->nb_index_entries) {
1624             index_table->nb_ptses = 0;
1625             return 0;                               /* no TemporalOffsets */
1626         }
1627
1628         if (s->index_duration > INT_MAX - index_table->nb_ptses) {
1629             index_table->nb_ptses = 0;
1630             av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration is too large\n", s->index_sid);
1631             return 0;
1632         }
1633
1634         index_table->nb_ptses += s->index_duration;
1635     }
1636
1637     /* paranoid check */
1638     if (index_table->nb_ptses <= 0)
1639         return 0;
1640
1641     if (!(index_table->ptses      = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1642         !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1643         !(index_table->offsets    = av_calloc(index_table->nb_ptses, sizeof(int8_t))) ||
1644         !(flags                   = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) {
1645         av_freep(&index_table->ptses);
1646         av_freep(&index_table->fake_index);
1647         av_freep(&index_table->offsets);
1648         return AVERROR(ENOMEM);
1649     }
1650
1651     /* we may have a few bad TemporalOffsets
1652      * make sure the corresponding PTSes don't have the bogus value 0 */
1653     for (x = 0; x < index_table->nb_ptses; x++)
1654         index_table->ptses[x] = AV_NOPTS_VALUE;
1655
1656     /**
1657      * We have this:
1658      *
1659      * x  TemporalOffset
1660      * 0:  0
1661      * 1:  1
1662      * 2:  1
1663      * 3: -2
1664      * 4:  1
1665      * 5:  1
1666      * 6: -2
1667      *
1668      * We want to transform it into this:
1669      *
1670      * x  DTS PTS
1671      * 0: -1   0
1672      * 1:  0   3
1673      * 2:  1   1
1674      * 3:  2   2
1675      * 4:  3   6
1676      * 5:  4   4
1677      * 6:  5   5
1678      *
1679      * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1680      * then settings mxf->first_dts = -max(TemporalOffset[x]).
1681      * The latter makes DTS <= PTS.
1682      */
1683     for (i = x = 0; i < index_table->nb_segments; i++) {
1684         MXFIndexTableSegment *s = index_table->segments[i];
1685         int index_delta = 1;
1686         int n = s->nb_index_entries;
1687
1688         if (s->nb_index_entries == 2 * s->index_duration + 1) {
1689             index_delta = 2;    /* Avid index */
1690             /* ignore the last entry - it's the size of the essence container */
1691             n--;
1692         }
1693
1694         for (j = 0; j < n; j += index_delta, x++) {
1695             int offset = s->temporal_offset_entries[j] / index_delta;
1696             int index  = x + offset;
1697
1698             if (x >= index_table->nb_ptses) {
1699                 av_log(mxf->fc, AV_LOG_ERROR,
1700                        "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1701                        s->nb_index_entries, s->index_duration);
1702                 break;
1703             }
1704
1705             flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1706
1707             if (index < 0 || index >= index_table->nb_ptses) {
1708                 av_log(mxf->fc, AV_LOG_ERROR,
1709                        "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1710                        x, offset, index);
1711                 continue;
1712             }
1713
1714             index_table->offsets[x] = offset;
1715             index_table->ptses[index] = x;
1716             max_temporal_offset = FFMAX(max_temporal_offset, offset);
1717         }
1718     }
1719
1720     /* calculate the fake index table in display order */
1721     for (x = 0; x < index_table->nb_ptses; x++) {
1722         index_table->fake_index[x].timestamp = x;
1723         if (index_table->ptses[x] != AV_NOPTS_VALUE)
1724             index_table->fake_index[index_table->ptses[x]].flags = flags[x];
1725     }
1726     av_freep(&flags);
1727
1728     index_table->first_dts = -max_temporal_offset;
1729
1730     return 0;
1731 }
1732
1733 /**
1734  * Sorts and collects index table segments into index tables.
1735  * Also computes PTSes if possible.
1736  */
1737 static int mxf_compute_index_tables(MXFContext *mxf)
1738 {
1739     int i, j, k, ret, nb_sorted_segments;
1740     MXFIndexTableSegment **sorted_segments = NULL;
1741
1742     if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1743         nb_sorted_segments <= 0) {
1744         av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1745         return 0;
1746     }
1747
1748     /* sanity check and count unique BodySIDs/IndexSIDs */
1749     for (i = 0; i < nb_sorted_segments; i++) {
1750         if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1751             mxf->nb_index_tables++;
1752         else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1753             av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1754             ret = AVERROR_INVALIDDATA;
1755             goto finish_decoding_index;
1756         }
1757     }
1758
1759     mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1760                                          sizeof(*mxf->index_tables));
1761     if (!mxf->index_tables) {
1762         av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1763         ret = AVERROR(ENOMEM);
1764         goto finish_decoding_index;
1765     }
1766
1767     /* distribute sorted segments to index tables */
1768     for (i = j = 0; i < nb_sorted_segments; i++) {
1769         if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1770             /* next IndexSID */
1771             j++;
1772         }
1773
1774         mxf->index_tables[j].nb_segments++;
1775     }
1776
1777     for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1778         MXFIndexTable *t = &mxf->index_tables[j];
1779         MXFTrack *mxf_track = NULL;
1780
1781         t->segments = av_mallocz_array(t->nb_segments,
1782                                        sizeof(*t->segments));
1783
1784         if (!t->segments) {
1785             av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1786                    " pointer array\n");
1787             ret = AVERROR(ENOMEM);
1788             goto finish_decoding_index;
1789         }
1790
1791         if (sorted_segments[i]->index_start_position)
1792             av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1793                    sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1794
1795         memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1796         t->index_sid = sorted_segments[i]->index_sid;
1797         t->body_sid = sorted_segments[i]->body_sid;
1798
1799         if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1800             goto finish_decoding_index;
1801
1802         for (k = 0; k < mxf->fc->nb_streams; k++) {
1803             MXFTrack *track = mxf->fc->streams[k]->priv_data;
1804             if (track && track->index_sid == t->index_sid) {
1805                 mxf_track = track;
1806                 break;
1807             }
1808         }
1809
1810         /* fix zero IndexDurations */
1811         for (k = 0; k < t->nb_segments; k++) {
1812             if (!t->segments[k]->index_edit_rate.num || !t->segments[k]->index_edit_rate.den) {
1813                 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has invalid IndexEditRate\n",
1814                        t->index_sid, k);
1815                 if (mxf_track)
1816                     t->segments[k]->index_edit_rate = mxf_track->edit_rate;
1817             }
1818
1819             if (t->segments[k]->index_duration)
1820                 continue;
1821
1822             if (t->nb_segments > 1)
1823                 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1824                        t->index_sid, k);
1825
1826             if (!mxf_track) {
1827                 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1828                 break;
1829             }
1830
1831             /* assume the first stream's duration is reasonable
1832              * leave index_duration = 0 on further segments in case we have any (unlikely)
1833              */
1834             t->segments[k]->index_duration = mxf_track->original_duration;
1835             break;
1836         }
1837     }
1838
1839     ret = 0;
1840 finish_decoding_index:
1841     av_free(sorted_segments);
1842     return ret;
1843 }
1844
1845 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1846 {
1847     return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1848                             &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1849            mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1850                             &descriptor->essence_codec_ul)->id     != AV_CODEC_ID_NONE;
1851 }
1852
1853 static int mxf_uid_to_str(UID uid, char **str)
1854 {
1855     int i;
1856     char *p;
1857     p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1858     if (!p)
1859         return AVERROR(ENOMEM);
1860     for (i = 0; i < sizeof(UID); i++) {
1861         snprintf(p, 2 + 1, "%.2x", uid[i]);
1862         p += 2;
1863         if (i == 3 || i == 5 || i == 7 || i == 9) {
1864             snprintf(p, 1 + 1, "-");
1865             p++;
1866         }
1867     }
1868     return 0;
1869 }
1870
1871 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1872 {
1873     int i;
1874     char *p;
1875     p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1876     if (!p)
1877         return AVERROR(ENOMEM);
1878     snprintf(p, 2 + 1, "0x");
1879     p += 2;
1880     for (i = 0; i < sizeof(UID); i++) {
1881         snprintf(p, 2 + 1, "%.2X", ul[i]);
1882         p += 2;
1883
1884     }
1885     for (i = 0; i < sizeof(UID); i++) {
1886         snprintf(p, 2 + 1, "%.2X", uid[i]);
1887         p += 2;
1888     }
1889     return 0;
1890 }
1891
1892 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1893 {
1894     char *str;
1895     int ret;
1896     if (!package)
1897         return 0;
1898     if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1899         return ret;
1900     av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1901     return 0;
1902 }
1903
1904 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1905 {
1906     char buf[AV_TIMECODE_STR_SIZE];
1907     av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1908
1909     return 0;
1910 }
1911
1912 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
1913 {
1914     MXFStructuralComponent *component = NULL;
1915     MXFPulldownComponent *pulldown = NULL;
1916
1917     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1918     if (!component)
1919         return NULL;
1920
1921     switch (component->type) {
1922     case TimecodeComponent:
1923         return (MXFTimecodeComponent*)component;
1924     case PulldownComponent: /* timcode component may be located on a pulldown component */
1925         pulldown = (MXFPulldownComponent*)component;
1926         return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
1927     default:
1928         break;
1929     }
1930     return NULL;
1931 }
1932
1933 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
1934 {
1935     MXFPackage *package = NULL;
1936     int i;
1937
1938     for (i = 0; i < mxf->packages_count; i++) {
1939         package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1940         if (!package)
1941             continue;
1942
1943         if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
1944             return package;
1945     }
1946     return NULL;
1947 }
1948
1949 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1950 {
1951     MXFDescriptor *sub_descriptor = NULL;
1952     int i;
1953
1954     if (!descriptor)
1955         return NULL;
1956
1957     if (descriptor->type == MultipleDescriptor) {
1958         for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1959             sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1960
1961             if (!sub_descriptor) {
1962                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1963                 continue;
1964             }
1965             if (sub_descriptor->linked_track_id == track_id) {
1966                 return sub_descriptor;
1967             }
1968         }
1969     } else if (descriptor->type == Descriptor)
1970         return descriptor;
1971
1972     return NULL;
1973 }
1974
1975 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
1976 {
1977     MXFStructuralComponent *component = NULL;
1978     MXFPackage *package = NULL;
1979     MXFDescriptor *descriptor = NULL;
1980     int i;
1981
1982     if (!essence_group || !essence_group->structural_components_count)
1983         return NULL;
1984
1985     /* essence groups contains multiple representations of the same media,
1986        this return the first components with a valid Descriptor typically index 0 */
1987     for (i =0; i < essence_group->structural_components_count; i++){
1988         component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1989         if (!component)
1990             continue;
1991
1992         if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
1993             continue;
1994
1995         descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1996         if (descriptor)
1997             return component;
1998     }
1999     return NULL;
2000 }
2001
2002 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
2003 {
2004     MXFStructuralComponent *component = NULL;
2005
2006     component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
2007     if (!component)
2008         return NULL;
2009     switch (component->type) {
2010         case SourceClip:
2011             return component;
2012         case EssenceGroup:
2013             return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
2014         default:
2015             break;
2016     }
2017     return NULL;
2018 }
2019
2020 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
2021 {
2022     MXFTaggedValue *tag;
2023     int i;
2024     char *key = NULL;
2025
2026     for (i = 0; i < package->comment_count; i++) {
2027         tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
2028         if (!tag || !tag->name || !tag->value)
2029             continue;
2030
2031         key = av_asprintf("comment_%s", tag->name);
2032         if (!key)
2033             return AVERROR(ENOMEM);
2034
2035         av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
2036     }
2037     return 0;
2038 }
2039
2040 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
2041 {
2042     MXFPackage *physical_package = NULL;
2043     MXFTrack *physical_track = NULL;
2044     MXFStructuralComponent *sourceclip = NULL;
2045     MXFTimecodeComponent *mxf_tc = NULL;
2046     int i, j, k;
2047     AVTimecode tc;
2048     int flags;
2049     int64_t start_position;
2050
2051     for (i = 0; i < source_track->sequence->structural_components_count; i++) {
2052         sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
2053         if (!sourceclip)
2054             continue;
2055
2056         if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
2057             break;
2058
2059         mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
2060
2061         /* the name of physical source package is name of the reel or tape */
2062         if (physical_package->name && physical_package->name[0])
2063             av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
2064
2065         /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
2066          * to the start_frame of the timecode component located on one of the tracks of the physical source package.
2067          */
2068         for (j = 0; j < physical_package->tracks_count; j++) {
2069             if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
2070                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2071                 continue;
2072             }
2073
2074             if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
2075                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2076                 continue;
2077             }
2078
2079             if (physical_track->edit_rate.num <= 0 ||
2080                 physical_track->edit_rate.den <= 0) {
2081                 av_log(mxf->fc, AV_LOG_WARNING,
2082                        "Invalid edit rate (%d/%d) found on structural"
2083                        " component #%d, defaulting to 25/1\n",
2084                        physical_track->edit_rate.num,
2085                        physical_track->edit_rate.den, i);
2086                 physical_track->edit_rate = (AVRational){25, 1};
2087             }
2088
2089             for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
2090                 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
2091                     continue;
2092
2093                 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2094                 /* scale sourceclip start_position to match physical track edit rate */
2095                 start_position = av_rescale_q(sourceclip->start_position,
2096                                               physical_track->edit_rate,
2097                                               source_track->edit_rate);
2098
2099                 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
2100                     mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
2101                     return 0;
2102                 }
2103             }
2104         }
2105     }
2106
2107     return 0;
2108 }
2109
2110 static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
2111 {
2112     MXFStructuralComponent *component = NULL;
2113     const MXFCodecUL *codec_ul = NULL;
2114     MXFPackage tmp_package;
2115     AVStream *st;
2116     int j;
2117
2118     for (j = 0; j < track->sequence->structural_components_count; j++) {
2119         component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
2120         if (!component)
2121             continue;
2122         break;
2123     }
2124     if (!component)
2125         return 0;
2126
2127     st = avformat_new_stream(mxf->fc, NULL);
2128     if (!st) {
2129         av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
2130         return AVERROR(ENOMEM);
2131     }
2132
2133     st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
2134     st->codecpar->codec_id = AV_CODEC_ID_NONE;
2135     st->id = track->track_id;
2136
2137     memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
2138     memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
2139     mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
2140     if (track->name && track->name[0])
2141         av_dict_set(&st->metadata, "track_name", track->name, 0);
2142
2143     codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
2144     av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
2145     return 0;
2146 }
2147
2148 static int mxf_parse_structural_metadata(MXFContext *mxf)
2149 {
2150     MXFPackage *material_package = NULL;
2151     int i, j, k, ret;
2152
2153     av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
2154     /* TODO: handle multiple material packages (OP3x) */
2155     for (i = 0; i < mxf->packages_count; i++) {
2156         material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2157         if (material_package) break;
2158     }
2159     if (!material_package) {
2160         av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2161         return AVERROR_INVALIDDATA;
2162     }
2163
2164     mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2165     if (material_package->name && material_package->name[0])
2166         av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2167     mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2168
2169     for (i = 0; i < material_package->tracks_count; i++) {
2170         MXFPackage *source_package = NULL;
2171         MXFTrack *material_track = NULL;
2172         MXFTrack *source_track = NULL;
2173         MXFTrack *temp_track = NULL;
2174         MXFDescriptor *descriptor = NULL;
2175         MXFStructuralComponent *component = NULL;
2176         MXFTimecodeComponent *mxf_tc = NULL;
2177         UID *essence_container_ul = NULL;
2178         const MXFCodecUL *codec_ul = NULL;
2179         const MXFCodecUL *container_ul = NULL;
2180         const MXFCodecUL *pix_fmt_ul = NULL;
2181         AVStream *st;
2182         AVTimecode tc;
2183         int flags;
2184
2185         if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2186             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2187             continue;
2188         }
2189
2190         if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2191             mxf_tc = (MXFTimecodeComponent*)component;
2192             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2193             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2194                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2195             }
2196         }
2197
2198         if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2199             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2200             continue;
2201         }
2202
2203         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2204             component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2205             if (!component)
2206                 continue;
2207
2208             mxf_tc = (MXFTimecodeComponent*)component;
2209             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2210             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2211                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2212                 break;
2213             }
2214         }
2215
2216         /* TODO: handle multiple source clips, only finds first valid source clip */
2217         if(material_track->sequence->structural_components_count > 1)
2218             av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2219                        material_track->track_id, material_track->sequence->structural_components_count);
2220
2221         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2222             component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2223             if (!component)
2224                 continue;
2225
2226             source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2227             if (!source_package) {
2228                 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2229                 continue;
2230             }
2231             for (k = 0; k < source_package->tracks_count; k++) {
2232                 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2233                     av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2234                     ret = AVERROR_INVALIDDATA;
2235                     goto fail_and_free;
2236                 }
2237                 if (temp_track->track_id == component->source_track_id) {
2238                     source_track = temp_track;
2239                     break;
2240                 }
2241             }
2242             if (!source_track) {
2243                 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2244                 break;
2245             }
2246
2247             for (k = 0; k < mxf->essence_container_data_count; k++) {
2248                 MXFEssenceContainerData *essence_data;
2249
2250                 if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2251                     av_log(mxf->fc, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2252                     continue;
2253                 }
2254                 if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2255                     source_track->body_sid = essence_data->body_sid;
2256                     source_track->index_sid = essence_data->index_sid;
2257                     break;
2258                 }
2259             }
2260
2261             if(source_track && component)
2262                 break;
2263         }
2264         if (!source_track || !component || !source_package) {
2265             if((ret = mxf_add_metadata_stream(mxf, material_track)))
2266                 goto fail_and_free;
2267             continue;
2268         }
2269
2270         if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2271             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2272             ret = AVERROR_INVALIDDATA;
2273             goto fail_and_free;
2274         }
2275
2276         /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2277          * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2278         if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2279             av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2280             continue;
2281         }
2282
2283         st = avformat_new_stream(mxf->fc, NULL);
2284         if (!st) {
2285             av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2286             ret = AVERROR(ENOMEM);
2287             goto fail_and_free;
2288         }
2289         st->id = material_track->track_id;
2290         st->priv_data = source_track;
2291
2292         source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2293         descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2294
2295         /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2296          * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2297         if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2298             source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2299         else
2300             source_track->original_duration = st->duration = component->duration;
2301
2302         if (st->duration == -1)
2303             st->duration = AV_NOPTS_VALUE;
2304         st->start_time = component->start_position;
2305         if (material_track->edit_rate.num <= 0 ||
2306             material_track->edit_rate.den <= 0) {
2307             av_log(mxf->fc, AV_LOG_WARNING,
2308                    "Invalid edit rate (%d/%d) found on stream #%d, "
2309                    "defaulting to 25/1\n",
2310                    material_track->edit_rate.num,
2311                    material_track->edit_rate.den, st->index);
2312             material_track->edit_rate = (AVRational){25, 1};
2313         }
2314         avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2315
2316         /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2317          * the former is accessible via st->priv_data */
2318         source_track->edit_rate = material_track->edit_rate;
2319
2320         PRINT_KEY(mxf->fc, "data definition   ul", source_track->sequence->data_definition_ul);
2321         codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2322         st->codecpar->codec_type = codec_ul->id;
2323
2324         if (!descriptor) {
2325             av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2326             continue;
2327         }
2328         PRINT_KEY(mxf->fc, "essence codec     ul", descriptor->essence_codec_ul);
2329         PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2330         essence_container_ul = &descriptor->essence_container_ul;
2331         source_track->wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_kind(essence_container_ul);
2332         if (source_track->wrapping == UnknownWrapped)
2333             av_log(mxf->fc, AV_LOG_INFO, "wrapping of stream %d is unknown\n", st->index);
2334         /* HACK: replacing the original key with mxf_encrypted_essence_container
2335          * is not allowed according to s429-6, try to find correct information anyway */
2336         if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2337             av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2338             for (k = 0; k < mxf->metadata_sets_count; k++) {
2339                 MXFMetadataSet *metadata = mxf->metadata_sets[k];
2340                 if (metadata->type == CryptoContext) {
2341                     essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2342                     break;
2343                 }
2344             }
2345         }
2346
2347         /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2348         codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2349         st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2350         if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2351             codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2352             st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2353         }
2354
2355         av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2356                avcodec_get_name(st->codecpar->codec_id));
2357         for (k = 0; k < 16; k++) {
2358             av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2359                    descriptor->essence_codec_ul[k]);
2360             if (!(k+1 & 19) || k == 5)
2361                 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2362         }
2363         av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2364
2365         mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2366         if (source_package->name && source_package->name[0])
2367             av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2368         if (material_track->name && material_track->name[0])
2369             av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2370
2371         mxf_parse_physical_source_package(mxf, source_track, st);
2372
2373         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2374             source_track->intra_only = mxf_is_intra_only(descriptor);
2375             container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2376             if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2377                 st->codecpar->codec_id = container_ul->id;
2378             st->codecpar->width = descriptor->width;
2379             st->codecpar->height = descriptor->height; /* Field height, not frame height */
2380             switch (descriptor->frame_layout) {
2381                 case FullFrame:
2382                     st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2383                     break;
2384                 case OneField:
2385                     /* Every other line is stored and needs to be duplicated. */
2386                     av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2387                     break; /* The correct thing to do here is fall through, but by breaking we might be
2388                               able to decode some streams at half the vertical resolution, rather than not al all.
2389                               It's also for compatibility with the old behavior. */
2390                 case MixedFields:
2391                     break;
2392                 case SegmentedFrame:
2393                     st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2394                 case SeparateFields:
2395                     av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2396                            descriptor->video_line_map[0], descriptor->video_line_map[1],
2397                            descriptor->field_dominance);
2398                     if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2399                         /* Detect coded field order from VideoLineMap:
2400                          *  (even, even) => bottom field coded first
2401                          *  (even, odd)  => top field coded first
2402                          *  (odd, even)  => top field coded first
2403                          *  (odd, odd)   => bottom field coded first
2404                          */
2405                         if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2406                             switch (descriptor->field_dominance) {
2407                                 case MXF_FIELD_DOMINANCE_DEFAULT:
2408                                 case MXF_FIELD_DOMINANCE_FF:
2409                                     st->codecpar->field_order = AV_FIELD_TT;
2410                                     break;
2411                                 case MXF_FIELD_DOMINANCE_FL:
2412                                     st->codecpar->field_order = AV_FIELD_TB;
2413                                     break;
2414                                 default:
2415                                     avpriv_request_sample(mxf->fc,
2416                                                           "Field dominance %d support",
2417                                                           descriptor->field_dominance);
2418                             }
2419                         } else {
2420                             switch (descriptor->field_dominance) {
2421                                 case MXF_FIELD_DOMINANCE_DEFAULT:
2422                                 case MXF_FIELD_DOMINANCE_FF:
2423                                     st->codecpar->field_order = AV_FIELD_BB;
2424                                     break;
2425                                 case MXF_FIELD_DOMINANCE_FL:
2426                                     st->codecpar->field_order = AV_FIELD_BT;
2427                                     break;
2428                                 default:
2429                                     avpriv_request_sample(mxf->fc,
2430                                                           "Field dominance %d support",
2431                                                           descriptor->field_dominance);
2432                             }
2433                         }
2434                     }
2435                     /* Turn field height into frame height. */
2436                     st->codecpar->height *= 2;
2437                     break;
2438                 default:
2439                     av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2440             }
2441
2442             if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2443                 switch (descriptor->essence_codec_ul[14]) {
2444                 case 1: st->codecpar->codec_tag = MKTAG('a','p','c','o'); break;
2445                 case 2: st->codecpar->codec_tag = MKTAG('a','p','c','s'); break;
2446                 case 3: st->codecpar->codec_tag = MKTAG('a','p','c','n'); break;
2447                 case 4: st->codecpar->codec_tag = MKTAG('a','p','c','h'); break;
2448                 case 5: st->codecpar->codec_tag = MKTAG('a','p','4','h'); break;
2449                 case 6: st->codecpar->codec_tag = MKTAG('a','p','4','x'); break;
2450                 }
2451             }
2452
2453             if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2454                 st->codecpar->format = descriptor->pix_fmt;
2455                 if (st->codecpar->format == AV_PIX_FMT_NONE) {
2456                     pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2457                                                   &descriptor->essence_codec_ul);
2458                     st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2459                     if (st->codecpar->format== AV_PIX_FMT_NONE) {
2460                         st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2461                                                                    &descriptor->essence_codec_ul)->id;
2462                         if (!st->codecpar->codec_tag) {
2463                             /* support files created before RP224v10 by defaulting to UYVY422
2464                                if subsampling is 4:2:2 and component depth is 8-bit */
2465                             if (descriptor->horiz_subsampling == 2 &&
2466                                 descriptor->vert_subsampling == 1 &&
2467                                 descriptor->component_depth == 8) {
2468                                 st->codecpar->format = AV_PIX_FMT_UYVY422;
2469                             }
2470                         }
2471                     }
2472                 }
2473             }
2474             st->need_parsing = AVSTREAM_PARSE_HEADERS;
2475             if (material_track->sequence->origin) {
2476                 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2477             }
2478             if (source_track->sequence->origin) {
2479                 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2480             }
2481             if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2482                 st->display_aspect_ratio = descriptor->aspect_ratio;
2483         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2484             container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2485             /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2486             if (st->codecpar->codec_id == AV_CODEC_ID_NONE || (st->codecpar->codec_id == AV_CODEC_ID_PCM_ALAW && (enum AVCodecID)container_ul->id != AV_CODEC_ID_NONE))
2487                 st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2488             st->codecpar->channels = descriptor->channels;
2489
2490             if (descriptor->sample_rate.den > 0) {
2491                 st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2492                 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2493             } else {
2494                 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2495                        "found for stream #%d, time base forced to 1/48000\n",
2496                        descriptor->sample_rate.num, descriptor->sample_rate.den,
2497                        st->index);
2498                 avpriv_set_pts_info(st, 64, 1, 48000);
2499             }
2500
2501             /* if duration is set, rescale it from EditRate to SampleRate */
2502             if (st->duration != AV_NOPTS_VALUE)
2503                 st->duration = av_rescale_q(st->duration,
2504                                             av_inv_q(material_track->edit_rate),
2505                                             st->time_base);
2506
2507             /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2508             if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2509                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2510                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
2511                 else if (descriptor->bits_per_sample == 32)
2512                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
2513             } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2514                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2515                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
2516                 else if (descriptor->bits_per_sample == 32)
2517                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
2518             } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2519                 st->need_parsing = AVSTREAM_PARSE_FULL;
2520             }
2521             st->codecpar->bits_per_coded_sample = av_get_bits_per_sample(st->codecpar->codec_id);
2522         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2523             enum AVMediaType type;
2524             container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
2525             if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2526                 st->codecpar->codec_id = container_ul->id;
2527             type = avcodec_get_type(st->codecpar->codec_id);
2528             if (type == AVMEDIA_TYPE_SUBTITLE)
2529                 st->codecpar->codec_type = type;
2530             if (container_ul->desc)
2531                 av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
2532             if (mxf->eia608_extract &&
2533                 !strcmp(container_ul->desc, "vbi_vanc_smpte_436M")) {
2534                 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
2535                 st->codecpar->codec_id = AV_CODEC_ID_EIA_608;
2536             }
2537         }
2538         if (descriptor->extradata) {
2539             if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2540                 memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2541             }
2542         } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2543             int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2544                                                &descriptor->essence_codec_ul)->id;
2545             if (coded_width)
2546                 st->codecpar->width = coded_width;
2547             ret = ff_generate_avci_extradata(st);
2548             if (ret < 0)
2549                 return ret;
2550         }
2551         if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && source_track->wrapping != FrameWrapped) {
2552             /* TODO: decode timestamps */
2553             st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2554         }
2555     }
2556
2557     for (int i = 0; i < mxf->fc->nb_streams; i++) {
2558         MXFTrack *track1 = mxf->fc->streams[i]->priv_data;
2559         if (track1 && track1->body_sid) {
2560             for (int j = i + 1; j < mxf->fc->nb_streams; j++) {
2561                 MXFTrack *track2 = mxf->fc->streams[j]->priv_data;
2562                 if (track2 && track1->body_sid == track2->body_sid && track1->wrapping != track2->wrapping) {
2563                     if (track1->wrapping == UnknownWrapped)
2564                         track1->wrapping = track2->wrapping;
2565                     else if (track2->wrapping == UnknownWrapped)
2566                         track2->wrapping = track1->wrapping;
2567                     else
2568                         av_log(mxf->fc, AV_LOG_ERROR, "stream %d and stream %d have the same BodySID (%d) "
2569                                                       "with different wrapping\n", i, j, track1->body_sid);
2570                 }
2571             }
2572         }
2573     }
2574
2575     ret = 0;
2576 fail_and_free:
2577     return ret;
2578 }
2579
2580 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
2581 {
2582     struct tm time = { 0 };
2583     int msecs;
2584     time.tm_year = (timestamp >> 48) - 1900;
2585     time.tm_mon  = (timestamp >> 40 & 0xFF) - 1;
2586     time.tm_mday = (timestamp >> 32 & 0xFF);
2587     time.tm_hour = (timestamp >> 24 & 0xFF);
2588     time.tm_min  = (timestamp >> 16 & 0xFF);
2589     time.tm_sec  = (timestamp >> 8  & 0xFF);
2590     msecs        = (timestamp & 0xFF) * 4;
2591
2592     /* Clip values for legacy reasons. Maybe we should return error instead? */
2593     time.tm_mon  = av_clip(time.tm_mon,  0, 11);
2594     time.tm_mday = av_clip(time.tm_mday, 1, 31);
2595     time.tm_hour = av_clip(time.tm_hour, 0, 23);
2596     time.tm_min  = av_clip(time.tm_min,  0, 59);
2597     time.tm_sec  = av_clip(time.tm_sec,  0, 59);
2598     msecs        = av_clip(msecs, 0, 999);
2599
2600     return (int64_t)av_timegm(&time) * 1000000 + msecs * 1000;
2601 }
2602
2603 #define SET_STR_METADATA(pb, name, str) do { \
2604     if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2605         return ret; \
2606     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2607 } while (0)
2608
2609 #define SET_UID_METADATA(pb, name, var, str) do { \
2610     avio_read(pb, var, 16); \
2611     if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2612         return ret; \
2613     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2614 } while (0)
2615
2616 #define SET_TS_METADATA(pb, name, var, str) do { \
2617     var = avio_rb64(pb); \
2618     if (var && (ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var))) < 0) \
2619         return ret; \
2620 } while (0)
2621
2622 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2623 {
2624     MXFContext *mxf = arg;
2625     AVFormatContext *s = mxf->fc;
2626     int ret;
2627     UID uid = { 0 };
2628     char *str = NULL;
2629     uint64_t ts;
2630     switch (tag) {
2631     case 0x3C01:
2632         SET_STR_METADATA(pb, "company_name", str);
2633         break;
2634     case 0x3C02:
2635         SET_STR_METADATA(pb, "product_name", str);
2636         break;
2637     case 0x3C04:
2638         SET_STR_METADATA(pb, "product_version", str);
2639         break;
2640     case 0x3C05:
2641         SET_UID_METADATA(pb, "product_uid", uid, str);
2642         break;
2643     case 0x3C06:
2644         SET_TS_METADATA(pb, "modification_date", ts, str);
2645         break;
2646     case 0x3C08:
2647         SET_STR_METADATA(pb, "application_platform", str);
2648         break;
2649     case 0x3C09:
2650         SET_UID_METADATA(pb, "generation_uid", uid, str);
2651         break;
2652     case 0x3C0A:
2653         SET_UID_METADATA(pb, "uid", uid, str);
2654         break;
2655     }
2656     return 0;
2657 }
2658
2659 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2660 {
2661     MXFContext *mxf = arg;
2662     AVFormatContext *s = mxf->fc;
2663     int ret;
2664     char *str = NULL;
2665
2666     if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2667         SET_STR_METADATA(pb, "project_name", str);
2668     }
2669     return 0;
2670 }
2671
2672 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2673     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2674     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2675     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2676     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2677     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2678     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2679     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2680     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2681     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2682     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2683     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2684     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2685     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2686     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2687     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2688     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2689     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2690     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2691     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2692     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2693     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2694     { { 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 */
2695     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2696     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2697     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2698     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2699     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2700     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5b,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* VBI - SMPTE 436M */
2701     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5c,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* VANC/VBI - SMPTE 436M */
2702     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2703     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x64,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* DC Timed Text Descriptor */
2704     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2705     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2706     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2707     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2708     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2709     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2710     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
2711     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2712 };
2713
2714 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2715 {
2716     ctx->type = type;
2717     switch (type){
2718     case MultipleDescriptor:
2719     case Descriptor:
2720         ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2721         ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2722         break;
2723     default:
2724         break;
2725     }
2726     return 0;
2727 }
2728
2729 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2730 {
2731     AVIOContext *pb = mxf->fc->pb;
2732     MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2733     uint64_t klv_end = avio_tell(pb) + klv->length;
2734
2735     if (!ctx)
2736         return AVERROR(ENOMEM);
2737     if (ctx_size)
2738         mxf_metadataset_init(ctx, type);
2739     while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2740         int ret;
2741         int tag = avio_rb16(pb);
2742         int size = avio_rb16(pb); /* KLV specified by 0x53 */
2743         uint64_t next = avio_tell(pb) + size;
2744         UID uid = {0};
2745
2746         av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2747         if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2748             av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2749             continue;
2750         }
2751         if (tag > 0x7FFF) { /* dynamic tag */
2752             int i;
2753             for (i = 0; i < mxf->local_tags_count; i++) {
2754                 int local_tag = AV_RB16(mxf->local_tags+i*18);
2755                 if (local_tag == tag) {
2756                     memcpy(uid, mxf->local_tags+i*18+2, 16);
2757                     av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2758                     PRINT_KEY(mxf->fc, "uid", uid);
2759                 }
2760             }
2761         }
2762         if (ctx_size && tag == 0x3C0A) {
2763             avio_read(pb, ctx->uid, 16);
2764         } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2765             if (ctx_size)
2766                 mxf_free_metadataset(&ctx, 1);
2767             return ret;
2768         }
2769
2770         /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2771          * it extending past the end of the KLV though (zzuf5.mxf). */
2772         if (avio_tell(pb) > klv_end) {
2773             if (ctx_size) {
2774                 mxf_free_metadataset(&ctx, 1);
2775             }
2776
2777             av_log(mxf->fc, AV_LOG_ERROR,
2778                    "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2779                    tag, klv->offset);
2780             return AVERROR_INVALIDDATA;
2781         } else if (avio_tell(pb) <= next)   /* only seek forward, else this can loop for a long time */
2782             avio_seek(pb, next, SEEK_SET);
2783     }
2784     return ctx_size ? mxf_add_metadata_set(mxf, &ctx) : 0;
2785 }
2786
2787 /**
2788  * Matches any partition pack key, in other words:
2789  * - HeaderPartition
2790  * - BodyPartition
2791  * - FooterPartition
2792  * @return non-zero if the key is a partition pack key, zero otherwise
2793  */
2794 static int mxf_is_partition_pack_key(UID key)
2795 {
2796     //NOTE: this is a little lax since it doesn't constraint key[14]
2797     return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2798             key[13] >= 2 && key[13] <= 4;
2799 }
2800
2801 /**
2802  * Parses a metadata KLV
2803  * @return <0 on error, 0 otherwise
2804  */
2805 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2806                                      int ctx_size, enum MXFMetadataSetType type)
2807 {
2808     AVFormatContext *s = mxf->fc;
2809     int res;
2810     if (klv.key[5] == 0x53) {
2811         res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2812     } else {
2813         uint64_t next = avio_tell(s->pb) + klv.length;
2814         res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2815
2816         /* only seek forward, else this can loop for a long time */
2817         if (avio_tell(s->pb) > next) {
2818             av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2819                    klv.offset);
2820             return AVERROR_INVALIDDATA;
2821         }
2822
2823         avio_seek(s->pb, next, SEEK_SET);
2824     }
2825     if (res < 0) {
2826         av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2827         return res;
2828     }
2829     return 0;
2830 }
2831
2832 /**
2833  * Seeks to the previous partition and parses it, if possible
2834  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2835  */
2836 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2837 {
2838     AVIOContext *pb = mxf->fc->pb;
2839     KLVPacket klv;
2840     int64_t current_partition_ofs;
2841     int ret;
2842
2843     if (!mxf->current_partition ||
2844         mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2845         return 0;   /* we've parsed all partitions */
2846
2847     /* seek to previous partition */
2848     current_partition_ofs = mxf->current_partition->pack_ofs;   //includes run-in
2849     avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2850     mxf->current_partition = NULL;
2851
2852     av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
2853
2854     /* Make sure this is actually a PartitionPack, and if so parse it.
2855      * See deadlock2.mxf
2856      */
2857     if ((ret = klv_read_packet(&klv, pb)) < 0) {
2858         av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2859         return ret;
2860     }
2861
2862     if (!mxf_is_partition_pack_key(klv.key)) {
2863         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2864         return AVERROR_INVALIDDATA;
2865     }
2866
2867     /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2868      * can point to just before the current partition, causing klv_read_packet()
2869      * to sync back up to it. See deadlock3.mxf
2870      */
2871     if (klv.offset >= current_partition_ofs) {
2872         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2873                PRIx64 " indirectly points to itself\n", current_partition_ofs);
2874         return AVERROR_INVALIDDATA;
2875     }
2876
2877     if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2878         return ret;
2879
2880     return 1;
2881 }
2882
2883 /**
2884  * Called when essence is encountered
2885  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2886  */
2887 static int mxf_parse_handle_essence(MXFContext *mxf)
2888 {
2889     AVIOContext *pb = mxf->fc->pb;
2890     int64_t ret;
2891
2892     if (mxf->parsing_backward) {
2893         return mxf_seek_to_previous_partition(mxf);
2894     } else {
2895         if (!mxf->footer_partition) {
2896             av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
2897             return 0;
2898         }
2899
2900         av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
2901
2902         /* remember where we were so we don't end up seeking further back than this */
2903         mxf->last_forward_tell = avio_tell(pb);
2904
2905         if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2906             av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2907             return -1;
2908         }
2909
2910         /* seek to FooterPartition and parse backward */
2911         if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2912             av_log(mxf->fc, AV_LOG_ERROR,
2913                    "failed to seek to FooterPartition @ 0x%" PRIx64
2914                    " (%"PRId64") - partial file?\n",
2915                    mxf->run_in + mxf->footer_partition, ret);
2916             return ret;
2917         }
2918
2919         mxf->current_partition = NULL;
2920         mxf->parsing_backward = 1;
2921     }
2922
2923     return 1;
2924 }
2925
2926 /**
2927  * Called when the next partition or EOF is encountered
2928  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2929  */
2930 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2931 {
2932     return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2933 }
2934
2935 static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
2936 {
2937     for (int i = 0; i < s->nb_streams; i++) {
2938         MXFTrack *track = s->streams[i]->priv_data;
2939         if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
2940             return track->wrapping;
2941     }
2942     return UnknownWrapped;
2943 }
2944
2945 /**
2946  * Figures out the proper offset and length of the essence container in each partition
2947  */
2948 static void mxf_compute_essence_containers(AVFormatContext *s)
2949 {
2950     MXFContext *mxf = s->priv_data;
2951     int x;
2952
2953     for (x = 0; x < mxf->partitions_count; x++) {
2954         MXFPartition *p = &mxf->partitions[x];
2955         MXFWrappingScheme wrapping;
2956
2957         if (!p->body_sid)
2958             continue;       /* BodySID == 0 -> no essence */
2959
2960         /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
2961          * otherwise we point essence_offset at the key of the first essence KLV.
2962          */
2963
2964         wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
2965
2966         if (wrapping == ClipWrapped) {
2967             p->essence_offset = p->first_essence_klv.next_klv - p->first_essence_klv.length;
2968             p->essence_length = p->first_essence_klv.length;
2969         } else {
2970             p->essence_offset = p->first_essence_klv.offset;
2971
2972             /* essence container spans to the next partition */
2973             if (x < mxf->partitions_count - 1)
2974                 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2975
2976             if (p->essence_length < 0) {
2977                 /* next ThisPartition < essence_offset */
2978                 p->essence_length = 0;
2979                 av_log(mxf->fc, AV_LOG_ERROR,
2980                        "partition %i: bad ThisPartition = %"PRIX64"\n",
2981                        x+1, mxf->partitions[x+1].this_partition);
2982             }
2983         }
2984     }
2985 }
2986
2987 static int is_pcm(enum AVCodecID codec_id)
2988 {
2989     /* we only care about "normal" PCM codecs until we get samples */
2990     return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2991 }
2992
2993 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
2994 {
2995     int i;
2996     for (i = 0; i < mxf->nb_index_tables; i++)
2997         if (mxf->index_tables[i].index_sid == index_sid)
2998             return &mxf->index_tables[i];
2999     return NULL;
3000 }
3001
3002 /**
3003  * Deal with the case where for some audio atoms EditUnitByteCount is
3004  * very small (2, 4..). In those cases we should read more than one
3005  * sample per call to mxf_read_packet().
3006  */
3007 static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
3008 {
3009     MXFTrack *track = st->priv_data;
3010     MXFIndexTable *t;
3011
3012     if (!track)
3013         return;
3014     track->edit_units_per_packet = 1;
3015     if (track->wrapping != ClipWrapped)
3016         return;
3017
3018     t = mxf_find_index_table(mxf, track->index_sid);
3019
3020     /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
3021     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO         ||
3022         !is_pcm(st->codecpar->codec_id)                        ||
3023         !t                                                     ||
3024         t->nb_segments != 1                                    ||
3025         t->segments[0]->edit_unit_byte_count >= 32)
3026         return;
3027
3028     /* arbitrarily default to 48 kHz PAL audio frame size */
3029     /* TODO: We could compute this from the ratio between the audio
3030      *       and video edit rates for 48 kHz NTSC we could use the
3031      *       1802-1802-1802-1802-1801 pattern. */
3032     track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
3033 }
3034
3035 /**
3036  * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
3037  */
3038 static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
3039 {
3040     MXFTrack *track = st->priv_data;
3041     MXFIndexTableSegment *segment = NULL;
3042     MXFPartition *p = NULL;
3043     int essence_partition_count = 0;
3044     int edit_unit_byte_count = 0;
3045     int i, ret;
3046
3047     if (!track || track->wrapping != ClipWrapped)
3048         return 0;
3049
3050     /* check if track already has an IndexTableSegment */
3051     for (i = 0; i < mxf->metadata_sets_count; i++) {
3052         if (mxf->metadata_sets[i]->type == IndexTableSegment) {
3053             MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
3054             if (s->body_sid == track->body_sid)
3055                 return 0;
3056         }
3057     }
3058
3059     /* find the essence partition */
3060     for (i = 0; i < mxf->partitions_count; i++) {
3061         /* BodySID == 0 -> no essence */
3062         if (mxf->partitions[i].body_sid != track->body_sid)
3063             continue;
3064
3065         p = &mxf->partitions[i];
3066         essence_partition_count++;
3067     }
3068
3069     /* only handle files with a single essence partition */
3070     if (essence_partition_count != 1)
3071         return 0;
3072
3073     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && is_pcm(st->codecpar->codec_id)) {
3074         edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
3075     } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
3076         edit_unit_byte_count = p->first_essence_klv.length / st->duration;
3077     }
3078
3079     if (edit_unit_byte_count <= 0)
3080         return 0;
3081
3082     av_log(mxf->fc, AV_LOG_WARNING, "guessing index for stream %d using edit unit byte count %d\n", st->index, edit_unit_byte_count);
3083
3084     if (!(segment = av_mallocz(sizeof(*segment))))
3085         return AVERROR(ENOMEM);
3086
3087     if ((ret = mxf_add_metadata_set(mxf, (MXFMetadataSet**)&segment)))
3088         return ret;
3089
3090     /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
3091      * using the same SID for index is forbidden in MXF. */
3092     if (!track->index_sid)
3093         track->index_sid = track->body_sid;
3094
3095     segment->type = IndexTableSegment;
3096     /* stream will be treated as small EditUnitByteCount */
3097     segment->edit_unit_byte_count = edit_unit_byte_count;
3098     segment->index_start_position = 0;
3099     segment->index_duration = st->duration;
3100     segment->index_edit_rate = av_inv_q(st->time_base);
3101     segment->index_sid = track->index_sid;
3102     segment->body_sid = p->body_sid;
3103     return 0;
3104 }
3105
3106 static void mxf_read_random_index_pack(AVFormatContext *s)
3107 {
3108     MXFContext *mxf = s->priv_data;
3109     uint32_t length;
3110     int64_t file_size, max_rip_length, min_rip_length;
3111     KLVPacket klv;
3112
3113     if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
3114         return;
3115
3116     file_size = avio_size(s->pb);
3117
3118     /* S377m says to check the RIP length for "silly" values, without defining "silly".
3119      * The limit below assumes a file with nothing but partition packs and a RIP.
3120      * Before changing this, consider that a muxer may place each sample in its own partition.
3121      *
3122      * 105 is the size of the smallest possible PartitionPack
3123      * 12 is the size of each RIP entry
3124      * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3125      */
3126     max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3127     max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3128
3129     /* We're only interested in RIPs with at least two entries.. */
3130     min_rip_length = 16+1+24+4;
3131
3132     /* See S377m section 11 */
3133     avio_seek(s->pb, file_size - 4, SEEK_SET);
3134     length = avio_rb32(s->pb);
3135
3136     if (length < min_rip_length || length > max_rip_length)
3137         goto end;
3138     avio_seek(s->pb, file_size - length, SEEK_SET);
3139     if (klv_read_packet(&klv, s->pb) < 0 ||
3140         !IS_KLV_KEY(klv.key, mxf_random_index_pack_key))
3141         goto end;
3142     if (klv.next_klv != file_size || klv.length <= 4 || (klv.length - 4) % 12) {
3143         av_log(s, AV_LOG_WARNING, "Invalid RIP KLV length\n");
3144         goto end;
3145     }
3146
3147     avio_skip(s->pb, klv.length - 12);
3148     mxf->footer_partition = avio_rb64(s->pb);
3149
3150     /* sanity check */
3151     if (mxf->run_in + mxf->footer_partition >= file_size) {
3152         av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3153         mxf->footer_partition = 0;
3154     }
3155
3156 end:
3157     avio_seek(s->pb, mxf->run_in, SEEK_SET);
3158 }
3159
3160 static int mxf_read_header(AVFormatContext *s)
3161 {
3162     MXFContext *mxf = s->priv_data;
3163     KLVPacket klv;
3164     int64_t essence_offset = 0;
3165     int ret;
3166
3167     mxf->last_forward_tell = INT64_MAX;
3168
3169     if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
3170         av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3171         //goto fail should not be needed as no metadata sets will have been parsed yet
3172         return AVERROR_INVALIDDATA;
3173     }
3174     avio_seek(s->pb, -14, SEEK_CUR);
3175     mxf->fc = s;
3176     mxf->run_in = avio_tell(s->pb);
3177
3178     mxf_read_random_index_pack(s);
3179
3180     while (!avio_feof(s->pb)) {
3181         const MXFMetadataReadTableEntry *metadata;
3182
3183         if (klv_read_packet(&klv, s->pb) < 0) {
3184             /* EOF - seek to previous partition or stop */
3185             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3186                 break;
3187             else
3188                 continue;
3189         }
3190
3191         PRINT_KEY(s, "read header", klv.key);
3192         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3193         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
3194             IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3195             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3196             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
3197             IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
3198             IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
3199
3200             if (!mxf->current_partition) {
3201                 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3202                 ret = AVERROR_INVALIDDATA;
3203                 goto fail;
3204             }
3205
3206             if (!mxf->current_partition->first_essence_klv.offset)
3207                 mxf->current_partition->first_essence_klv = klv;
3208
3209             if (!essence_offset)
3210                 essence_offset = klv.offset;
3211
3212             /* seek to footer, previous partition or stop */
3213             if (mxf_parse_handle_essence(mxf) <= 0)
3214                 break;
3215             continue;
3216         } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3217             /* next partition pack - keep going, seek to previous partition or stop */
3218             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3219                 break;
3220             else if (mxf->parsing_backward)
3221                 continue;
3222             /* we're still parsing forward. proceed to parsing this partition pack */
3223         }
3224
3225         for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3226             if (IS_KLV_KEY(klv.key, metadata->key)) {
3227                 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3228                     goto fail;
3229                 break;
3230             }
3231         }
3232         if (!metadata->read) {
3233             av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3234                             UID_ARG(klv.key));
3235             avio_skip(s->pb, klv.length);
3236         }
3237     }
3238     /* FIXME avoid seek */
3239     if (!essence_offset)  {
3240         av_log(s, AV_LOG_ERROR, "no essence\n");
3241         ret = AVERROR_INVALIDDATA;
3242         goto fail;
3243     }
3244     avio_seek(s->pb, essence_offset, SEEK_SET);
3245
3246     /* we need to do this before computing the index tables
3247      * to be able to fill in zero IndexDurations with st->duration */
3248     if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3249         goto fail;
3250
3251     for (int i = 0; i < s->nb_streams; i++)
3252         mxf_handle_missing_index_segment(mxf, s->streams[i]);
3253
3254     if ((ret = mxf_compute_index_tables(mxf)) < 0)
3255         goto fail;
3256
3257     if (mxf->nb_index_tables > 1) {
3258         /* TODO: look up which IndexSID to use via EssenceContainerData */
3259         av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3260                mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3261     } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3262         av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3263         ret = AVERROR_INVALIDDATA;
3264         goto fail;
3265     }
3266
3267     mxf_compute_essence_containers(s);
3268
3269     for (int i = 0; i < s->nb_streams; i++)
3270         mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
3271
3272     return 0;
3273 fail:
3274     mxf_read_close(s);
3275
3276     return ret;
3277 }
3278
3279 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3280 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3281 {
3282     int64_t a, b, m, offset;
3283     MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3284
3285     if (!t || track->original_duration <= 0)
3286         return -1;
3287
3288     a = -1;
3289     b = track->original_duration;
3290
3291     while (b - a > 1) {
3292         m = (a + b) >> 1;
3293         if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3294             return -1;
3295         if (offset < current_offset)
3296             a = m;
3297         else
3298             b = m;
3299     }
3300
3301     *edit_unit_out = b;
3302
3303     return 0;
3304 }
3305
3306 static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st,
3307                                         int64_t edit_unit)
3308 {
3309     MXFTrack *track = st->priv_data;
3310     AVRational time_base = av_inv_q(track->edit_rate);
3311     AVRational sample_rate = av_inv_q(st->time_base);
3312
3313     // For non-audio sample_count equals current edit unit
3314     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
3315         return edit_unit;
3316
3317     if ((sample_rate.num / sample_rate.den) == 48000) {
3318         return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3319     } else {
3320         int remainder = (sample_rate.num * time_base.num) %
3321                         (time_base.den * sample_rate.den);
3322         if (remainder)
3323             av_log(mxf->fc, AV_LOG_WARNING,
3324                    "seeking detected on stream #%d with time base (%d/%d) and "
3325                    "sample rate (%d/%d), audio pts won't be accurate.\n",
3326                    st->index, time_base.num, time_base.den,
3327                    sample_rate.num, sample_rate.den);
3328         return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3329     }
3330 }
3331
3332 /**
3333  * Make sure track->sample_count is correct based on what offset we're currently at.
3334  * Also determine the next edit unit (or packet) offset.
3335  * @return next_ofs if OK, <0 on error
3336  */
3337 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3338 {
3339     int64_t next_ofs = -1;
3340     MXFTrack *track = st->priv_data;
3341     int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3342     int64_t new_edit_unit;
3343     MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3344
3345     if (!t || track->wrapping == UnknownWrapped)
3346         return -1;
3347
3348     if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3349         (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3350         av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3351         return -1;
3352     }
3353
3354     /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3355     if (next_ofs > current_offset)
3356         return next_ofs;
3357
3358     if (!resync) {
3359         av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3360         return -1;
3361     }
3362
3363     if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3364         av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3365         return -1;
3366     }
3367
3368     new_edit_unit--;
3369     track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3370     av_log(mxf->fc, AV_LOG_WARNING, "edit unit sync lost on stream %d, jumping from %"PRId64" to %"PRId64"\n", st->index, edit_unit, new_edit_unit);
3371
3372     return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3373 }
3374
3375 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3376                              AVPacket *pkt)
3377 {
3378     AVStream *st = mxf->fc->streams[pkt->stream_index];
3379     MXFTrack *track = st->priv_data;
3380     int64_t bits_per_sample = par->bits_per_coded_sample;
3381
3382     if (!bits_per_sample)
3383         bits_per_sample = av_get_bits_per_sample(par->codec_id);
3384
3385     pkt->pts = track->sample_count;
3386
3387     if (   par->channels <= 0
3388         || bits_per_sample <= 0
3389         || par->channels * (int64_t)bits_per_sample < 8)
3390         track->sample_count = mxf_compute_sample_count(mxf, st, av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate)) + 1);
3391     else
3392         track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3393
3394     return 0;
3395 }
3396
3397 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3398 {
3399     AVCodecParameters *par = st->codecpar;
3400     MXFTrack *track = st->priv_data;
3401
3402     if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3403         /* see if we have an index table to derive timestamps from */
3404         MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3405
3406         if (t && track->sample_count < t->nb_ptses) {
3407             pkt->dts = track->sample_count + t->first_dts;
3408             pkt->pts = t->ptses[track->sample_count];
3409         } else if (track->intra_only) {
3410             /* intra-only -> PTS = EditUnit.
3411              * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3412             pkt->pts = track->sample_count;
3413         }
3414         track->sample_count++;
3415     } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3416         int ret = mxf_set_audio_pts(mxf, par, pkt);
3417         if (ret < 0)
3418             return ret;
3419     } else if (track) {
3420         pkt->dts = pkt->pts = track->sample_count;
3421         pkt->duration = 1;
3422         track->sample_count++;
3423     }
3424     return 0;
3425 }
3426
3427 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3428 {
3429     KLVPacket klv;
3430     MXFContext *mxf = s->priv_data;
3431     int ret;
3432
3433     while (1) {
3434         int64_t max_data_size;
3435         int64_t pos = avio_tell(s->pb);
3436
3437         if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3438             mxf->current_klv_data = (KLVPacket){{0}};
3439             ret = klv_read_packet(&klv, s->pb);
3440             if (ret < 0)
3441                 break;
3442             max_data_size = klv.length;
3443             pos = klv.next_klv - klv.length;
3444             PRINT_KEY(s, "read packet", klv.key);
3445             av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3446             if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3447                 ret = mxf_decrypt_triplet(s, pkt, &klv);
3448                 if (ret < 0) {
3449                     av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3450                     return ret;
3451                 }
3452                 return 0;
3453             }
3454         } else {
3455             klv = mxf->current_klv_data;
3456             max_data_size = klv.next_klv - pos;
3457         }
3458         if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3459             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3460             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3461             int body_sid = find_body_sid_by_absolute_offset(mxf, klv.offset);
3462             int index = mxf_get_stream_index(s, &klv, body_sid);
3463             int64_t next_ofs;
3464             AVStream *st;
3465             MXFTrack *track;
3466
3467             if (index < 0) {
3468                 av_log(s, AV_LOG_ERROR,
3469                        "error getting stream index %"PRIu32"\n",
3470                        AV_RB32(klv.key + 12));
3471                 goto skip;
3472             }
3473
3474             st = s->streams[index];
3475             track = st->priv_data;
3476
3477             if (s->streams[index]->discard == AVDISCARD_ALL)
3478                 goto skip;
3479
3480             next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
3481
3482             if (track->wrapping != FrameWrapped) {
3483                 int64_t size;
3484
3485                 if (next_ofs <= 0) {
3486                     // If we have no way to packetize the data, then return it in chunks...
3487                     if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
3488                         st->need_parsing = AVSTREAM_PARSE_FULL;
3489                         avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
3490                     }
3491                     size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
3492                 } else {
3493                     if ((size = next_ofs - pos) <= 0) {
3494                         av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
3495                         mxf->current_klv_data = (KLVPacket){{0}};
3496                         return AVERROR_INVALIDDATA;
3497                     }
3498                     // We must not overread, because the next edit unit might be in another KLV
3499                     if (size > max_data_size)
3500                         size = max_data_size;
3501                 }
3502
3503                 mxf->current_klv_data = klv;
3504                 klv.offset = pos;
3505                 klv.length = size;
3506                 klv.next_klv = klv.offset + klv.length;
3507             }
3508
3509             /* check for 8 channels AES3 element */
3510             if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3511                 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3512                                               pkt, klv.length);
3513                 if (ret < 0) {
3514                     av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3515                     mxf->current_klv_data = (KLVPacket){{0}};
3516                     return ret;
3517                 }
3518             } else if (mxf->eia608_extract &&
3519                        s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
3520                 ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
3521                 if (ret < 0) {
3522                     mxf->current_klv_data = (KLVPacket){{0}};
3523                     return ret;
3524                 }
3525             } else {
3526                 ret = av_get_packet(s->pb, pkt, klv.length);
3527                 if (ret < 0) {
3528                     mxf->current_klv_data = (KLVPacket){{0}};
3529                     return ret;
3530                 }
3531             }
3532             pkt->stream_index = index;
3533             pkt->pos = klv.offset;
3534
3535             ret = mxf_set_pts(mxf, st, pkt);
3536             if (ret < 0) {
3537                 mxf->current_klv_data = (KLVPacket){{0}};
3538                 return ret;
3539             }
3540
3541             /* seek for truncated packets */
3542             avio_seek(s->pb, klv.next_klv, SEEK_SET);
3543
3544             return 0;
3545         } else {
3546         skip:
3547             avio_skip(s->pb, max_data_size);
3548             mxf->current_klv_data = (KLVPacket){{0}};
3549         }
3550     }
3551     return avio_feof(s->pb) ? AVERROR_EOF : ret;
3552 }
3553
3554 static int mxf_read_close(AVFormatContext *s)
3555 {
3556     MXFContext *mxf = s->priv_data;
3557     int i;
3558
3559     av_freep(&mxf->packages_refs);
3560     av_freep(&mxf->essence_container_data_refs);
3561
3562     for (i = 0; i < s->nb_streams; i++)
3563         s->streams[i]->priv_data = NULL;
3564
3565     for (i = 0; i < mxf->metadata_sets_count; i++) {
3566         mxf_free_metadataset(mxf->metadata_sets + i, 1);
3567     }
3568     mxf->metadata_sets_count = 0;
3569     av_freep(&mxf->partitions);
3570     av_freep(&mxf->metadata_sets);
3571     av_freep(&mxf->aesc);
3572     av_freep(&mxf->local_tags);
3573
3574     if (mxf->index_tables) {
3575         for (i = 0; i < mxf->nb_index_tables; i++) {
3576             av_freep(&mxf->index_tables[i].segments);
3577             av_freep(&mxf->index_tables[i].ptses);
3578             av_freep(&mxf->index_tables[i].fake_index);
3579             av_freep(&mxf->index_tables[i].offsets);
3580         }
3581     }
3582     av_freep(&mxf->index_tables);
3583
3584     return 0;
3585 }
3586
3587 static int mxf_probe(const AVProbeData *p) {
3588     const uint8_t *bufp = p->buf;
3589     const uint8_t *end = p->buf + p->buf_size;
3590
3591     if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3592         return 0;
3593
3594     /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3595     end -= sizeof(mxf_header_partition_pack_key);
3596
3597     for (; bufp < end;) {
3598         if (!((bufp[13] - 1) & 0xF2)){
3599             if (AV_RN32(bufp   ) == AV_RN32(mxf_header_partition_pack_key   ) &&
3600                 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3601                 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3602                 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3603                 return AVPROBE_SCORE_MAX;
3604             bufp ++;
3605         } else
3606             bufp += 10;
3607     }
3608
3609     return 0;
3610 }
3611
3612 /* rudimentary byte seek */
3613 /* XXX: use MXF Index */
3614 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3615 {
3616     AVStream *st = s->streams[stream_index];
3617     int64_t seconds;
3618     MXFContext* mxf = s->priv_data;
3619     int64_t seekpos;
3620     int i, ret;
3621     MXFIndexTable *t;
3622     MXFTrack *source_track = st->priv_data;
3623
3624     if (!source_track)
3625         return 0;
3626
3627     /* if audio then truncate sample_time to EditRate */
3628     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
3629         sample_time = av_rescale_q(sample_time, st->time_base,
3630                                    av_inv_q(source_track->edit_rate));
3631
3632     if (mxf->nb_index_tables <= 0) {
3633         if (!s->bit_rate)
3634             return AVERROR_INVALIDDATA;
3635         if (sample_time < 0)
3636             sample_time = 0;
3637         seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3638
3639         seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3640         if (seekpos < 0)
3641             return seekpos;
3642
3643         ff_update_cur_dts(s, st, sample_time);
3644         mxf->current_klv_data = (KLVPacket){{0}};
3645     } else {
3646         MXFPartition *partition;
3647
3648         t = &mxf->index_tables[0];
3649         if (t->index_sid != source_track->index_sid) {
3650             /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
3651             for (i = 0; i < s->nb_streams; i++) {
3652                 MXFTrack *new_source_track = s->streams[i]->priv_data;
3653                 if (new_source_track && new_source_track->index_sid == t->index_sid) {
3654                     sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
3655                     source_track = new_source_track;
3656                     st = s->streams[i];
3657                     break;
3658                 }
3659             }
3660             if (i == s->nb_streams)
3661                 return AVERROR_INVALIDDATA;
3662         }
3663
3664         /* clamp above zero, else ff_index_search_timestamp() returns negative
3665          * this also means we allow seeking before the start */
3666         sample_time = FFMAX(sample_time, 0);
3667
3668         if (t->fake_index) {
3669             /* The first frames may not be keyframes in presentation order, so
3670              * we have to advance the target to be able to find the first
3671              * keyframe backwards... */
3672             if (!(flags & AVSEEK_FLAG_ANY) &&
3673                 (flags & AVSEEK_FLAG_BACKWARD) &&
3674                 t->ptses[0] != AV_NOPTS_VALUE &&
3675                 sample_time < t->ptses[0] &&
3676                 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3677                 sample_time = t->ptses[0];
3678
3679             /* behave as if we have a proper index */
3680             if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3681                 return sample_time;
3682             /* get the stored order index from the display order index */
3683             sample_time += t->offsets[sample_time];
3684         } else {
3685             /* no IndexEntryArray (one or more CBR segments)
3686              * make sure we don't seek past the end */
3687             sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3688         }
3689
3690         if (source_track->wrapping == UnknownWrapped)
3691             av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
3692
3693         if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
3694             return ret;
3695
3696         ff_update_cur_dts(s, st, sample_time);
3697         if (source_track->wrapping == ClipWrapped) {
3698             KLVPacket klv = partition->first_essence_klv;
3699             if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
3700                 av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
3701                 return AVERROR_INVALIDDATA;
3702             }
3703             mxf->current_klv_data = klv;
3704         } else {
3705             mxf->current_klv_data = (KLVPacket){{0}};
3706         }
3707         avio_seek(s->pb, seekpos, SEEK_SET);
3708     }
3709
3710     // Update all tracks sample count
3711     for (i = 0; i < s->nb_streams; i++) {
3712         AVStream *cur_st = s->streams[i];
3713         MXFTrack *cur_track = cur_st->priv_data;
3714         if (cur_track) {
3715             int64_t track_edit_unit = sample_time;
3716             if (st != cur_st)
3717                 mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
3718             cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
3719         }
3720     }
3721     return 0;
3722 }
3723
3724 static const AVOption options[] = {
3725     { "eia608_extract", "extract eia 608 captions from s436m track",
3726       offsetof(MXFContext, eia608_extract), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
3727       AV_OPT_FLAG_DECODING_PARAM },
3728     { NULL },
3729 };
3730
3731 static const AVClass demuxer_class = {
3732     .class_name = "mxf",
3733     .item_name  = av_default_item_name,
3734     .option     = options,
3735     .version    = LIBAVUTIL_VERSION_INT,
3736     .category   = AV_CLASS_CATEGORY_DEMUXER,
3737 };
3738
3739 AVInputFormat ff_mxf_demuxer = {
3740     .name           = "mxf",
3741     .long_name      = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3742     .flags          = AVFMT_SEEK_TO_PTS,
3743     .priv_data_size = sizeof(MXFContext),
3744     .read_probe     = mxf_probe,
3745     .read_header    = mxf_read_header,
3746     .read_packet    = mxf_read_packet,
3747     .read_close     = mxf_read_close,
3748     .read_seek      = mxf_read_seek,
3749     .priv_class     = &demuxer_class,
3750 };