LCOV - code coverage report
Current view: top level - libavformat - mxfdec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1377 1745 78.9 %
Date: 2017-12-13 10:57:33 Functions: 77 79 97.5 %

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

Generated by: LCOV version 1.13