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 MXFTrack {
 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 size, 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         size = strlen(tag->name) + 8 + 1;
2029         key = av_mallocz(size);
2030         if (!key)
2031             return AVERROR(ENOMEM);
2032
2033         snprintf(key, size, "comment_%s", tag->name);
2034         av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
2035     }
2036     return 0;
2037 }
2038
2039 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
2040 {
2041     MXFPackage *physical_package = NULL;
2042     MXFTrack *physical_track = NULL;
2043     MXFStructuralComponent *sourceclip = NULL;
2044     MXFTimecodeComponent *mxf_tc = NULL;
2045     int i, j, k;
2046     AVTimecode tc;
2047     int flags;
2048     int64_t start_position;
2049
2050     for (i = 0; i < source_track->sequence->structural_components_count; i++) {
2051         sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
2052         if (!sourceclip)
2053             continue;
2054
2055         if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
2056             break;
2057
2058         mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
2059
2060         /* the name of physical source package is name of the reel or tape */
2061         if (physical_package->name && physical_package->name[0])
2062             av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
2063
2064         /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
2065          * to the start_frame of the timecode component located on one of the tracks of the physical source package.
2066          */
2067         for (j = 0; j < physical_package->tracks_count; j++) {
2068             if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
2069                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2070                 continue;
2071             }
2072
2073             if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
2074                 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2075                 continue;
2076             }
2077
2078             if (physical_track->edit_rate.num <= 0 ||
2079                 physical_track->edit_rate.den <= 0) {
2080                 av_log(mxf->fc, AV_LOG_WARNING,
2081                        "Invalid edit rate (%d/%d) found on structural"
2082                        " component #%d, defaulting to 25/1\n",
2083                        physical_track->edit_rate.num,
2084                        physical_track->edit_rate.den, i);
2085                 physical_track->edit_rate = (AVRational){25, 1};
2086             }
2087
2088             for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
2089                 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
2090                     continue;
2091
2092                 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2093                 /* scale sourceclip start_position to match physical track edit rate */
2094                 start_position = av_rescale_q(sourceclip->start_position,
2095                                               physical_track->edit_rate,
2096                                               source_track->edit_rate);
2097
2098                 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
2099                     mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
2100                     return 0;
2101                 }
2102             }
2103         }
2104     }
2105
2106     return 0;
2107 }
2108
2109 static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
2110 {
2111     MXFStructuralComponent *component = NULL;
2112     const MXFCodecUL *codec_ul = NULL;
2113     MXFPackage tmp_package;
2114     AVStream *st;
2115     int j;
2116
2117     for (j = 0; j < track->sequence->structural_components_count; j++) {
2118         component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
2119         if (!component)
2120             continue;
2121         break;
2122     }
2123     if (!component)
2124         return 0;
2125
2126     st = avformat_new_stream(mxf->fc, NULL);
2127     if (!st) {
2128         av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
2129         return AVERROR(ENOMEM);
2130     }
2131
2132     st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
2133     st->codecpar->codec_id = AV_CODEC_ID_NONE;
2134     st->id = track->track_id;
2135
2136     memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
2137     memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
2138     mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
2139     if (track->name && track->name[0])
2140         av_dict_set(&st->metadata, "track_name", track->name, 0);
2141
2142     codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
2143     av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
2144     return 0;
2145 }
2146
2147 static int mxf_parse_structural_metadata(MXFContext *mxf)
2148 {
2149     MXFPackage *material_package = NULL;
2150     int i, j, k, ret;
2151
2152     av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
2153     /* TODO: handle multiple material packages (OP3x) */
2154     for (i = 0; i < mxf->packages_count; i++) {
2155         material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2156         if (material_package) break;
2157     }
2158     if (!material_package) {
2159         av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2160         return AVERROR_INVALIDDATA;
2161     }
2162
2163     mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2164     if (material_package->name && material_package->name[0])
2165         av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2166     mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2167
2168     for (i = 0; i < material_package->tracks_count; i++) {
2169         MXFPackage *source_package = NULL;
2170         MXFTrack *material_track = NULL;
2171         MXFTrack *source_track = NULL;
2172         MXFTrack *temp_track = NULL;
2173         MXFDescriptor *descriptor = NULL;
2174         MXFStructuralComponent *component = NULL;
2175         MXFTimecodeComponent *mxf_tc = NULL;
2176         UID *essence_container_ul = NULL;
2177         const MXFCodecUL *codec_ul = NULL;
2178         const MXFCodecUL *container_ul = NULL;
2179         const MXFCodecUL *pix_fmt_ul = NULL;
2180         AVStream *st;
2181         AVTimecode tc;
2182         int flags;
2183
2184         if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2185             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2186             continue;
2187         }
2188
2189         if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2190             mxf_tc = (MXFTimecodeComponent*)component;
2191             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2192             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2193                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2194             }
2195         }
2196
2197         if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2198             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2199             continue;
2200         }
2201
2202         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2203             component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2204             if (!component)
2205                 continue;
2206
2207             mxf_tc = (MXFTimecodeComponent*)component;
2208             flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2209             if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2210                 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2211                 break;
2212             }
2213         }
2214
2215         /* TODO: handle multiple source clips, only finds first valid source clip */
2216         if(material_track->sequence->structural_components_count > 1)
2217             av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2218                        material_track->track_id, material_track->sequence->structural_components_count);
2219
2220         for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2221             component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2222             if (!component)
2223                 continue;
2224
2225             source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2226             if (!source_package) {
2227                 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2228                 continue;
2229             }
2230             for (k = 0; k < source_package->tracks_count; k++) {
2231                 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2232                     av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2233                     ret = AVERROR_INVALIDDATA;
2234                     goto fail_and_free;
2235                 }
2236                 if (temp_track->track_id == component->source_track_id) {
2237                     source_track = temp_track;
2238                     break;
2239                 }
2240             }
2241             if (!source_track) {
2242                 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2243                 break;
2244             }
2245
2246             for (k = 0; k < mxf->essence_container_data_count; k++) {
2247                 MXFEssenceContainerData *essence_data;
2248
2249                 if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2250                     av_log(mxf->fc, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2251                     continue;
2252                 }
2253                 if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2254                     source_track->body_sid = essence_data->body_sid;
2255                     source_track->index_sid = essence_data->index_sid;
2256                     break;
2257                 }
2258             }
2259
2260             if(source_track && component)
2261                 break;
2262         }
2263         if (!source_track || !component || !source_package) {
2264             if((ret = mxf_add_metadata_stream(mxf, material_track)))
2265                 goto fail_and_free;
2266             continue;
2267         }
2268
2269         if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2270             av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2271             ret = AVERROR_INVALIDDATA;
2272             goto fail_and_free;
2273         }
2274
2275         /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2276          * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2277         if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2278             av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2279             continue;
2280         }
2281
2282         st = avformat_new_stream(mxf->fc, NULL);
2283         if (!st) {
2284             av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2285             ret = AVERROR(ENOMEM);
2286             goto fail_and_free;
2287         }
2288         st->id = material_track->track_id;
2289         st->priv_data = source_track;
2290
2291         source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2292         descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2293
2294         /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2295          * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2296         if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2297             source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2298         else
2299             source_track->original_duration = st->duration = component->duration;
2300
2301         if (st->duration == -1)
2302             st->duration = AV_NOPTS_VALUE;
2303         st->start_time = component->start_position;
2304         if (material_track->edit_rate.num <= 0 ||
2305             material_track->edit_rate.den <= 0) {
2306             av_log(mxf->fc, AV_LOG_WARNING,
2307                    "Invalid edit rate (%d/%d) found on stream #%d, "
2308                    "defaulting to 25/1\n",
2309                    material_track->edit_rate.num,
2310                    material_track->edit_rate.den, st->index);
2311             material_track->edit_rate = (AVRational){25, 1};
2312         }
2313         avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2314
2315         /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2316          * the former is accessible via st->priv_data */
2317         source_track->edit_rate = material_track->edit_rate;
2318
2319         PRINT_KEY(mxf->fc, "data definition   ul", source_track->sequence->data_definition_ul);
2320         codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2321         st->codecpar->codec_type = codec_ul->id;
2322
2323         if (!descriptor) {
2324             av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2325             continue;
2326         }
2327         PRINT_KEY(mxf->fc, "essence codec     ul", descriptor->essence_codec_ul);
2328         PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2329         essence_container_ul = &descriptor->essence_container_ul;
2330         source_track->wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_kind(essence_container_ul);
2331         if (source_track->wrapping == UnknownWrapped)
2332             av_log(mxf->fc, AV_LOG_INFO, "wrapping of stream %d is unknown\n", st->index);
2333         /* HACK: replacing the original key with mxf_encrypted_essence_container
2334          * is not allowed according to s429-6, try to find correct information anyway */
2335         if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2336             av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2337             for (k = 0; k < mxf->metadata_sets_count; k++) {
2338                 MXFMetadataSet *metadata = mxf->metadata_sets[k];
2339                 if (metadata->type == CryptoContext) {
2340                     essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2341                     break;
2342                 }
2343             }
2344         }
2345
2346         /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2347         codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2348         st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2349         if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2350             codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2351             st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2352         }
2353
2354         av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2355                avcodec_get_name(st->codecpar->codec_id));
2356         for (k = 0; k < 16; k++) {
2357             av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2358                    descriptor->essence_codec_ul[k]);
2359             if (!(k+1 & 19) || k == 5)
2360                 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2361         }
2362         av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2363
2364         mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2365         if (source_package->name && source_package->name[0])
2366             av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2367         if (material_track->name && material_track->name[0])
2368             av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2369
2370         mxf_parse_physical_source_package(mxf, source_track, st);
2371
2372         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2373             source_track->intra_only = mxf_is_intra_only(descriptor);
2374             container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2375             if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2376                 st->codecpar->codec_id = container_ul->id;
2377             st->codecpar->width = descriptor->width;
2378             st->codecpar->height = descriptor->height; /* Field height, not frame height */
2379             switch (descriptor->frame_layout) {
2380                 case FullFrame:
2381                     st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2382                     break;
2383                 case OneField:
2384                     /* Every other line is stored and needs to be duplicated. */
2385                     av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2386                     break; /* The correct thing to do here is fall through, but by breaking we might be
2387                               able to decode some streams at half the vertical resolution, rather than not al all.
2388                               It's also for compatibility with the old behavior. */
2389                 case MixedFields:
2390                     break;
2391                 case SegmentedFrame:
2392                     st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2393                 case SeparateFields:
2394                     av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2395                            descriptor->video_line_map[0], descriptor->video_line_map[1],
2396                            descriptor->field_dominance);
2397                     if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2398                         /* Detect coded field order from VideoLineMap:
2399                          *  (even, even) => bottom field coded first
2400                          *  (even, odd)  => top field coded first
2401                          *  (odd, even)  => top field coded first
2402                          *  (odd, odd)   => bottom field coded first
2403                          */
2404                         if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2405                             switch (descriptor->field_dominance) {
2406                                 case MXF_FIELD_DOMINANCE_DEFAULT:
2407                                 case MXF_FIELD_DOMINANCE_FF:
2408                                     st->codecpar->field_order = AV_FIELD_TT;
2409                                     break;
2410                                 case MXF_FIELD_DOMINANCE_FL:
2411                                     st->codecpar->field_order = AV_FIELD_TB;
2412                                     break;
2413                                 default:
2414                                     avpriv_request_sample(mxf->fc,
2415                                                           "Field dominance %d support",
2416                                                           descriptor->field_dominance);
2417                             }
2418                         } else {
2419                             switch (descriptor->field_dominance) {
2420                                 case MXF_FIELD_DOMINANCE_DEFAULT:
2421                                 case MXF_FIELD_DOMINANCE_FF:
2422                                     st->codecpar->field_order = AV_FIELD_BB;
2423                                     break;
2424                                 case MXF_FIELD_DOMINANCE_FL:
2425                                     st->codecpar->field_order = AV_FIELD_BT;
2426                                     break;
2427                                 default:
2428                                     avpriv_request_sample(mxf->fc,
2429                                                           "Field dominance %d support",
2430                                                           descriptor->field_dominance);
2431                             }
2432                         }
2433                     }
2434                     /* Turn field height into frame height. */
2435                     st->codecpar->height *= 2;
2436                     break;
2437                 default:
2438                     av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2439             }
2440
2441             if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2442                 switch (descriptor->essence_codec_ul[14]) {
2443                 case 1: st->codecpar->codec_tag = MKTAG('a','p','c','o'); break;
2444                 case 2: st->codecpar->codec_tag = MKTAG('a','p','c','s'); break;
2445                 case 3: st->codecpar->codec_tag = MKTAG('a','p','c','n'); break;
2446                 case 4: st->codecpar->codec_tag = MKTAG('a','p','c','h'); break;
2447                 case 5: st->codecpar->codec_tag = MKTAG('a','p','4','h'); break;
2448                 case 6: st->codecpar->codec_tag = MKTAG('a','p','4','x'); break;
2449                 }
2450             }
2451
2452             if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2453                 st->codecpar->format = descriptor->pix_fmt;
2454                 if (st->codecpar->format == AV_PIX_FMT_NONE) {
2455                     pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2456                                                   &descriptor->essence_codec_ul);
2457                     st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2458                     if (st->codecpar->format== AV_PIX_FMT_NONE) {
2459                         st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2460                                                                    &descriptor->essence_codec_ul)->id;
2461                         if (!st->codecpar->codec_tag) {
2462                             /* support files created before RP224v10 by defaulting to UYVY422
2463                                if subsampling is 4:2:2 and component depth is 8-bit */
2464                             if (descriptor->horiz_subsampling == 2 &&
2465                                 descriptor->vert_subsampling == 1 &&
2466                                 descriptor->component_depth == 8) {
2467                                 st->codecpar->format = AV_PIX_FMT_UYVY422;
2468                             }
2469                         }
2470                     }
2471                 }
2472             }
2473             st->need_parsing = AVSTREAM_PARSE_HEADERS;
2474             if (material_track->sequence->origin) {
2475                 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2476             }
2477             if (source_track->sequence->origin) {
2478                 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2479             }
2480             if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2481                 st->display_aspect_ratio = descriptor->aspect_ratio;
2482         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2483             container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2484             /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2485             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))
2486                 st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2487             st->codecpar->channels = descriptor->channels;
2488
2489             if (descriptor->sample_rate.den > 0) {
2490                 st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2491                 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2492             } else {
2493                 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2494                        "found for stream #%d, time base forced to 1/48000\n",
2495                        descriptor->sample_rate.num, descriptor->sample_rate.den,
2496                        st->index);
2497                 avpriv_set_pts_info(st, 64, 1, 48000);
2498             }
2499
2500             /* if duration is set, rescale it from EditRate to SampleRate */
2501             if (st->duration != AV_NOPTS_VALUE)
2502                 st->duration = av_rescale_q(st->duration,
2503                                             av_inv_q(material_track->edit_rate),
2504                                             st->time_base);
2505
2506             /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2507             if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2508                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2509                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
2510                 else if (descriptor->bits_per_sample == 32)
2511                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
2512             } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2513                 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2514                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
2515                 else if (descriptor->bits_per_sample == 32)
2516                     st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
2517             } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2518                 st->need_parsing = AVSTREAM_PARSE_FULL;
2519             }
2520             st->codecpar->bits_per_coded_sample = av_get_bits_per_sample(st->codecpar->codec_id);
2521         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2522             enum AVMediaType type;
2523             container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
2524             if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2525                 st->codecpar->codec_id = container_ul->id;
2526             type = avcodec_get_type(st->codecpar->codec_id);
2527             if (type == AVMEDIA_TYPE_SUBTITLE)
2528                 st->codecpar->codec_type = type;
2529             if (container_ul->desc)
2530                 av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
2531             if (mxf->eia608_extract &&
2532                 !strcmp(container_ul->desc, "vbi_vanc_smpte_436M")) {
2533                 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
2534                 st->codecpar->codec_id = AV_CODEC_ID_EIA_608;
2535             }
2536         }
2537         if (descriptor->extradata) {
2538             if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2539                 memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2540             }
2541         } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2542             int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2543                                                &descriptor->essence_codec_ul)->id;
2544             if (coded_width)
2545                 st->codecpar->width = coded_width;
2546             ret = ff_generate_avci_extradata(st);
2547             if (ret < 0)
2548                 return ret;
2549         }
2550         if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && source_track->wrapping != FrameWrapped) {
2551             /* TODO: decode timestamps */
2552             st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2553         }
2554     }
2555
2556     for (int i = 0; i < mxf->fc->nb_streams; i++) {
2557         MXFTrack *track1 = mxf->fc->streams[i]->priv_data;
2558         if (track1 && track1->body_sid) {
2559             for (int j = i + 1; j < mxf->fc->nb_streams; j++) {
2560                 MXFTrack *track2 = mxf->fc->streams[j]->priv_data;
2561                 if (track2 && track1->body_sid == track2->body_sid && track1->wrapping != track2->wrapping) {
2562                     if (track1->wrapping == UnknownWrapped)
2563                         track1->wrapping = track2->wrapping;
2564                     else if (track2->wrapping == UnknownWrapped)
2565                         track2->wrapping = track1->wrapping;
2566                     else
2567                         av_log(mxf->fc, AV_LOG_ERROR, "stream %d and stream %d have the same BodySID (%d) "
2568                                                       "with different wrapping\n", i, j, track1->body_sid);
2569                 }
2570             }
2571         }
2572     }
2573
2574     ret = 0;
2575 fail_and_free:
2576     return ret;
2577 }
2578
2579 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
2580 {
2581     struct tm time = { 0 };
2582     int msecs;
2583     time.tm_year = (timestamp >> 48) - 1900;
2584     time.tm_mon  = (timestamp >> 40 & 0xFF) - 1;
2585     time.tm_mday = (timestamp >> 32 & 0xFF);
2586     time.tm_hour = (timestamp >> 24 & 0xFF);
2587     time.tm_min  = (timestamp >> 16 & 0xFF);
2588     time.tm_sec  = (timestamp >> 8  & 0xFF);
2589     msecs        = (timestamp & 0xFF) * 4;
2590
2591     /* Clip values for legacy reasons. Maybe we should return error instead? */
2592     time.tm_mon  = av_clip(time.tm_mon,  0, 11);
2593     time.tm_mday = av_clip(time.tm_mday, 1, 31);
2594     time.tm_hour = av_clip(time.tm_hour, 0, 23);
2595     time.tm_min  = av_clip(time.tm_min,  0, 59);
2596     time.tm_sec  = av_clip(time.tm_sec,  0, 59);
2597     msecs        = av_clip(msecs, 0, 999);
2598
2599     return (int64_t)av_timegm(&time) * 1000000 + msecs * 1000;
2600 }
2601
2602 #define SET_STR_METADATA(pb, name, str) do { \
2603     if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2604         return ret; \
2605     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2606 } while (0)
2607
2608 #define SET_UID_METADATA(pb, name, var, str) do { \
2609     avio_read(pb, var, 16); \
2610     if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2611         return ret; \
2612     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2613 } while (0)
2614
2615 #define SET_TS_METADATA(pb, name, var, str) do { \
2616     var = avio_rb64(pb); \
2617     if (var && (ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var))) < 0) \
2618         return ret; \
2619 } while (0)
2620
2621 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2622 {
2623     MXFContext *mxf = arg;
2624     AVFormatContext *s = mxf->fc;
2625     int ret;
2626     UID uid = { 0 };
2627     char *str = NULL;
2628     uint64_t ts;
2629     switch (tag) {
2630     case 0x3C01:
2631         SET_STR_METADATA(pb, "company_name", str);
2632         break;
2633     case 0x3C02:
2634         SET_STR_METADATA(pb, "product_name", str);
2635         break;
2636     case 0x3C04:
2637         SET_STR_METADATA(pb, "product_version", str);
2638         break;
2639     case 0x3C05:
2640         SET_UID_METADATA(pb, "product_uid", uid, str);
2641         break;
2642     case 0x3C06:
2643         SET_TS_METADATA(pb, "modification_date", ts, str);
2644         break;
2645     case 0x3C08:
2646         SET_STR_METADATA(pb, "application_platform", str);
2647         break;
2648     case 0x3C09:
2649         SET_UID_METADATA(pb, "generation_uid", uid, str);
2650         break;
2651     case 0x3C0A:
2652         SET_UID_METADATA(pb, "uid", uid, str);
2653         break;
2654     }
2655     return 0;
2656 }
2657
2658 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2659 {
2660     MXFContext *mxf = arg;
2661     AVFormatContext *s = mxf->fc;
2662     int ret;
2663     char *str = NULL;
2664
2665     if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2666         SET_STR_METADATA(pb, "project_name", str);
2667     }
2668     return 0;
2669 }
2670
2671 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2672     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2673     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2674     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2675     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2676     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2677     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2678     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2679     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2680     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2681     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2682     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2683     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2684     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2685     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2686     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2687     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2688     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2689     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2690     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2691     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2692     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2693     { { 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 */
2694     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2695     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2696     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2697     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2698     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2699     { { 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 */
2700     { { 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 */
2701     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2702     { { 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 */
2703     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2704     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2705     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2706     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2707     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2708     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2709     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
2710     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2711 };
2712
2713 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2714 {
2715     switch (type){
2716     case MultipleDescriptor:
2717     case Descriptor:
2718         ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2719         ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2720         break;
2721     default:
2722         break;
2723     }
2724     return 0;
2725 }
2726
2727 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2728 {
2729     AVIOContext *pb = mxf->fc->pb;
2730     MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2731     uint64_t klv_end = avio_tell(pb) + klv->length;
2732
2733     if (!ctx)
2734         return AVERROR(ENOMEM);
2735     mxf_metadataset_init(ctx, type);
2736     while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2737         int ret;
2738         int tag = avio_rb16(pb);
2739         int size = avio_rb16(pb); /* KLV specified by 0x53 */
2740         uint64_t next = avio_tell(pb) + size;
2741         UID uid = {0};
2742
2743         av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2744         if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2745             av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2746             continue;
2747         }
2748         if (tag > 0x7FFF) { /* dynamic tag */
2749             int i;
2750             for (i = 0; i < mxf->local_tags_count; i++) {
2751                 int local_tag = AV_RB16(mxf->local_tags+i*18);
2752                 if (local_tag == tag) {
2753                     memcpy(uid, mxf->local_tags+i*18+2, 16);
2754                     av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2755                     PRINT_KEY(mxf->fc, "uid", uid);
2756                 }
2757             }
2758         }
2759         if (ctx_size && tag == 0x3C0A) {
2760             avio_read(pb, ctx->uid, 16);
2761         } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2762             if (ctx_size)
2763                 mxf_free_metadataset(&ctx, 1);
2764             return ret;
2765         }
2766
2767         /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2768          * it extending past the end of the KLV though (zzuf5.mxf). */
2769         if (avio_tell(pb) > klv_end) {
2770             if (ctx_size) {
2771                 ctx->type = type;
2772                 mxf_free_metadataset(&ctx, 1);
2773             }
2774
2775             av_log(mxf->fc, AV_LOG_ERROR,
2776                    "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2777                    tag, klv->offset);
2778             return AVERROR_INVALIDDATA;
2779         } else if (avio_tell(pb) <= next)   /* only seek forward, else this can loop for a long time */
2780             avio_seek(pb, next, SEEK_SET);
2781     }
2782     if (ctx_size) ctx->type = type;
2783     return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2784 }
2785
2786 /**
2787  * Matches any partition pack key, in other words:
2788  * - HeaderPartition
2789  * - BodyPartition
2790  * - FooterPartition
2791  * @return non-zero if the key is a partition pack key, zero otherwise
2792  */
2793 static int mxf_is_partition_pack_key(UID key)
2794 {
2795     //NOTE: this is a little lax since it doesn't constraint key[14]
2796     return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2797             key[13] >= 2 && key[13] <= 4;
2798 }
2799
2800 /**
2801  * Parses a metadata KLV
2802  * @return <0 on error, 0 otherwise
2803  */
2804 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2805                                      int ctx_size, enum MXFMetadataSetType type)
2806 {
2807     AVFormatContext *s = mxf->fc;
2808     int res;
2809     if (klv.key[5] == 0x53) {
2810         res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2811     } else {
2812         uint64_t next = avio_tell(s->pb) + klv.length;
2813         res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2814
2815         /* only seek forward, else this can loop for a long time */
2816         if (avio_tell(s->pb) > next) {
2817             av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2818                    klv.offset);
2819             return AVERROR_INVALIDDATA;
2820         }
2821
2822         avio_seek(s->pb, next, SEEK_SET);
2823     }
2824     if (res < 0) {
2825         av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2826         return res;
2827     }
2828     return 0;
2829 }
2830
2831 /**
2832  * Seeks to the previous partition and parses it, if possible
2833  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2834  */
2835 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2836 {
2837     AVIOContext *pb = mxf->fc->pb;
2838     KLVPacket klv;
2839     int64_t current_partition_ofs;
2840     int ret;
2841
2842     if (!mxf->current_partition ||
2843         mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2844         return 0;   /* we've parsed all partitions */
2845
2846     /* seek to previous partition */
2847     current_partition_ofs = mxf->current_partition->pack_ofs;   //includes run-in
2848     avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2849     mxf->current_partition = NULL;
2850
2851     av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
2852
2853     /* Make sure this is actually a PartitionPack, and if so parse it.
2854      * See deadlock2.mxf
2855      */
2856     if ((ret = klv_read_packet(&klv, pb)) < 0) {
2857         av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2858         return ret;
2859     }
2860
2861     if (!mxf_is_partition_pack_key(klv.key)) {
2862         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2863         return AVERROR_INVALIDDATA;
2864     }
2865
2866     /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2867      * can point to just before the current partition, causing klv_read_packet()
2868      * to sync back up to it. See deadlock3.mxf
2869      */
2870     if (klv.offset >= current_partition_ofs) {
2871         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2872                PRIx64 " indirectly points to itself\n", current_partition_ofs);
2873         return AVERROR_INVALIDDATA;
2874     }
2875
2876     if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2877         return ret;
2878
2879     return 1;
2880 }
2881
2882 /**
2883  * Called when essence is encountered
2884  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2885  */
2886 static int mxf_parse_handle_essence(MXFContext *mxf)
2887 {
2888     AVIOContext *pb = mxf->fc->pb;
2889     int64_t ret;
2890
2891     if (mxf->parsing_backward) {
2892         return mxf_seek_to_previous_partition(mxf);
2893     } else {
2894         if (!mxf->footer_partition) {
2895             av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
2896             return 0;
2897         }
2898
2899         av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
2900
2901         /* remember where we were so we don't end up seeking further back than this */
2902         mxf->last_forward_tell = avio_tell(pb);
2903
2904         if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2905             av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2906             return -1;
2907         }
2908
2909         /* seek to FooterPartition and parse backward */
2910         if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2911             av_log(mxf->fc, AV_LOG_ERROR,
2912                    "failed to seek to FooterPartition @ 0x%" PRIx64
2913                    " (%"PRId64") - partial file?\n",
2914                    mxf->run_in + mxf->footer_partition, ret);
2915             return ret;
2916         }
2917
2918         mxf->current_partition = NULL;
2919         mxf->parsing_backward = 1;
2920     }
2921
2922     return 1;
2923 }
2924
2925 /**
2926  * Called when the next partition or EOF is encountered
2927  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2928  */
2929 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2930 {
2931     return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2932 }
2933
2934 static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
2935 {
2936     for (int i = 0; i < s->nb_streams; i++) {
2937         MXFTrack *track = s->streams[i]->priv_data;
2938         if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
2939             return track->wrapping;
2940     }
2941     return UnknownWrapped;
2942 }
2943
2944 /**
2945  * Figures out the proper offset and length of the essence container in each partition
2946  */
2947 static void mxf_compute_essence_containers(AVFormatContext *s)
2948 {
2949     MXFContext *mxf = s->priv_data;
2950     int x;
2951
2952     for (x = 0; x < mxf->partitions_count; x++) {
2953         MXFPartition *p = &mxf->partitions[x];
2954         MXFWrappingScheme wrapping;
2955
2956         if (!p->body_sid)
2957             continue;       /* BodySID == 0 -> no essence */
2958
2959         /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
2960          * otherwise we point essence_offset at the key of the first essence KLV.
2961          */
2962
2963         wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
2964
2965         if (wrapping == ClipWrapped) {
2966             p->essence_offset = p->first_essence_klv.next_klv - p->first_essence_klv.length;
2967             p->essence_length = p->first_essence_klv.length;
2968         } else {
2969             p->essence_offset = p->first_essence_klv.offset;
2970
2971             /* essence container spans to the next partition */
2972             if (x < mxf->partitions_count - 1)
2973                 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2974
2975             if (p->essence_length < 0) {
2976                 /* next ThisPartition < essence_offset */
2977                 p->essence_length = 0;
2978                 av_log(mxf->fc, AV_LOG_ERROR,
2979                        "partition %i: bad ThisPartition = %"PRIX64"\n",
2980                        x+1, mxf->partitions[x+1].this_partition);
2981             }
2982         }
2983     }
2984 }
2985
2986 static int is_pcm(enum AVCodecID codec_id)
2987 {
2988     /* we only care about "normal" PCM codecs until we get samples */
2989     return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2990 }
2991
2992 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
2993 {
2994     int i;
2995     for (i = 0; i < mxf->nb_index_tables; i++)
2996         if (mxf->index_tables[i].index_sid == index_sid)
2997             return &mxf->index_tables[i];
2998     return NULL;
2999 }
3000
3001 /**
3002  * Deal with the case where for some audio atoms EditUnitByteCount is
3003  * very small (2, 4..). In those cases we should read more than one
3004  * sample per call to mxf_read_packet().
3005  */
3006 static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
3007 {
3008     MXFTrack *track = st->priv_data;
3009     MXFIndexTable *t;
3010
3011     if (!track)
3012         return;
3013     track->edit_units_per_packet = 1;
3014     if (track->wrapping != ClipWrapped)
3015         return;
3016
3017     t = mxf_find_index_table(mxf, track->index_sid);
3018
3019     /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
3020     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO         ||
3021         !is_pcm(st->codecpar->codec_id)                        ||
3022         !t                                                     ||
3023         t->nb_segments != 1                                    ||
3024         t->segments[0]->edit_unit_byte_count >= 32)
3025         return;
3026
3027     /* arbitrarily default to 48 kHz PAL audio frame size */
3028     /* TODO: We could compute this from the ratio between the audio
3029      *       and video edit rates for 48 kHz NTSC we could use the
3030      *       1802-1802-1802-1802-1801 pattern. */
3031     track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
3032 }
3033
3034 /**
3035  * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
3036  */
3037 static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
3038 {
3039     MXFTrack *track = st->priv_data;
3040     MXFIndexTableSegment *segment = NULL;
3041     MXFPartition *p = NULL;
3042     int essence_partition_count = 0;
3043     int edit_unit_byte_count = 0;
3044     int i, ret;
3045
3046     if (!track || track->wrapping != ClipWrapped)
3047         return 0;
3048
3049     /* check if track already has an IndexTableSegment */
3050     for (i = 0; i < mxf->metadata_sets_count; i++) {
3051         if (mxf->metadata_sets[i]->type == IndexTableSegment) {
3052             MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
3053             if (s->body_sid == track->body_sid)
3054                 return 0;
3055         }
3056     }
3057
3058     /* find the essence partition */
3059     for (i = 0; i < mxf->partitions_count; i++) {
3060         /* BodySID == 0 -> no essence */
3061         if (mxf->partitions[i].body_sid != track->body_sid)
3062             continue;
3063
3064         p = &mxf->partitions[i];
3065         essence_partition_count++;
3066     }
3067
3068     /* only handle files with a single essence partition */
3069     if (essence_partition_count != 1)
3070         return 0;
3071
3072     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && is_pcm(st->codecpar->codec_id)) {
3073         edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
3074     } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
3075         edit_unit_byte_count = p->first_essence_klv.length / st->duration;
3076     }
3077
3078     if (edit_unit_byte_count <= 0)
3079         return 0;
3080
3081     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);
3082
3083     if (!(segment = av_mallocz(sizeof(*segment))))
3084         return AVERROR(ENOMEM);
3085
3086     if ((ret = mxf_add_metadata_set(mxf, segment))) {
3087         mxf_free_metadataset((MXFMetadataSet**)&segment, 1);
3088         return ret;
3089     }
3090
3091     /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
3092      * using the same SID for index is forbidden in MXF. */
3093     if (!track->index_sid)
3094         track->index_sid = track->body_sid;
3095
3096     segment->type = IndexTableSegment;
3097     /* stream will be treated as small EditUnitByteCount */
3098     segment->edit_unit_byte_count = edit_unit_byte_count;
3099     segment->index_start_position = 0;
3100     segment->index_duration = st->duration;
3101     segment->index_edit_rate = av_inv_q(st->time_base);
3102     segment->index_sid = track->index_sid;
3103     segment->body_sid = p->body_sid;
3104     return 0;
3105 }
3106
3107 static void mxf_read_random_index_pack(AVFormatContext *s)
3108 {
3109     MXFContext *mxf = s->priv_data;
3110     uint32_t length;
3111     int64_t file_size, max_rip_length, min_rip_length;
3112     KLVPacket klv;
3113
3114     if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
3115         return;
3116
3117     file_size = avio_size(s->pb);
3118
3119     /* S377m says to check the RIP length for "silly" values, without defining "silly".
3120      * The limit below assumes a file with nothing but partition packs and a RIP.
3121      * Before changing this, consider that a muxer may place each sample in its own partition.
3122      *
3123      * 105 is the size of the smallest possible PartitionPack
3124      * 12 is the size of each RIP entry
3125      * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3126      */
3127     max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3128     max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3129
3130     /* We're only interested in RIPs with at least two entries.. */
3131     min_rip_length = 16+1+24+4;
3132
3133     /* See S377m section 11 */
3134     avio_seek(s->pb, file_size - 4, SEEK_SET);
3135     length = avio_rb32(s->pb);
3136
3137     if (length < min_rip_length || length > max_rip_length)
3138         goto end;
3139     avio_seek(s->pb, file_size - length, SEEK_SET);
3140     if (klv_read_packet(&klv, s->pb) < 0 ||
3141         !IS_KLV_KEY(klv.key, mxf_random_index_pack_key))
3142         goto end;
3143     if (klv.next_klv != file_size || klv.length <= 4 || (klv.length - 4) % 12) {
3144         av_log(s, AV_LOG_WARNING, "Invalid RIP KLV length\n");
3145         goto end;
3146     }
3147
3148     avio_skip(s->pb, klv.length - 12);
3149     mxf->footer_partition = avio_rb64(s->pb);
3150
3151     /* sanity check */
3152     if (mxf->run_in + mxf->footer_partition >= file_size) {
3153         av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3154         mxf->footer_partition = 0;
3155     }
3156
3157 end:
3158     avio_seek(s->pb, mxf->run_in, SEEK_SET);
3159 }
3160
3161 static int mxf_read_header(AVFormatContext *s)
3162 {
3163     MXFContext *mxf = s->priv_data;
3164     KLVPacket klv;
3165     int64_t essence_offset = 0;
3166     int ret;
3167
3168     mxf->last_forward_tell = INT64_MAX;
3169
3170     if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
3171         av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3172         //goto fail should not be needed as no metadata sets will have been parsed yet
3173         return AVERROR_INVALIDDATA;
3174     }
3175     avio_seek(s->pb, -14, SEEK_CUR);
3176     mxf->fc = s;
3177     mxf->run_in = avio_tell(s->pb);
3178
3179     mxf_read_random_index_pack(s);
3180
3181     while (!avio_feof(s->pb)) {
3182         const MXFMetadataReadTableEntry *metadata;
3183
3184         if (klv_read_packet(&klv, s->pb) < 0) {
3185             /* EOF - seek to previous partition or stop */
3186             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3187                 break;
3188             else
3189                 continue;
3190         }
3191
3192         PRINT_KEY(s, "read header", klv.key);
3193         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3194         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
3195             IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3196             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3197             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
3198             IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
3199             IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
3200
3201             if (!mxf->current_partition) {
3202                 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3203                 ret = AVERROR_INVALIDDATA;
3204                 goto fail;
3205             }
3206
3207             if (!mxf->current_partition->first_essence_klv.offset)
3208                 mxf->current_partition->first_essence_klv = klv;
3209
3210             if (!essence_offset)
3211                 essence_offset = klv.offset;
3212
3213             /* seek to footer, previous partition or stop */
3214             if (mxf_parse_handle_essence(mxf) <= 0)
3215                 break;
3216             continue;
3217         } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3218             /* next partition pack - keep going, seek to previous partition or stop */
3219             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3220                 break;
3221             else if (mxf->parsing_backward)
3222                 continue;
3223             /* we're still parsing forward. proceed to parsing this partition pack */
3224         }
3225
3226         for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3227             if (IS_KLV_KEY(klv.key, metadata->key)) {
3228                 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3229                     goto fail;
3230                 break;
3231             }
3232         }
3233         if (!metadata->read) {
3234             av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3235                             UID_ARG(klv.key));
3236             avio_skip(s->pb, klv.length);
3237         }
3238     }
3239     /* FIXME avoid seek */
3240     if (!essence_offset)  {
3241         av_log(s, AV_LOG_ERROR, "no essence\n");
3242         ret = AVERROR_INVALIDDATA;
3243         goto fail;
3244     }
3245     avio_seek(s->pb, essence_offset, SEEK_SET);
3246
3247     /* we need to do this before computing the index tables
3248      * to be able to fill in zero IndexDurations with st->duration */
3249     if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3250         goto fail;
3251
3252     for (int i = 0; i < s->nb_streams; i++)
3253         mxf_handle_missing_index_segment(mxf, s->streams[i]);
3254
3255     if ((ret = mxf_compute_index_tables(mxf)) < 0)
3256         goto fail;
3257
3258     if (mxf->nb_index_tables > 1) {
3259         /* TODO: look up which IndexSID to use via EssenceContainerData */
3260         av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3261                mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3262     } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3263         av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3264         ret = AVERROR_INVALIDDATA;
3265         goto fail;
3266     }
3267
3268     mxf_compute_essence_containers(s);
3269
3270     for (int i = 0; i < s->nb_streams; i++)
3271         mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
3272
3273     return 0;
3274 fail:
3275     mxf_read_close(s);
3276
3277     return ret;
3278 }
3279
3280 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3281 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3282 {
3283     int64_t a, b, m, offset;
3284     MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3285
3286     if (!t || track->original_duration <= 0)
3287         return -1;
3288
3289     a = -1;
3290     b = track->original_duration;
3291
3292     while (b - a > 1) {
3293         m = (a + b) >> 1;
3294         if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3295             return -1;
3296         if (offset < current_offset)
3297             a = m;
3298         else
3299             b = m;
3300     }
3301
3302     *edit_unit_out = b;
3303
3304     return 0;
3305 }
3306
3307 static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st,
3308                                         int64_t edit_unit)
3309 {
3310     int i, total = 0, size = 0;
3311     MXFTrack *track = st->priv_data;
3312     AVRational time_base = av_inv_q(track->edit_rate);
3313     AVRational sample_rate = av_inv_q(st->time_base);
3314     const MXFSamplesPerFrame *spf = NULL;
3315     int64_t sample_count;
3316
3317     // For non-audio sample_count equals current edit unit
3318     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
3319         return edit_unit;
3320
3321     if ((sample_rate.num / sample_rate.den) == 48000)
3322         spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
3323     if (!spf) {
3324         int remainder = (sample_rate.num * time_base.num) %
3325                         (time_base.den * sample_rate.den);
3326         if (remainder)
3327             av_log(mxf->fc, AV_LOG_WARNING,
3328                    "seeking detected on stream #%d with time base (%d/%d) and "
3329                    "sample rate (%d/%d), audio pts won't be accurate.\n",
3330                    st->index, time_base.num, time_base.den,
3331                    sample_rate.num, sample_rate.den);
3332         return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3333     }
3334
3335     while (spf->samples_per_frame[size]) {
3336         total += spf->samples_per_frame[size];
3337         size++;
3338     }
3339
3340     av_assert2(size);
3341
3342     sample_count = (edit_unit / size) * (uint64_t)total;
3343     for (i = 0; i < edit_unit % size; i++) {
3344         sample_count += spf->samples_per_frame[i];
3345     }
3346
3347     return sample_count;
3348 }
3349
3350 /**
3351  * Make sure track->sample_count is correct based on what offset we're currently at.
3352  * Also determine the next edit unit (or packet) offset.
3353  * @return next_ofs if OK, <0 on error
3354  */
3355 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3356 {
3357     int64_t next_ofs = -1;
3358     MXFTrack *track = st->priv_data;
3359     int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3360     int64_t new_edit_unit;
3361     MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3362
3363     if (!t || track->wrapping == UnknownWrapped)
3364         return -1;
3365
3366     if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3367         (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3368         av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3369         return -1;
3370     }
3371
3372     /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3373     if (next_ofs > current_offset)
3374         return next_ofs;
3375
3376     if (!resync) {
3377         av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3378         return -1;
3379     }
3380
3381     if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3382         av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3383         return -1;
3384     }
3385
3386     new_edit_unit--;
3387     track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3388     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);
3389
3390     return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3391 }
3392
3393 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3394                              AVPacket *pkt)
3395 {
3396     AVStream *st = mxf->fc->streams[pkt->stream_index];
3397     MXFTrack *track = st->priv_data;
3398     int64_t bits_per_sample = par->bits_per_coded_sample;
3399
3400     if (!bits_per_sample)
3401         bits_per_sample = av_get_bits_per_sample(par->codec_id);
3402
3403     pkt->pts = track->sample_count;
3404
3405     if (   par->channels <= 0
3406         || bits_per_sample <= 0
3407         || par->channels * (int64_t)bits_per_sample < 8)
3408         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);
3409     else
3410         track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3411
3412     return 0;
3413 }
3414
3415 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3416 {
3417     AVCodecParameters *par = st->codecpar;
3418     MXFTrack *track = st->priv_data;
3419
3420     if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3421         /* see if we have an index table to derive timestamps from */
3422         MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3423
3424         if (t && track->sample_count < t->nb_ptses) {
3425             pkt->dts = track->sample_count + t->first_dts;
3426             pkt->pts = t->ptses[track->sample_count];
3427         } else if (track->intra_only) {
3428             /* intra-only -> PTS = EditUnit.
3429              * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3430             pkt->pts = track->sample_count;
3431         }
3432         track->sample_count++;
3433     } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3434         int ret = mxf_set_audio_pts(mxf, par, pkt);
3435         if (ret < 0)
3436             return ret;
3437     } else if (track) {
3438         pkt->dts = pkt->pts = track->sample_count;
3439         pkt->duration = 1;
3440         track->sample_count++;
3441     }
3442     return 0;
3443 }
3444
3445 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3446 {
3447     KLVPacket klv;
3448     MXFContext *mxf = s->priv_data;
3449     int ret;
3450
3451     while (1) {
3452         int64_t max_data_size;
3453         int64_t pos = avio_tell(s->pb);
3454
3455         if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3456             mxf->current_klv_data = (KLVPacket){{0}};
3457             ret = klv_read_packet(&klv, s->pb);
3458             if (ret < 0)
3459                 break;
3460             max_data_size = klv.length;
3461             pos = klv.next_klv - klv.length;
3462             PRINT_KEY(s, "read packet", klv.key);
3463             av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3464             if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3465                 ret = mxf_decrypt_triplet(s, pkt, &klv);
3466                 if (ret < 0) {
3467                     av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3468                     return ret;
3469                 }
3470                 return 0;
3471             }
3472         } else {
3473             klv = mxf->current_klv_data;
3474             max_data_size = klv.next_klv - pos;
3475         }
3476         if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3477             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3478             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3479             int body_sid = find_body_sid_by_absolute_offset(mxf, klv.offset);
3480             int index = mxf_get_stream_index(s, &klv, body_sid);
3481             int64_t next_ofs;
3482             AVStream *st;
3483             MXFTrack *track;
3484
3485             if (index < 0) {
3486                 av_log(s, AV_LOG_ERROR,
3487                        "error getting stream index %"PRIu32"\n",
3488                        AV_RB32(klv.key + 12));
3489                 goto skip;
3490             }
3491
3492             st = s->streams[index];
3493             track = st->priv_data;
3494
3495             if (s->streams[index]->discard == AVDISCARD_ALL)
3496                 goto skip;
3497
3498             next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
3499
3500             if (track->wrapping != FrameWrapped) {
3501                 int64_t size;
3502
3503                 if (next_ofs <= 0) {
3504                     // If we have no way to packetize the data, then return it in chunks...
3505                     if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
3506                         st->need_parsing = AVSTREAM_PARSE_FULL;
3507                         avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
3508                     }
3509                     size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
3510                 } else {
3511                     if ((size = next_ofs - pos) <= 0) {
3512                         av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
3513                         mxf->current_klv_data = (KLVPacket){{0}};
3514                         return AVERROR_INVALIDDATA;
3515                     }
3516                     // We must not overread, because the next edit unit might be in another KLV
3517                     if (size > max_data_size)
3518                         size = max_data_size;
3519                 }
3520
3521                 mxf->current_klv_data = klv;
3522                 klv.offset = pos;
3523                 klv.length = size;
3524                 klv.next_klv = klv.offset + klv.length;
3525             }
3526
3527             /* check for 8 channels AES3 element */
3528             if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3529                 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3530                                               pkt, klv.length);
3531                 if (ret < 0) {
3532                     av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3533                     mxf->current_klv_data = (KLVPacket){{0}};
3534                     return ret;
3535                 }
3536             } else if (mxf->eia608_extract &&
3537                        s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
3538                 ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
3539                 if (ret < 0) {
3540                     mxf->current_klv_data = (KLVPacket){{0}};
3541                     return ret;
3542                 }
3543             } else {
3544                 ret = av_get_packet(s->pb, pkt, klv.length);
3545                 if (ret < 0) {
3546                     mxf->current_klv_data = (KLVPacket){{0}};
3547                     return ret;
3548                 }
3549             }
3550             pkt->stream_index = index;
3551             pkt->pos = klv.offset;
3552
3553             ret = mxf_set_pts(mxf, st, pkt);
3554             if (ret < 0) {
3555                 mxf->current_klv_data = (KLVPacket){{0}};
3556                 return ret;
3557             }
3558
3559             /* seek for truncated packets */
3560             avio_seek(s->pb, klv.next_klv, SEEK_SET);
3561
3562             return 0;
3563         } else {
3564         skip:
3565             avio_skip(s->pb, max_data_size);
3566             mxf->current_klv_data = (KLVPacket){{0}};
3567         }
3568     }
3569     return avio_feof(s->pb) ? AVERROR_EOF : ret;
3570 }
3571
3572 static int mxf_read_close(AVFormatContext *s)
3573 {
3574     MXFContext *mxf = s->priv_data;
3575     int i;
3576
3577     av_freep(&mxf->packages_refs);
3578     av_freep(&mxf->essence_container_data_refs);
3579
3580     for (i = 0; i < s->nb_streams; i++)
3581         s->streams[i]->priv_data = NULL;
3582
3583     for (i = 0; i < mxf->metadata_sets_count; i++) {
3584         mxf_free_metadataset(mxf->metadata_sets + i, 1);
3585     }
3586     av_freep(&mxf->partitions);
3587     av_freep(&mxf->metadata_sets);
3588     av_freep(&mxf->aesc);
3589     av_freep(&mxf->local_tags);
3590
3591     if (mxf->index_tables) {
3592         for (i = 0; i < mxf->nb_index_tables; i++) {
3593             av_freep(&mxf->index_tables[i].segments);
3594             av_freep(&mxf->index_tables[i].ptses);
3595             av_freep(&mxf->index_tables[i].fake_index);
3596             av_freep(&mxf->index_tables[i].offsets);
3597         }
3598     }
3599     av_freep(&mxf->index_tables);
3600
3601     return 0;
3602 }
3603
3604 static int mxf_probe(const AVProbeData *p) {
3605     const uint8_t *bufp = p->buf;
3606     const uint8_t *end = p->buf + p->buf_size;
3607
3608     if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3609         return 0;
3610
3611     /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3612     end -= sizeof(mxf_header_partition_pack_key);
3613
3614     for (; bufp < end;) {
3615         if (!((bufp[13] - 1) & 0xF2)){
3616             if (AV_RN32(bufp   ) == AV_RN32(mxf_header_partition_pack_key   ) &&
3617                 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3618                 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3619                 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3620                 return AVPROBE_SCORE_MAX;
3621             bufp ++;
3622         } else
3623             bufp += 10;
3624     }
3625
3626     return 0;
3627 }
3628
3629 /* rudimentary byte seek */
3630 /* XXX: use MXF Index */
3631 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3632 {
3633     AVStream *st = s->streams[stream_index];
3634     int64_t seconds;
3635     MXFContext* mxf = s->priv_data;
3636     int64_t seekpos;
3637     int i, ret;
3638     MXFIndexTable *t;
3639     MXFTrack *source_track = st->priv_data;
3640
3641     if (!source_track)
3642         return 0;
3643
3644     /* if audio then truncate sample_time to EditRate */
3645     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
3646         sample_time = av_rescale_q(sample_time, st->time_base,
3647                                    av_inv_q(source_track->edit_rate));
3648
3649     if (mxf->nb_index_tables <= 0) {
3650         if (!s->bit_rate)
3651             return AVERROR_INVALIDDATA;
3652         if (sample_time < 0)
3653             sample_time = 0;
3654         seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3655
3656         seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3657         if (seekpos < 0)
3658             return seekpos;
3659
3660         ff_update_cur_dts(s, st, sample_time);
3661         mxf->current_klv_data = (KLVPacket){{0}};
3662     } else {
3663         MXFPartition *partition;
3664
3665         t = &mxf->index_tables[0];
3666         if (t->index_sid != source_track->index_sid) {
3667             /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
3668             for (i = 0; i < s->nb_streams; i++) {
3669                 MXFTrack *new_source_track = s->streams[i]->priv_data;
3670                 if (new_source_track && new_source_track->index_sid == t->index_sid) {
3671                     sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
3672                     source_track = new_source_track;
3673                     st = s->streams[i];
3674                     break;
3675                 }
3676             }
3677             if (i == s->nb_streams)
3678                 return AVERROR_INVALIDDATA;
3679         }
3680
3681         /* clamp above zero, else ff_index_search_timestamp() returns negative
3682          * this also means we allow seeking before the start */
3683         sample_time = FFMAX(sample_time, 0);
3684
3685         if (t->fake_index) {
3686             /* The first frames may not be keyframes in presentation order, so
3687              * we have to advance the target to be able to find the first
3688              * keyframe backwards... */
3689             if (!(flags & AVSEEK_FLAG_ANY) &&
3690                 (flags & AVSEEK_FLAG_BACKWARD) &&
3691                 t->ptses[0] != AV_NOPTS_VALUE &&
3692                 sample_time < t->ptses[0] &&
3693                 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3694                 sample_time = t->ptses[0];
3695
3696             /* behave as if we have a proper index */
3697             if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3698                 return sample_time;
3699             /* get the stored order index from the display order index */
3700             sample_time += t->offsets[sample_time];
3701         } else {
3702             /* no IndexEntryArray (one or more CBR segments)
3703              * make sure we don't seek past the end */
3704             sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3705         }
3706
3707         if (source_track->wrapping == UnknownWrapped)
3708             av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
3709
3710         if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
3711             return ret;
3712
3713         ff_update_cur_dts(s, st, sample_time);
3714         if (source_track->wrapping == ClipWrapped) {
3715             KLVPacket klv = partition->first_essence_klv;
3716             if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
3717                 av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
3718                 return AVERROR_INVALIDDATA;
3719             }
3720             mxf->current_klv_data = klv;
3721         } else {
3722             mxf->current_klv_data = (KLVPacket){{0}};
3723         }
3724         avio_seek(s->pb, seekpos, SEEK_SET);
3725     }
3726
3727     // Update all tracks sample count
3728     for (i = 0; i < s->nb_streams; i++) {
3729         AVStream *cur_st = s->streams[i];
3730         MXFTrack *cur_track = cur_st->priv_data;
3731         if (cur_track) {
3732             int64_t track_edit_unit = sample_time;
3733             if (st != cur_st)
3734                 mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
3735             cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
3736         }
3737     }
3738     return 0;
3739 }
3740
3741 static const AVOption options[] = {
3742     { "eia608_extract", "extract eia 608 captions from s436m track",
3743       offsetof(MXFContext, eia608_extract), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
3744       AV_OPT_FLAG_DECODING_PARAM },
3745     { NULL },
3746 };
3747
3748 static const AVClass demuxer_class = {
3749     .class_name = "mxf",
3750     .item_name  = av_default_item_name,
3751     .option     = options,
3752     .version    = LIBAVUTIL_VERSION_INT,
3753     .category   = AV_CLASS_CATEGORY_DEMUXER,
3754 };
3755
3756 AVInputFormat ff_mxf_demuxer = {
3757     .name           = "mxf",
3758     .long_name      = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3759     .flags          = AVFMT_SEEK_TO_PTS,
3760     .priv_data_size = sizeof(MXFContext),
3761     .read_probe     = mxf_probe,
3762     .read_header    = mxf_read_header,
3763     .read_packet    = mxf_read_packet,
3764     .read_close     = mxf_read_close,
3765     .read_seek      = mxf_read_seek,
3766     .priv_class     = &demuxer_class,
3767 };