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