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_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 this_partition;
 437
 438     a = -1;
 439     b = mxf->partitions_count;
 440
 441     while (b - a > 1) {
 442         m         = (a + b) >> 1;
 443         this_partition = mxf->partitions[m].this_partition;
 444         if (this_partition <= 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_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         klv.length != length - 20)
3143         goto end;
3144
3145     avio_skip(s->pb, klv.length - 12);
3146     mxf->footer_partition = avio_rb64(s->pb);
3147
3148     /* sanity check */
3149     if (mxf->run_in + mxf->footer_partition >= file_size) {
3150         av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3151         mxf->footer_partition = 0;
3152     }
3153
3154 end:
3155     avio_seek(s->pb, mxf->run_in, SEEK_SET);
3156 }
3157
3158 static int mxf_read_header(AVFormatContext *s)
3159 {
3160     MXFContext *mxf = s->priv_data;
3161     KLVPacket klv;
3162     int64_t essence_offset = 0;
3163     int ret;
3164
3165     mxf->last_forward_tell = INT64_MAX;
3166
3167     if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
3168         av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3169         return AVERROR_INVALIDDATA;
3170     }
3171     avio_seek(s->pb, -14, SEEK_CUR);
3172     mxf->fc = s;
3173     mxf->run_in = avio_tell(s->pb);
3174
3175     mxf_read_random_index_pack(s);
3176
3177     while (!avio_feof(s->pb)) {
3178         const MXFMetadataReadTableEntry *metadata;
3179
3180         if (klv_read_packet(&klv, s->pb) < 0) {
3181             /* EOF - seek to previous partition or stop */
3182             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3183                 break;
3184             else
3185                 continue;
3186         }
3187
3188         PRINT_KEY(s, "read header", klv.key);
3189         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3190         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
3191             IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3192             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3193             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
3194             IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
3195             IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
3196
3197             if (!mxf->current_partition) {
3198                 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3199                 return AVERROR_INVALIDDATA;
3200             }
3201
3202             if (!mxf->current_partition->first_essence_klv.offset)
3203                 mxf->current_partition->first_essence_klv = klv;
3204
3205             if (!essence_offset)
3206                 essence_offset = klv.offset;
3207
3208             /* seek to footer, previous partition or stop */
3209             if (mxf_parse_handle_essence(mxf) <= 0)
3210                 break;
3211             continue;
3212         } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3213             /* next partition pack - keep going, seek to previous partition or stop */
3214             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3215                 break;
3216             else if (mxf->parsing_backward)
3217                 continue;
3218             /* we're still parsing forward. proceed to parsing this partition pack */
3219         }
3220
3221         for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3222             if (IS_KLV_KEY(klv.key, metadata->key)) {
3223                 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3224                     goto fail;
3225                 break;
3226             }
3227         }
3228         if (!metadata->read) {
3229             av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3230                             UID_ARG(klv.key));
3231             avio_skip(s->pb, klv.length);
3232         }
3233     }
3234     /* FIXME avoid seek */
3235     if (!essence_offset)  {
3236         av_log(s, AV_LOG_ERROR, "no essence\n");
3237         ret = AVERROR_INVALIDDATA;
3238         goto fail;
3239     }
3240     avio_seek(s->pb, essence_offset, SEEK_SET);
3241
3242     /* we need to do this before computing the index tables
3243      * to be able to fill in zero IndexDurations with st->duration */
3244     if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3245         goto fail;
3246
3247     for (int i = 0; i < s->nb_streams; i++)
3248         mxf_handle_missing_index_segment(mxf, s->streams[i]);
3249
3250     if ((ret = mxf_compute_index_tables(mxf)) < 0)
3251         goto fail;
3252
3253     if (mxf->nb_index_tables > 1) {
3254         /* TODO: look up which IndexSID to use via EssenceContainerData */
3255         av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3256                mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3257     } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3258         av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3259         ret = AVERROR_INVALIDDATA;
3260         goto fail;
3261     }
3262
3263     mxf_compute_essence_containers(s);
3264
3265     for (int i = 0; i < s->nb_streams; i++)
3266         mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
3267
3268     return 0;
3269 fail:
3270     mxf_read_close(s);
3271
3272     return ret;
3273 }
3274
3275 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3276 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3277 {
3278     int64_t a, b, m, offset;
3279     MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3280
3281     if (!t || track->original_duration <= 0)
3282         return -1;
3283
3284     a = -1;
3285     b = track->original_duration;
3286
3287     while (b - a > 1) {
3288         m = (a + b) >> 1;
3289         if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3290             return -1;
3291         if (offset < current_offset)
3292             a = m;
3293         else
3294             b = m;
3295     }
3296
3297     *edit_unit_out = b;
3298
3299     return 0;
3300 }
3301
3302 static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st,
3303                                         int64_t edit_unit)
3304 {
3305     int i, total = 0, size = 0;
3306     MXFTrack *track = st->priv_data;
3307     AVRational time_base = av_inv_q(track->edit_rate);
3308     AVRational sample_rate = av_inv_q(st->time_base);
3309     const MXFSamplesPerFrame *spf = NULL;
3310     int64_t sample_count;
3311
3312     // For non-audio sample_count equals current edit unit
3313     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
3314         return edit_unit;
3315
3316     if ((sample_rate.num / sample_rate.den) == 48000)
3317         spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
3318     if (!spf) {
3319         int remainder = (sample_rate.num * time_base.num) %
3320                         (time_base.den * sample_rate.den);
3321         if (remainder)
3322             av_log(mxf->fc, AV_LOG_WARNING,
3323                    "seeking detected on stream #%d with time base (%d/%d) and "
3324                    "sample rate (%d/%d), audio pts won't be accurate.\n",
3325                    st->index, time_base.num, time_base.den,
3326                    sample_rate.num, sample_rate.den);
3327         return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3328     }
3329
3330     while (spf->samples_per_frame[size]) {
3331         total += spf->samples_per_frame[size];
3332         size++;
3333     }
3334
3335     av_assert2(size);
3336
3337     sample_count = (edit_unit / size) * (uint64_t)total;
3338     for (i = 0; i < edit_unit % size; i++) {
3339         sample_count += spf->samples_per_frame[i];
3340     }
3341
3342     return sample_count;
3343 }
3344
3345 /**
3346  * Make sure track->sample_count is correct based on what offset we're currently at.
3347  * Also determine the next edit unit (or packet) offset.
3348  * @return next_ofs if OK, <0 on error
3349  */
3350 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3351 {
3352     int64_t next_ofs = -1;
3353     MXFTrack *track = st->priv_data;
3354     int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3355     int64_t new_edit_unit;
3356     MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3357
3358     if (!t || track->wrapping == UnknownWrapped)
3359         return -1;
3360
3361     if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3362         (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3363         av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3364         return -1;
3365     }
3366
3367     /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3368     if (next_ofs > current_offset)
3369         return next_ofs;
3370
3371     if (!resync) {
3372         av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3373         return -1;
3374     }
3375
3376     if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3377         av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3378         return -1;
3379     }
3380
3381     new_edit_unit--;
3382     track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3383     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);
3384
3385     return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3386 }
3387
3388 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3389                              AVPacket *pkt)
3390 {
3391     AVStream *st = mxf->fc->streams[pkt->stream_index];
3392     MXFTrack *track = st->priv_data;
3393     int64_t bits_per_sample = par->bits_per_coded_sample;
3394
3395     if (!bits_per_sample)
3396         bits_per_sample = av_get_bits_per_sample(par->codec_id);
3397
3398     pkt->pts = track->sample_count;
3399
3400     if (   par->channels <= 0
3401         || bits_per_sample <= 0
3402         || par->channels * (int64_t)bits_per_sample < 8)
3403         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);
3404     else
3405         track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3406
3407     return 0;
3408 }
3409
3410 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3411 {
3412     AVCodecParameters *par = st->codecpar;
3413     MXFTrack *track = st->priv_data;
3414
3415     if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3416         /* see if we have an index table to derive timestamps from */
3417         MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3418
3419         if (t && track->sample_count < t->nb_ptses) {
3420             pkt->dts = track->sample_count + t->first_dts;
3421             pkt->pts = t->ptses[track->sample_count];
3422         } else if (track->intra_only) {
3423             /* intra-only -> PTS = EditUnit.
3424              * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3425             pkt->pts = track->sample_count;
3426         }
3427         track->sample_count++;
3428     } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3429         int ret = mxf_set_audio_pts(mxf, par, pkt);
3430         if (ret < 0)
3431             return ret;
3432     } else if (track) {
3433         pkt->dts = pkt->pts = track->sample_count;
3434         pkt->duration = 1;
3435         track->sample_count++;
3436     }
3437     return 0;
3438 }
3439
3440 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3441 {
3442     KLVPacket klv;
3443     MXFContext *mxf = s->priv_data;
3444     int ret;
3445
3446     while (1) {
3447         int64_t max_data_size;
3448         int64_t pos = avio_tell(s->pb);
3449
3450         if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3451             mxf->current_klv_data = (KLVPacket){{0}};
3452             ret = klv_read_packet(&klv, s->pb);
3453             if (ret < 0)
3454                 break;
3455             max_data_size = klv.length;
3456             pos = klv.next_klv - klv.length;
3457             PRINT_KEY(s, "read packet", klv.key);
3458             av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3459             if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3460                 ret = mxf_decrypt_triplet(s, pkt, &klv);
3461                 if (ret < 0) {
3462                     av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3463                     return ret;
3464                 }
3465                 return 0;
3466             }
3467         } else {
3468             klv = mxf->current_klv_data;
3469             max_data_size = klv.next_klv - pos;
3470         }
3471         if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3472             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3473             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3474             int body_sid = find_body_sid_by_offset(mxf, klv.offset);
3475             int index = mxf_get_stream_index(s, &klv, body_sid);
3476             int64_t next_ofs;
3477             AVStream *st;
3478             MXFTrack *track;
3479
3480             if (index < 0) {
3481                 av_log(s, AV_LOG_ERROR,
3482                        "error getting stream index %"PRIu32"\n",
3483                        AV_RB32(klv.key + 12));
3484                 goto skip;
3485             }
3486
3487             st = s->streams[index];
3488             track = st->priv_data;
3489
3490             if (s->streams[index]->discard == AVDISCARD_ALL)
3491                 goto skip;
3492
3493             next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
3494
3495             if (track->wrapping != FrameWrapped) {
3496                 int64_t size;
3497
3498                 if (next_ofs <= 0) {
3499                     // If we have no way to packetize the data, then return it in chunks...
3500                     if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
3501                         st->need_parsing = AVSTREAM_PARSE_FULL;
3502                         avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
3503                     }
3504                     size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
3505                 } else {
3506                     if ((size = next_ofs - pos) <= 0) {
3507                         av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
3508                         ret = AVERROR_INVALIDDATA;
3509                         goto skip;
3510                     }
3511                     // We must not overread, because the next edit unit might be in another KLV
3512                     if (size > max_data_size)
3513                         size = max_data_size;
3514                 }
3515
3516                 mxf->current_klv_data = klv;
3517                 klv.offset = pos;
3518                 klv.length = size;
3519                 klv.next_klv = klv.offset + klv.length;
3520             }
3521
3522             /* check for 8 channels AES3 element */
3523             if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3524                 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3525                                               pkt, klv.length);
3526                 if (ret < 0) {
3527                     av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3528                     mxf->current_klv_data = (KLVPacket){{0}};
3529                     return ret;
3530                 }
3531             } else if (mxf->eia608_extract &&
3532                        s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
3533                 ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
3534                 if (ret < 0) {
3535                     mxf->current_klv_data = (KLVPacket){{0}};
3536                     return ret;
3537                 }
3538             } else {
3539                 ret = av_get_packet(s->pb, pkt, klv.length);
3540                 if (ret < 0) {
3541                     mxf->current_klv_data = (KLVPacket){{0}};
3542                     return ret;
3543                 }
3544             }
3545             pkt->stream_index = index;
3546             pkt->pos = klv.offset;
3547
3548             ret = mxf_set_pts(mxf, st, pkt);
3549             if (ret < 0) {
3550                 mxf->current_klv_data = (KLVPacket){{0}};
3551                 return ret;
3552             }
3553
3554             /* seek for truncated packets */
3555             avio_seek(s->pb, klv.next_klv, SEEK_SET);
3556
3557             return 0;
3558         } else {
3559         skip:
3560             avio_skip(s->pb, max_data_size);
3561             mxf->current_klv_data = (KLVPacket){{0}};
3562         }
3563     }
3564     return avio_feof(s->pb) ? AVERROR_EOF : ret;
3565 }
3566
3567 static int mxf_read_close(AVFormatContext *s)
3568 {
3569     MXFContext *mxf = s->priv_data;
3570     int i;
3571
3572     av_freep(&mxf->packages_refs);
3573     av_freep(&mxf->essence_container_data_refs);
3574
3575     for (i = 0; i < s->nb_streams; i++)
3576         s->streams[i]->priv_data = NULL;
3577
3578     for (i = 0; i < mxf->metadata_sets_count; i++) {
3579         mxf_free_metadataset(mxf->metadata_sets + i, 1);
3580     }
3581     av_freep(&mxf->partitions);
3582     av_freep(&mxf->metadata_sets);
3583     av_freep(&mxf->aesc);
3584     av_freep(&mxf->local_tags);
3585
3586     if (mxf->index_tables) {
3587         for (i = 0; i < mxf->nb_index_tables; i++) {
3588             av_freep(&mxf->index_tables[i].segments);
3589             av_freep(&mxf->index_tables[i].ptses);
3590             av_freep(&mxf->index_tables[i].fake_index);
3591             av_freep(&mxf->index_tables[i].offsets);
3592         }
3593     }
3594     av_freep(&mxf->index_tables);
3595
3596     return 0;
3597 }
3598
3599 static int mxf_probe(const AVProbeData *p) {
3600     const uint8_t *bufp = p->buf;
3601     const uint8_t *end = p->buf + p->buf_size;
3602
3603     if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3604         return 0;
3605
3606     /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3607     end -= sizeof(mxf_header_partition_pack_key);
3608
3609     for (; bufp < end;) {
3610         if (!((bufp[13] - 1) & 0xF2)){
3611             if (AV_RN32(bufp   ) == AV_RN32(mxf_header_partition_pack_key   ) &&
3612                 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3613                 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3614                 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3615                 return AVPROBE_SCORE_MAX;
3616             bufp ++;
3617         } else
3618             bufp += 10;
3619     }
3620
3621     return 0;
3622 }
3623
3624 /* rudimentary byte seek */
3625 /* XXX: use MXF Index */
3626 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3627 {
3628     AVStream *st = s->streams[stream_index];
3629     int64_t seconds;
3630     MXFContext* mxf = s->priv_data;
3631     int64_t seekpos;
3632     int i, ret;
3633     MXFIndexTable *t;
3634     MXFTrack *source_track = st->priv_data;
3635
3636     if (!source_track)
3637         return 0;
3638
3639     /* if audio then truncate sample_time to EditRate */
3640     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
3641         sample_time = av_rescale_q(sample_time, st->time_base,
3642                                    av_inv_q(source_track->edit_rate));
3643
3644     if (mxf->nb_index_tables <= 0) {
3645         if (!s->bit_rate)
3646             return AVERROR_INVALIDDATA;
3647         if (sample_time < 0)
3648             sample_time = 0;
3649         seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3650
3651         seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3652         if (seekpos < 0)
3653             return seekpos;
3654
3655         ff_update_cur_dts(s, st, sample_time);
3656         mxf->current_klv_data = (KLVPacket){{0}};
3657     } else {
3658         MXFPartition *partition;
3659
3660         t = &mxf->index_tables[0];
3661         if (t->index_sid != source_track->index_sid) {
3662             /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
3663             for (i = 0; i < s->nb_streams; i++) {
3664                 MXFTrack *new_source_track = s->streams[i]->priv_data;
3665                 if (new_source_track && new_source_track->index_sid == t->index_sid) {
3666                     sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
3667                     source_track = new_source_track;
3668                     st = s->streams[i];
3669                     break;
3670                 }
3671             }
3672             if (i == s->nb_streams)
3673                 return AVERROR_INVALIDDATA;
3674         }
3675
3676         /* clamp above zero, else ff_index_search_timestamp() returns negative
3677          * this also means we allow seeking before the start */
3678         sample_time = FFMAX(sample_time, 0);
3679
3680         if (t->fake_index) {
3681             /* The first frames may not be keyframes in presentation order, so
3682              * we have to advance the target to be able to find the first
3683              * keyframe backwards... */
3684             if (!(flags & AVSEEK_FLAG_ANY) &&
3685                 (flags & AVSEEK_FLAG_BACKWARD) &&
3686                 t->ptses[0] != AV_NOPTS_VALUE &&
3687                 sample_time < t->ptses[0] &&
3688                 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3689                 sample_time = t->ptses[0];
3690
3691             /* behave as if we have a proper index */
3692             if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3693                 return sample_time;
3694             /* get the stored order index from the display order index */
3695             sample_time += t->offsets[sample_time];
3696         } else {
3697             /* no IndexEntryArray (one or more CBR segments)
3698              * make sure we don't seek past the end */
3699             sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3700         }
3701
3702         if (source_track->wrapping == UnknownWrapped)
3703             av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
3704
3705         if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
3706             return ret;
3707
3708         ff_update_cur_dts(s, st, sample_time);
3709         if (source_track->wrapping == ClipWrapped) {
3710             KLVPacket klv = partition->first_essence_klv;
3711             if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
3712                 av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
3713                 return AVERROR_INVALIDDATA;
3714             }
3715             mxf->current_klv_data = klv;
3716         } else {
3717             mxf->current_klv_data = (KLVPacket){{0}};
3718         }
3719         avio_seek(s->pb, seekpos, SEEK_SET);
3720     }
3721
3722     // Update all tracks sample count
3723     for (i = 0; i < s->nb_streams; i++) {
3724         AVStream *cur_st = s->streams[i];
3725         MXFTrack *cur_track = cur_st->priv_data;
3726         if (cur_track) {
3727             int64_t track_edit_unit = sample_time;
3728             if (st != cur_st)
3729                 mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
3730             cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
3731         }
3732     }
3733     return 0;
3734 }
3735
3736 static const AVOption options[] = {
3737     { "eia608_extract", "extract eia 608 captions from s436m track",
3738       offsetof(MXFContext, eia608_extract), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
3739       AV_OPT_FLAG_DECODING_PARAM },
3740     { NULL },
3741 };
3742
3743 static const AVClass demuxer_class = {
3744     .class_name = "mxf",
3745     .item_name  = av_default_item_name,
3746     .option     = options,
3747     .version    = LIBAVUTIL_VERSION_INT,
3748     .category   = AV_CLASS_CATEGORY_DEMUXER,
3749 };
3750
3751 AVInputFormat ff_mxf_demuxer = {
3752     .name           = "mxf",
3753     .long_name      = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3754     .flags          = AVFMT_SEEK_TO_PTS,
3755     .priv_data_size = sizeof(MXFContext),
3756     .read_probe     = mxf_probe,
3757     .read_header    = mxf_read_header,
3758     .read_packet    = mxf_read_packet,
3759     .read_close     = mxf_read_close,
3760     .read_seek      = mxf_read_seek,
3761     .priv_class     = &demuxer_class,
3762 };