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