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