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