git.sesse.net Git - ffmpeg/blob - libavformat/mxfdec.c

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