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     time.tm_year = (timestamp >> 48) - 1900;
2560     time.tm_mon  = (timestamp >> 40 & 0xFF) - 1;
2561     time.tm_mday = (timestamp >> 32 & 0xFF);
2562     time.tm_hour = (timestamp >> 24 & 0xFF);
2563     time.tm_min  = (timestamp >> 16 & 0xFF);
2564     time.tm_sec  = (timestamp >> 8  & 0xFF);
2565
2566     /* msvcrt versions of strftime calls the invalid parameter handler
2567      * (aborting the process if one isn't set) if the parameters are out
2568      * of range. */
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
2575     return (int64_t)av_timegm(&time) * 1000000;
2576 }
2577
2578 #define SET_STR_METADATA(pb, name, str) do { \
2579     if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2580         return ret; \
2581     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2582 } while (0)
2583
2584 #define SET_UID_METADATA(pb, name, var, str) do { \
2585     avio_read(pb, var, 16); \
2586     if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2587         return ret; \
2588     av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2589 } while (0)
2590
2591 #define SET_TS_METADATA(pb, name, var, str) do { \
2592     var = avio_rb64(pb); \
2593     if (var && (ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var))) < 0) \
2594         return ret; \
2595 } while (0)
2596
2597 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2598 {
2599     MXFContext *mxf = arg;
2600     AVFormatContext *s = mxf->fc;
2601     int ret;
2602     UID uid = { 0 };
2603     char *str = NULL;
2604     uint64_t ts;
2605     switch (tag) {
2606     case 0x3C01:
2607         SET_STR_METADATA(pb, "company_name", str);
2608         break;
2609     case 0x3C02:
2610         SET_STR_METADATA(pb, "product_name", str);
2611         break;
2612     case 0x3C04:
2613         SET_STR_METADATA(pb, "product_version", str);
2614         break;
2615     case 0x3C05:
2616         SET_UID_METADATA(pb, "product_uid", uid, str);
2617         break;
2618     case 0x3C06:
2619         SET_TS_METADATA(pb, "modification_date", ts, str);
2620         break;
2621     case 0x3C08:
2622         SET_STR_METADATA(pb, "application_platform", str);
2623         break;
2624     case 0x3C09:
2625         SET_UID_METADATA(pb, "generation_uid", uid, str);
2626         break;
2627     case 0x3C0A:
2628         SET_UID_METADATA(pb, "uid", uid, str);
2629         break;
2630     }
2631     return 0;
2632 }
2633
2634 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2635 {
2636     MXFContext *mxf = arg;
2637     AVFormatContext *s = mxf->fc;
2638     int ret;
2639     char *str = NULL;
2640
2641     if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2642         SET_STR_METADATA(pb, "project_name", str);
2643     }
2644     return 0;
2645 }
2646
2647 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2648     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2649     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2650     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2651     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2652     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2653     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2654     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2655     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2656     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2657     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2658     { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2659     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2660     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2661     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2662     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2663     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2664     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2665     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2666     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2667     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2668     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2669     { { 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 */
2670     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2671     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2672     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2673     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2674     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2675     { { 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 */
2676     { { 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 */
2677     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2678     { { 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 */
2679     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2680     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2681     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2682     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2683     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2684     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2685     { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
2686     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2687 };
2688
2689 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2690 {
2691     switch (type){
2692     case MultipleDescriptor:
2693     case Descriptor:
2694         ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2695         ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2696         break;
2697     default:
2698         break;
2699     }
2700     return 0;
2701 }
2702
2703 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2704 {
2705     AVIOContext *pb = mxf->fc->pb;
2706     MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2707     uint64_t klv_end = avio_tell(pb) + klv->length;
2708
2709     if (!ctx)
2710         return AVERROR(ENOMEM);
2711     mxf_metadataset_init(ctx, type);
2712     while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2713         int ret;
2714         int tag = avio_rb16(pb);
2715         int size = avio_rb16(pb); /* KLV specified by 0x53 */
2716         uint64_t next = avio_tell(pb) + size;
2717         UID uid = {0};
2718
2719         av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2720         if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2721             av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2722             continue;
2723         }
2724         if (tag > 0x7FFF) { /* dynamic tag */
2725             int i;
2726             for (i = 0; i < mxf->local_tags_count; i++) {
2727                 int local_tag = AV_RB16(mxf->local_tags+i*18);
2728                 if (local_tag == tag) {
2729                     memcpy(uid, mxf->local_tags+i*18+2, 16);
2730                     av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2731                     PRINT_KEY(mxf->fc, "uid", uid);
2732                 }
2733             }
2734         }
2735         if (ctx_size && tag == 0x3C0A) {
2736             avio_read(pb, ctx->uid, 16);
2737         } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2738             if (ctx_size)
2739                 mxf_free_metadataset(&ctx, 1);
2740             return ret;
2741         }
2742
2743         /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2744          * it extending past the end of the KLV though (zzuf5.mxf). */
2745         if (avio_tell(pb) > klv_end) {
2746             if (ctx_size) {
2747                 ctx->type = type;
2748                 mxf_free_metadataset(&ctx, 1);
2749             }
2750
2751             av_log(mxf->fc, AV_LOG_ERROR,
2752                    "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2753                    tag, klv->offset);
2754             return AVERROR_INVALIDDATA;
2755         } else if (avio_tell(pb) <= next)   /* only seek forward, else this can loop for a long time */
2756             avio_seek(pb, next, SEEK_SET);
2757     }
2758     if (ctx_size) ctx->type = type;
2759     return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2760 }
2761
2762 /**
2763  * Matches any partition pack key, in other words:
2764  * - HeaderPartition
2765  * - BodyPartition
2766  * - FooterPartition
2767  * @return non-zero if the key is a partition pack key, zero otherwise
2768  */
2769 static int mxf_is_partition_pack_key(UID key)
2770 {
2771     //NOTE: this is a little lax since it doesn't constraint key[14]
2772     return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2773             key[13] >= 2 && key[13] <= 4;
2774 }
2775
2776 /**
2777  * Parses a metadata KLV
2778  * @return <0 on error, 0 otherwise
2779  */
2780 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2781                                      int ctx_size, enum MXFMetadataSetType type)
2782 {
2783     AVFormatContext *s = mxf->fc;
2784     int res;
2785     if (klv.key[5] == 0x53) {
2786         res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2787     } else {
2788         uint64_t next = avio_tell(s->pb) + klv.length;
2789         res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2790
2791         /* only seek forward, else this can loop for a long time */
2792         if (avio_tell(s->pb) > next) {
2793             av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2794                    klv.offset);
2795             return AVERROR_INVALIDDATA;
2796         }
2797
2798         avio_seek(s->pb, next, SEEK_SET);
2799     }
2800     if (res < 0) {
2801         av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2802         return res;
2803     }
2804     return 0;
2805 }
2806
2807 /**
2808  * Seeks to the previous partition and parses it, if possible
2809  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2810  */
2811 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2812 {
2813     AVIOContext *pb = mxf->fc->pb;
2814     KLVPacket klv;
2815     int64_t current_partition_ofs;
2816     int ret;
2817
2818     if (!mxf->current_partition ||
2819         mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2820         return 0;   /* we've parsed all partitions */
2821
2822     /* seek to previous partition */
2823     current_partition_ofs = mxf->current_partition->pack_ofs;   //includes run-in
2824     avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2825     mxf->current_partition = NULL;
2826
2827     av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
2828
2829     /* Make sure this is actually a PartitionPack, and if so parse it.
2830      * See deadlock2.mxf
2831      */
2832     if ((ret = klv_read_packet(&klv, pb)) < 0) {
2833         av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2834         return ret;
2835     }
2836
2837     if (!mxf_is_partition_pack_key(klv.key)) {
2838         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2839         return AVERROR_INVALIDDATA;
2840     }
2841
2842     /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2843      * can point to just before the current partition, causing klv_read_packet()
2844      * to sync back up to it. See deadlock3.mxf
2845      */
2846     if (klv.offset >= current_partition_ofs) {
2847         av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2848                PRIx64 " indirectly points to itself\n", current_partition_ofs);
2849         return AVERROR_INVALIDDATA;
2850     }
2851
2852     if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2853         return ret;
2854
2855     return 1;
2856 }
2857
2858 /**
2859  * Called when essence is encountered
2860  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2861  */
2862 static int mxf_parse_handle_essence(MXFContext *mxf)
2863 {
2864     AVIOContext *pb = mxf->fc->pb;
2865     int64_t ret;
2866
2867     if (mxf->parsing_backward) {
2868         return mxf_seek_to_previous_partition(mxf);
2869     } else {
2870         if (!mxf->footer_partition) {
2871             av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
2872             return 0;
2873         }
2874
2875         av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
2876
2877         /* remember where we were so we don't end up seeking further back than this */
2878         mxf->last_forward_tell = avio_tell(pb);
2879
2880         if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2881             av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2882             return -1;
2883         }
2884
2885         /* seek to FooterPartition and parse backward */
2886         if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2887             av_log(mxf->fc, AV_LOG_ERROR,
2888                    "failed to seek to FooterPartition @ 0x%" PRIx64
2889                    " (%"PRId64") - partial file?\n",
2890                    mxf->run_in + mxf->footer_partition, ret);
2891             return ret;
2892         }
2893
2894         mxf->current_partition = NULL;
2895         mxf->parsing_backward = 1;
2896     }
2897
2898     return 1;
2899 }
2900
2901 /**
2902  * Called when the next partition or EOF is encountered
2903  * @return <= 0 if we should stop parsing, > 0 if we should keep going
2904  */
2905 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2906 {
2907     return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2908 }
2909
2910 static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
2911 {
2912     for (int i = 0; i < s->nb_streams; i++) {
2913         MXFTrack *track = s->streams[i]->priv_data;
2914         if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
2915             return track->wrapping;
2916     }
2917     return UnknownWrapped;
2918 }
2919
2920 /**
2921  * Figures out the proper offset and length of the essence container in each partition
2922  */
2923 static void mxf_compute_essence_containers(AVFormatContext *s)
2924 {
2925     MXFContext *mxf = s->priv_data;
2926     int x;
2927
2928     for (x = 0; x < mxf->partitions_count; x++) {
2929         MXFPartition *p = &mxf->partitions[x];
2930         MXFWrappingScheme wrapping;
2931
2932         if (!p->body_sid)
2933             continue;       /* BodySID == 0 -> no essence */
2934
2935         /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
2936          * otherwise we point essence_offset at the key of the first essence KLV.
2937          */
2938
2939         wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
2940
2941         if (wrapping == ClipWrapped) {
2942             p->essence_offset = p->first_essence_klv.next_klv - p->first_essence_klv.length;
2943             p->essence_length = p->first_essence_klv.length;
2944         } else {
2945             p->essence_offset = p->first_essence_klv.offset;
2946
2947             /* essence container spans to the next partition */
2948             if (x < mxf->partitions_count - 1)
2949                 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2950
2951             if (p->essence_length < 0) {
2952                 /* next ThisPartition < essence_offset */
2953                 p->essence_length = 0;
2954                 av_log(mxf->fc, AV_LOG_ERROR,
2955                        "partition %i: bad ThisPartition = %"PRIX64"\n",
2956                        x+1, mxf->partitions[x+1].this_partition);
2957             }
2958         }
2959     }
2960 }
2961
2962 static int is_pcm(enum AVCodecID codec_id)
2963 {
2964     /* we only care about "normal" PCM codecs until we get samples */
2965     return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2966 }
2967
2968 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
2969 {
2970     int i;
2971     for (i = 0; i < mxf->nb_index_tables; i++)
2972         if (mxf->index_tables[i].index_sid == index_sid)
2973             return &mxf->index_tables[i];
2974     return NULL;
2975 }
2976
2977 /**
2978  * Deal with the case where for some audio atoms EditUnitByteCount is
2979  * very small (2, 4..). In those cases we should read more than one
2980  * sample per call to mxf_read_packet().
2981  */
2982 static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
2983 {
2984     MXFTrack *track = st->priv_data;
2985     MXFIndexTable *t;
2986
2987     if (!track)
2988         return;
2989     track->edit_units_per_packet = 1;
2990     if (track->wrapping != ClipWrapped)
2991         return;
2992
2993     t = mxf_find_index_table(mxf, track->index_sid);
2994
2995     /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2996     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO         ||
2997         !is_pcm(st->codecpar->codec_id)                        ||
2998         !t                                                     ||
2999         t->nb_segments != 1                                    ||
3000         t->segments[0]->edit_unit_byte_count >= 32)
3001         return;
3002
3003     /* arbitrarily default to 48 kHz PAL audio frame size */
3004     /* TODO: We could compute this from the ratio between the audio
3005      *       and video edit rates for 48 kHz NTSC we could use the
3006      *       1802-1802-1802-1802-1801 pattern. */
3007     track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
3008 }
3009
3010 /**
3011  * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
3012  */
3013 static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
3014 {
3015     MXFTrack *track = st->priv_data;
3016     MXFIndexTableSegment *segment = NULL;
3017     MXFPartition *p = NULL;
3018     int essence_partition_count = 0;
3019     int edit_unit_byte_count = 0;
3020     int i, ret;
3021
3022     if (!track || track->wrapping != ClipWrapped)
3023         return 0;
3024
3025     /* check if track already has an IndexTableSegment */
3026     for (i = 0; i < mxf->metadata_sets_count; i++) {
3027         if (mxf->metadata_sets[i]->type == IndexTableSegment) {
3028             MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
3029             if (s->body_sid == track->body_sid)
3030                 return 0;
3031         }
3032     }
3033
3034     /* find the essence partition */
3035     for (i = 0; i < mxf->partitions_count; i++) {
3036         /* BodySID == 0 -> no essence */
3037         if (mxf->partitions[i].body_sid != track->body_sid)
3038             continue;
3039
3040         p = &mxf->partitions[i];
3041         essence_partition_count++;
3042     }
3043
3044     /* only handle files with a single essence partition */
3045     if (essence_partition_count != 1)
3046         return 0;
3047
3048     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && is_pcm(st->codecpar->codec_id)) {
3049         edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
3050     } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
3051         edit_unit_byte_count = p->first_essence_klv.length / st->duration;
3052     }
3053
3054     if (edit_unit_byte_count <= 0)
3055         return 0;
3056
3057     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);
3058
3059     if (!(segment = av_mallocz(sizeof(*segment))))
3060         return AVERROR(ENOMEM);
3061
3062     if ((ret = mxf_add_metadata_set(mxf, segment))) {
3063         mxf_free_metadataset((MXFMetadataSet**)&segment, 1);
3064         return ret;
3065     }
3066
3067     /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
3068      * using the same SID for index is forbidden in MXF. */
3069     if (!track->index_sid)
3070         track->index_sid = track->body_sid;
3071
3072     segment->type = IndexTableSegment;
3073     /* stream will be treated as small EditUnitByteCount */
3074     segment->edit_unit_byte_count = edit_unit_byte_count;
3075     segment->index_start_position = 0;
3076     segment->index_duration = st->duration;
3077     segment->index_edit_rate = av_inv_q(st->time_base);
3078     segment->index_sid = track->index_sid;
3079     segment->body_sid = p->body_sid;
3080     return 0;
3081 }
3082
3083 static void mxf_read_random_index_pack(AVFormatContext *s)
3084 {
3085     MXFContext *mxf = s->priv_data;
3086     uint32_t length;
3087     int64_t file_size, max_rip_length, min_rip_length;
3088     KLVPacket klv;
3089
3090     if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
3091         return;
3092
3093     file_size = avio_size(s->pb);
3094
3095     /* S377m says to check the RIP length for "silly" values, without defining "silly".
3096      * The limit below assumes a file with nothing but partition packs and a RIP.
3097      * Before changing this, consider that a muxer may place each sample in its own partition.
3098      *
3099      * 105 is the size of the smallest possible PartitionPack
3100      * 12 is the size of each RIP entry
3101      * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3102      */
3103     max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3104     max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3105
3106     /* We're only interested in RIPs with at least two entries.. */
3107     min_rip_length = 16+1+24+4;
3108
3109     /* See S377m section 11 */
3110     avio_seek(s->pb, file_size - 4, SEEK_SET);
3111     length = avio_rb32(s->pb);
3112
3113     if (length < min_rip_length || length > max_rip_length)
3114         goto end;
3115     avio_seek(s->pb, file_size - length, SEEK_SET);
3116     if (klv_read_packet(&klv, s->pb) < 0 ||
3117         !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
3118         klv.length != length - 20)
3119         goto end;
3120
3121     avio_skip(s->pb, klv.length - 12);
3122     mxf->footer_partition = avio_rb64(s->pb);
3123
3124     /* sanity check */
3125     if (mxf->run_in + mxf->footer_partition >= file_size) {
3126         av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3127         mxf->footer_partition = 0;
3128     }
3129
3130 end:
3131     avio_seek(s->pb, mxf->run_in, SEEK_SET);
3132 }
3133
3134 static int mxf_read_header(AVFormatContext *s)
3135 {
3136     MXFContext *mxf = s->priv_data;
3137     KLVPacket klv;
3138     int64_t essence_offset = 0;
3139     int ret;
3140
3141     mxf->last_forward_tell = INT64_MAX;
3142
3143     if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
3144         av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3145         return AVERROR_INVALIDDATA;
3146     }
3147     avio_seek(s->pb, -14, SEEK_CUR);
3148     mxf->fc = s;
3149     mxf->run_in = avio_tell(s->pb);
3150
3151     mxf_read_random_index_pack(s);
3152
3153     while (!avio_feof(s->pb)) {
3154         const MXFMetadataReadTableEntry *metadata;
3155
3156         if (klv_read_packet(&klv, s->pb) < 0) {
3157             /* EOF - seek to previous partition or stop */
3158             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3159                 break;
3160             else
3161                 continue;
3162         }
3163
3164         PRINT_KEY(s, "read header", klv.key);
3165         av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3166         if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
3167             IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3168             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3169             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
3170             IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
3171             IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
3172
3173             if (!mxf->current_partition) {
3174                 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3175                 return AVERROR_INVALIDDATA;
3176             }
3177
3178             if (!mxf->current_partition->first_essence_klv.offset)
3179                 mxf->current_partition->first_essence_klv = klv;
3180
3181             if (!essence_offset)
3182                 essence_offset = klv.offset;
3183
3184             /* seek to footer, previous partition or stop */
3185             if (mxf_parse_handle_essence(mxf) <= 0)
3186                 break;
3187             continue;
3188         } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3189             /* next partition pack - keep going, seek to previous partition or stop */
3190             if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3191                 break;
3192             else if (mxf->parsing_backward)
3193                 continue;
3194             /* we're still parsing forward. proceed to parsing this partition pack */
3195         }
3196
3197         for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3198             if (IS_KLV_KEY(klv.key, metadata->key)) {
3199                 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3200                     goto fail;
3201                 break;
3202             }
3203         }
3204         if (!metadata->read) {
3205             av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3206                             UID_ARG(klv.key));
3207             avio_skip(s->pb, klv.length);
3208         }
3209     }
3210     /* FIXME avoid seek */
3211     if (!essence_offset)  {
3212         av_log(s, AV_LOG_ERROR, "no essence\n");
3213         ret = AVERROR_INVALIDDATA;
3214         goto fail;
3215     }
3216     avio_seek(s->pb, essence_offset, SEEK_SET);
3217
3218     /* we need to do this before computing the index tables
3219      * to be able to fill in zero IndexDurations with st->duration */
3220     if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3221         goto fail;
3222
3223     for (int i = 0; i < s->nb_streams; i++)
3224         mxf_handle_missing_index_segment(mxf, s->streams[i]);
3225
3226     if ((ret = mxf_compute_index_tables(mxf)) < 0)
3227         goto fail;
3228
3229     if (mxf->nb_index_tables > 1) {
3230         /* TODO: look up which IndexSID to use via EssenceContainerData */
3231         av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3232                mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3233     } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3234         av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3235         ret = AVERROR_INVALIDDATA;
3236         goto fail;
3237     }
3238
3239     mxf_compute_essence_containers(s);
3240
3241     for (int i = 0; i < s->nb_streams; i++)
3242         mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
3243
3244     return 0;
3245 fail:
3246     mxf_read_close(s);
3247
3248     return ret;
3249 }
3250
3251 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3252 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3253 {
3254     int64_t a, b, m, offset;
3255     MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3256
3257     if (!t || track->original_duration <= 0)
3258         return -1;
3259
3260     a = -1;
3261     b = track->original_duration;
3262
3263     while (b - a > 1) {
3264         m = (a + b) >> 1;
3265         if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3266             return -1;
3267         if (offset < current_offset)
3268             a = m;
3269         else
3270             b = m;
3271     }
3272
3273     *edit_unit_out = b;
3274
3275     return 0;
3276 }
3277
3278 static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st,
3279                                         int64_t edit_unit)
3280 {
3281     int i, total = 0, size = 0;
3282     MXFTrack *track = st->priv_data;
3283     AVRational time_base = av_inv_q(track->edit_rate);
3284     AVRational sample_rate = av_inv_q(st->time_base);
3285     const MXFSamplesPerFrame *spf = NULL;
3286     int64_t sample_count;
3287
3288     // For non-audio sample_count equals current edit unit
3289     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
3290         return edit_unit;
3291
3292     if ((sample_rate.num / sample_rate.den) == 48000)
3293         spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
3294     if (!spf) {
3295         int remainder = (sample_rate.num * time_base.num) %
3296                         (time_base.den * sample_rate.den);
3297         if (remainder)
3298             av_log(mxf->fc, AV_LOG_WARNING,
3299                    "seeking detected on stream #%d with time base (%d/%d) and "
3300                    "sample rate (%d/%d), audio pts won't be accurate.\n",
3301                    st->index, time_base.num, time_base.den,
3302                    sample_rate.num, sample_rate.den);
3303         return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3304     }
3305
3306     while (spf->samples_per_frame[size]) {
3307         total += spf->samples_per_frame[size];
3308         size++;
3309     }
3310
3311     av_assert2(size);
3312
3313     sample_count = (edit_unit / size) * (uint64_t)total;
3314     for (i = 0; i < edit_unit % size; i++) {
3315         sample_count += spf->samples_per_frame[i];
3316     }
3317
3318     return sample_count;
3319 }
3320
3321 /**
3322  * Make sure track->sample_count is correct based on what offset we're currently at.
3323  * Also determine the next edit unit (or packet) offset.
3324  * @return next_ofs if OK, <0 on error
3325  */
3326 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3327 {
3328     int64_t next_ofs = -1;
3329     MXFTrack *track = st->priv_data;
3330     int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3331     int64_t new_edit_unit;
3332     MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3333
3334     if (!t || track->wrapping == UnknownWrapped)
3335         return -1;
3336
3337     if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3338         (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3339         av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3340         return -1;
3341     }
3342
3343     /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3344     if (next_ofs > current_offset)
3345         return next_ofs;
3346
3347     if (!resync) {
3348         av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3349         return -1;
3350     }
3351
3352     if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3353         av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3354         return -1;
3355     }
3356
3357     new_edit_unit--;
3358     track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3359     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);
3360
3361     return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3362 }
3363
3364 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3365                              AVPacket *pkt)
3366 {
3367     AVStream *st = mxf->fc->streams[pkt->stream_index];
3368     MXFTrack *track = st->priv_data;
3369     int64_t bits_per_sample = par->bits_per_coded_sample;
3370
3371     if (!bits_per_sample)
3372         bits_per_sample = av_get_bits_per_sample(par->codec_id);
3373
3374     pkt->pts = track->sample_count;
3375
3376     if (   par->channels <= 0
3377         || bits_per_sample <= 0
3378         || par->channels * (int64_t)bits_per_sample < 8)
3379         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);
3380     else
3381         track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3382
3383     return 0;
3384 }
3385
3386 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3387 {
3388     AVCodecParameters *par = st->codecpar;
3389     MXFTrack *track = st->priv_data;
3390
3391     if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3392         /* see if we have an index table to derive timestamps from */
3393         MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3394
3395         if (t && track->sample_count < t->nb_ptses) {
3396             pkt->dts = track->sample_count + t->first_dts;
3397             pkt->pts = t->ptses[track->sample_count];
3398         } else if (track->intra_only) {
3399             /* intra-only -> PTS = EditUnit.
3400              * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3401             pkt->pts = track->sample_count;
3402         }
3403         track->sample_count++;
3404     } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3405         int ret = mxf_set_audio_pts(mxf, par, pkt);
3406         if (ret < 0)
3407             return ret;
3408     } else if (track) {
3409         pkt->dts = pkt->pts = track->sample_count;
3410         pkt->duration = 1;
3411         track->sample_count++;
3412     }
3413     return 0;
3414 }
3415
3416 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3417 {
3418     KLVPacket klv;
3419     MXFContext *mxf = s->priv_data;
3420     int ret;
3421
3422     while (1) {
3423         int64_t max_data_size;
3424         int64_t pos = avio_tell(s->pb);
3425
3426         if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3427             mxf->current_klv_data = (KLVPacket){{0}};
3428             ret = klv_read_packet(&klv, s->pb);
3429             if (ret < 0)
3430                 break;
3431             max_data_size = klv.length;
3432             pos = klv.next_klv - klv.length;
3433             PRINT_KEY(s, "read packet", klv.key);
3434             av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3435             if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3436                 ret = mxf_decrypt_triplet(s, pkt, &klv);
3437                 if (ret < 0) {
3438                     av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3439                     return ret;
3440                 }
3441                 return 0;
3442             }
3443         } else {
3444             klv = mxf->current_klv_data;
3445             max_data_size = klv.next_klv - pos;
3446         }
3447         if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3448             IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3449             IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3450             int body_sid = find_body_sid_by_offset(mxf, klv.offset);
3451             int index = mxf_get_stream_index(s, &klv, body_sid);
3452             int64_t next_ofs;
3453             AVStream *st;
3454             MXFTrack *track;
3455
3456             if (index < 0) {
3457                 av_log(s, AV_LOG_ERROR,
3458                        "error getting stream index %"PRIu32"\n",
3459                        AV_RB32(klv.key + 12));
3460                 goto skip;
3461             }
3462
3463             st = s->streams[index];
3464             track = st->priv_data;
3465
3466             if (s->streams[index]->discard == AVDISCARD_ALL)
3467                 goto skip;
3468
3469             next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
3470
3471             if (track->wrapping != FrameWrapped) {
3472                 int64_t size;
3473
3474                 if (next_ofs <= 0) {
3475                     // If we have no way to packetize the data, then return it in chunks...
3476                     if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
3477                         st->need_parsing = AVSTREAM_PARSE_FULL;
3478                         avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
3479                     }
3480                     size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
3481                 } else {
3482                     if ((size = next_ofs - pos) <= 0) {
3483                         av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
3484                         ret = AVERROR_INVALIDDATA;
3485                         goto skip;
3486                     }
3487                     // We must not overread, because the next edit unit might be in another KLV
3488                     if (size > max_data_size)
3489                         size = max_data_size;
3490                 }
3491
3492                 mxf->current_klv_data = klv;
3493                 klv.offset = pos;
3494                 klv.length = size;
3495                 klv.next_klv = klv.offset + klv.length;
3496             }
3497
3498             /* check for 8 channels AES3 element */
3499             if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3500                 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3501                                               pkt, klv.length);
3502                 if (ret < 0) {
3503                     av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3504                     mxf->current_klv_data = (KLVPacket){{0}};
3505                     return ret;
3506                 }
3507             } else if (mxf->eia608_extract &&
3508                        s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
3509                 ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
3510                 if (ret < 0) {
3511                     mxf->current_klv_data = (KLVPacket){{0}};
3512                     return ret;
3513                 }
3514             } else {
3515                 ret = av_get_packet(s->pb, pkt, klv.length);
3516                 if (ret < 0) {
3517                     mxf->current_klv_data = (KLVPacket){{0}};
3518                     return ret;
3519                 }
3520             }
3521             pkt->stream_index = index;
3522             pkt->pos = klv.offset;
3523
3524             ret = mxf_set_pts(mxf, st, pkt);
3525             if (ret < 0) {
3526                 mxf->current_klv_data = (KLVPacket){{0}};
3527                 return ret;
3528             }
3529
3530             /* seek for truncated packets */
3531             avio_seek(s->pb, klv.next_klv, SEEK_SET);
3532
3533             return 0;
3534         } else {
3535         skip:
3536             avio_skip(s->pb, max_data_size);
3537             mxf->current_klv_data = (KLVPacket){{0}};
3538         }
3539     }
3540     return avio_feof(s->pb) ? AVERROR_EOF : ret;
3541 }
3542
3543 static int mxf_read_close(AVFormatContext *s)
3544 {
3545     MXFContext *mxf = s->priv_data;
3546     int i;
3547
3548     av_freep(&mxf->packages_refs);
3549     av_freep(&mxf->essence_container_data_refs);
3550
3551     for (i = 0; i < s->nb_streams; i++)
3552         s->streams[i]->priv_data = NULL;
3553
3554     for (i = 0; i < mxf->metadata_sets_count; i++) {
3555         mxf_free_metadataset(mxf->metadata_sets + i, 1);
3556     }
3557     av_freep(&mxf->partitions);
3558     av_freep(&mxf->metadata_sets);
3559     av_freep(&mxf->aesc);
3560     av_freep(&mxf->local_tags);
3561
3562     if (mxf->index_tables) {
3563         for (i = 0; i < mxf->nb_index_tables; i++) {
3564             av_freep(&mxf->index_tables[i].segments);
3565             av_freep(&mxf->index_tables[i].ptses);
3566             av_freep(&mxf->index_tables[i].fake_index);
3567             av_freep(&mxf->index_tables[i].offsets);
3568         }
3569     }
3570     av_freep(&mxf->index_tables);
3571
3572     return 0;
3573 }
3574
3575 static int mxf_probe(AVProbeData *p) {
3576     const uint8_t *bufp = p->buf;
3577     const uint8_t *end = p->buf + p->buf_size;
3578
3579     if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3580         return 0;
3581
3582     /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3583     end -= sizeof(mxf_header_partition_pack_key);
3584
3585     for (; bufp < end;) {
3586         if (!((bufp[13] - 1) & 0xF2)){
3587             if (AV_RN32(bufp   ) == AV_RN32(mxf_header_partition_pack_key   ) &&
3588                 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3589                 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3590                 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3591                 return AVPROBE_SCORE_MAX;
3592             bufp ++;
3593         } else
3594             bufp += 10;
3595     }
3596
3597     return 0;
3598 }
3599
3600 /* rudimentary byte seek */
3601 /* XXX: use MXF Index */
3602 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3603 {
3604     AVStream *st = s->streams[stream_index];
3605     int64_t seconds;
3606     MXFContext* mxf = s->priv_data;
3607     int64_t seekpos;
3608     int i, ret;
3609     MXFIndexTable *t;
3610     MXFTrack *source_track = st->priv_data;
3611
3612     if (!source_track)
3613         return 0;
3614
3615     /* if audio then truncate sample_time to EditRate */
3616     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
3617         sample_time = av_rescale_q(sample_time, st->time_base,
3618                                    av_inv_q(source_track->edit_rate));
3619
3620     if (mxf->nb_index_tables <= 0) {
3621         if (!s->bit_rate)
3622             return AVERROR_INVALIDDATA;
3623         if (sample_time < 0)
3624             sample_time = 0;
3625         seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3626
3627         seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3628         if (seekpos < 0)
3629             return seekpos;
3630
3631         ff_update_cur_dts(s, st, sample_time);
3632         mxf->current_klv_data = (KLVPacket){{0}};
3633     } else {
3634         MXFPartition *partition;
3635
3636         t = &mxf->index_tables[0];
3637         if (t->index_sid != source_track->index_sid) {
3638             /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
3639             for (i = 0; i < s->nb_streams; i++) {
3640                 MXFTrack *new_source_track = s->streams[i]->priv_data;
3641                 if (new_source_track && new_source_track->index_sid == t->index_sid) {
3642                     sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
3643                     source_track = new_source_track;
3644                     st = s->streams[i];
3645                     break;
3646                 }
3647             }
3648             if (i == s->nb_streams)
3649                 return AVERROR_INVALIDDATA;
3650         }
3651
3652         /* clamp above zero, else ff_index_search_timestamp() returns negative
3653          * this also means we allow seeking before the start */
3654         sample_time = FFMAX(sample_time, 0);
3655
3656         if (t->fake_index) {
3657             /* The first frames may not be keyframes in presentation order, so
3658              * we have to advance the target to be able to find the first
3659              * keyframe backwards... */
3660             if (!(flags & AVSEEK_FLAG_ANY) &&
3661                 (flags & AVSEEK_FLAG_BACKWARD) &&
3662                 t->ptses[0] != AV_NOPTS_VALUE &&
3663                 sample_time < t->ptses[0] &&
3664                 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3665                 sample_time = t->ptses[0];
3666
3667             /* behave as if we have a proper index */
3668             if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3669                 return sample_time;
3670             /* get the stored order index from the display order index */
3671             sample_time += t->offsets[sample_time];
3672         } else {
3673             /* no IndexEntryArray (one or more CBR segments)
3674              * make sure we don't seek past the end */
3675             sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3676         }
3677
3678         if (source_track->wrapping == UnknownWrapped)
3679             av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
3680
3681         if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
3682             return ret;
3683
3684         ff_update_cur_dts(s, st, sample_time);
3685         if (source_track->wrapping == ClipWrapped) {
3686             KLVPacket klv = partition->first_essence_klv;
3687             if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
3688                 av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
3689                 return AVERROR_INVALIDDATA;
3690             }
3691             mxf->current_klv_data = klv;
3692         } else {
3693             mxf->current_klv_data = (KLVPacket){{0}};
3694         }
3695         avio_seek(s->pb, seekpos, SEEK_SET);
3696     }
3697
3698     // Update all tracks sample count
3699     for (i = 0; i < s->nb_streams; i++) {
3700         AVStream *cur_st = s->streams[i];
3701         MXFTrack *cur_track = cur_st->priv_data;
3702         if (cur_track) {
3703             int64_t track_edit_unit = sample_time;
3704             if (st != cur_st)
3705                 mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
3706             cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
3707         }
3708     }
3709     return 0;
3710 }
3711
3712 static const AVOption options[] = {
3713     { "eia608_extract", "extract eia 608 captions from s436m track",
3714       offsetof(MXFContext, eia608_extract), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
3715       AV_OPT_FLAG_DECODING_PARAM },
3716     { NULL },
3717 };
3718
3719 static const AVClass demuxer_class = {
3720     .class_name = "mxf",
3721     .item_name  = av_default_item_name,
3722     .option     = options,
3723     .version    = LIBAVUTIL_VERSION_INT,
3724     .category   = AV_CLASS_CATEGORY_DEMUXER,
3725 };
3726
3727 AVInputFormat ff_mxf_demuxer = {
3728     .name           = "mxf",
3729     .long_name      = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3730     .flags          = AVFMT_SEEK_TO_PTS,
3731     .priv_data_size = sizeof(MXFContext),
3732     .read_probe     = mxf_probe,
3733     .read_header    = mxf_read_header,
3734     .read_packet    = mxf_read_packet,
3735     .read_close     = mxf_read_close,
3736     .read_seek      = mxf_read_seek,
3737     .priv_class     = &demuxer_class,
3738 };