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

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