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