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