/*

 * MXF demuxer.

 * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>

 *

 * This file is part of FFmpeg.

 *

 * FFmpeg is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * FFmpeg is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with FFmpeg; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 */

/*

 * References

 * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value

 * SMPTE 377M MXF File Format Specifications

 * SMPTE 378M Operational Pattern 1a

 * SMPTE 379M MXF Generic Container

 * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container

 * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container

 * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container

 * SMPTE 2067-21 Interoperable Master Format — Application #2E

 *

 * Principle

 * Search for Track numbers which will identify essence element KLV packets.

 * Search for SourcePackage which define tracks which contains Track numbers.

 * Material Package contains tracks with reference to SourcePackage tracks.

 * Search for Descriptors (Picture, Sound) which contains codec info and parameters.

 * Assign Descriptors to correct Tracks.

 *

 * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.

 * Metadata parsing resolves Strong References to objects.

 *

 * Simple demuxer, only OP1A supported and some files might not work at all.

 * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1

 */

#include <inttypes.h>

#include <time.h>

#include "libavutil/aes.h"

#include "libavutil/avstring.h"

#include "libavutil/mastering_display_metadata.h"

#include "libavutil/mathematics.h"

#include "libavutil/mem.h"

#include "libavcodec/bytestream.h"

#include "libavcodec/defs.h"

#include "libavcodec/internal.h"

#include "libavutil/channel_layout.h"

#include "libavutil/intreadwrite.h"

#include "libavutil/parseutils.h"

#include "libavutil/timecode.h"

#include "libavutil/opt.h"

#include "avformat.h"

#include "avlanguage.h"

#include "avio_internal.h"

#include "demux.h"

#include "internal.h"

#include "mxf.h"

#define MXF_MAX_CHUNK_SIZE (32 << 20)

#define RUN_IN_MAX (65535+1)  // S377m-2004 section 5.5 and S377-1-2009 section 6.5, the +1 is to be slightly more tolerant

typedef enum {

    Header,

    BodyPartition,

    Footer

} MXFPartitionType;

typedef enum {

    OP1a = 1,

    OP1b,

    OP1c,

    OP2a,

    OP2b,

    OP2c,

    OP3a,

    OP3b,

    OP3c,

    OPAtom,

    OPSONYOpt,  /* FATE sample, violates the spec in places */

} MXFOP;

typedef enum {

    UnknownWrapped = 0,

    FrameWrapped,

    ClipWrapped,

} MXFWrappingScheme;

typedef struct MXFPartition {

    int closed;

    int complete;

    MXFPartitionType type;

    uint64_t previous_partition;

    int index_sid;

    int body_sid;

    int64_t essence_offset;         ///< absolute offset of essence

    int64_t essence_length;

    int32_t kag_size;

    int64_t header_byte_count;

    int64_t index_byte_count;

    int pack_length;

    int64_t pack_ofs;               ///< absolute offset of pack in file, including run-in

    int64_t body_offset;

    KLVPacket first_essence_klv;

} MXFPartition;

typedef struct MXFMetadataSet {

    UID uid;

    uint64_t partition_score;

} MXFMetadataSet;

typedef struct MXFMetadataSetGroup {

    MXFMetadataSet **metadata_sets;

    int metadata_sets_count;

} MXFMetadataSetGroup;

typedef struct MXFCryptoContext {

    MXFMetadataSet meta;

    UID source_container_ul;

} MXFCryptoContext;

typedef struct MXFStructuralComponent {

    MXFMetadataSet meta;

    UID source_package_ul;

    UID source_package_uid;

    UID data_definition_ul;

    int64_t duration;

    int64_t start_position;

    int source_track_id;

} MXFStructuralComponent;

typedef struct MXFSequence {

    MXFMetadataSet meta;

    UID data_definition_ul;

    UID *structural_components_refs;

    int structural_components_count;

    int64_t duration;

} MXFSequence;

typedef struct MXFTimecodeComponent {

    MXFMetadataSet meta;

    int drop_frame;

    int start_frame;

    struct AVRational rate;

    AVTimecode tc;

} MXFTimecodeComponent;

typedef struct {

    MXFMetadataSet meta;

    UID input_segment_ref;

} MXFPulldownComponent;

typedef struct {

    MXFMetadataSet meta;

    UID *structural_components_refs;

    int structural_components_count;

    int64_t duration;

} MXFEssenceGroup;

typedef struct {

    MXFMetadataSet meta;

    char *name;

    char *value;

} MXFTaggedValue;

typedef struct {

    MXFMetadataSet meta;

    MXFSequence *sequence; /* mandatory, and only one */

    UID sequence_ref;

    int track_id;

    char *name;

    uint8_t track_number[4];

    AVRational edit_rate;

    int intra_only;

    uint64_t sample_count;

    int64_t original_duration; /* st->duration in SampleRate/EditRate units */

    int index_sid;

    int body_sid;

    MXFWrappingScheme wrapping;

    int edit_units_per_packet; /* how many edit units to read at a time (PCM, ClipWrapped) */

    int64_t origin;

} MXFTrack;

typedef struct MXFDescriptor {

    MXFMetadataSet meta;

    UID essence_container_ul;

    UID essence_codec_ul;

    UID codec_ul;

    AVRational sample_rate;

    AVRational aspect_ratio;

    int width;

    int height; /* Field height, not frame height */

    int frame_layout; /* See MXFFrameLayout enum */

    int video_line_map[2];

#define MXF_FIELD_DOMINANCE_DEFAULT 0

#define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */

#define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */

    int field_dominance;

    int channels;

    int bits_per_sample;

    int64_t duration; /* ContainerDuration optional property */

    unsigned int component_depth;

    unsigned int black_ref_level;

    unsigned int white_ref_level;

    unsigned int color_range;

    unsigned int horiz_subsampling;

    unsigned int vert_subsampling;

    UID *file_descriptors_refs;

    int file_descriptors_count;

    UID *sub_descriptors_refs;

    int sub_descriptors_count;

    int linked_track_id;

    uint8_t *extradata;

    int extradata_size;

    enum AVPixelFormat pix_fmt;

    UID color_primaries_ul;

    UID color_trc_ul;

    UID color_space_ul;

    AVMasteringDisplayMetadata *mastering;

    size_t mastering_size;

    AVContentLightMetadata *coll;

    size_t coll_size;

} MXFDescriptor;

typedef struct MXFMCASubDescriptor {

    MXFMetadataSet meta;

    UID uid;

    UID mca_link_id;

    UID soundfield_group_link_id;

    UID *group_of_soundfield_groups_link_id_refs;

    int group_of_soundfield_groups_link_id_count;

    UID mca_label_dictionary_id;

    int mca_channel_id;

    char *language;

} MXFMCASubDescriptor;

typedef struct MXFFFV1SubDescriptor {

    MXFMetadataSet meta;

    uint8_t *extradata;

    int extradata_size;

} MXFFFV1SubDescriptor;

typedef struct MXFIndexTableSegment {

    MXFMetadataSet meta;

    unsigned edit_unit_byte_count;

    int index_sid;

    int body_sid;

    AVRational index_edit_rate;

    uint64_t index_start_position;

    uint64_t index_duration;

    int8_t *temporal_offset_entries;

    int *flag_entries;

    uint64_t *stream_offset_entries;

    int nb_index_entries;

    int64_t offset;

} MXFIndexTableSegment;

typedef struct MXFPackage {

    MXFMetadataSet meta;

    UID package_uid;

    UID package_ul;

    UID *tracks_refs;

    int tracks_count;

    UID descriptor_ref;

    char *name;

    UID *comment_refs;

    int comment_count;

} MXFPackage;

typedef struct MXFEssenceContainerData {

    MXFMetadataSet meta;

    UID package_uid;

    UID package_ul;

    int index_sid;

    int body_sid;

} MXFEssenceContainerData;

/* decoded index table */

typedef struct MXFIndexTable {

    int index_sid;

    int body_sid;

    int nb_ptses;               /* number of PTSes or total duration of index */

    int64_t first_dts;          /* DTS = EditUnit + first_dts */

    int64_t *ptses;             /* maps EditUnit -> PTS */

    int nb_segments;

    MXFIndexTableSegment **segments;    /* sorted by IndexStartPosition */

    AVIndexEntry *fake_index;   /* used for calling ff_index_search_timestamp() */

    int8_t *offsets;            /* temporal offsets for display order to stored order conversion */

} MXFIndexTable;

typedef struct MXFContext {

    const AVClass *class;     /**< Class for private options. */

    MXFPartition *partitions;

    unsigned partitions_count;

    MXFOP op;

    UID *packages_refs;

    int packages_count;

    UID *essence_container_data_refs;

    int essence_container_data_count;

    MXFMetadataSetGroup metadata_set_groups[MetadataSetTypeNB];

    AVFormatContext *fc;

    struct AVAES *aesc;

    uint8_t *local_tags;

    int local_tags_count;

    uint64_t footer_partition;

    KLVPacket current_klv_data;

    int run_in;

    MXFPartition *current_partition;

    int parsing_backward;

    int64_t last_forward_tell;

    int last_forward_partition;

    int nb_index_tables;

    MXFIndexTable *index_tables;

    int eia608_extract;

} MXFContext;

/* NOTE: klv_offset is not set (-1) for local keys */

typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);

typedef struct MXFMetadataReadTableEntry {

    const UID key;

    MXFMetadataReadFunc *read; /* if NULL then skip KLV */

    int ctx_size;

    enum MXFMetadataSetType type;

} MXFMetadataReadTableEntry;

/* partial keys to match */

static const uint8_t mxf_header_partition_pack_key[]       = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };

static const uint8_t mxf_essence_element_key[]             = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };

static const uint8_t mxf_avid_essence_element_key[]        = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };

static const uint8_t mxf_canopus_essence_element_key[]     = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };

static const uint8_t mxf_system_item_key_cp[]              = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };

static const uint8_t mxf_system_item_key_gc[]              = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };

static const uint8_t mxf_klv_key[]                         = { 0x06,0x0e,0x2b,0x34 };

static const uint8_t mxf_apple_coll_prefix[]               = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01 };

/* complete keys to match */

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 };

static const uint8_t mxf_encrypted_triplet_key[]           = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };

static const uint8_t mxf_encrypted_essence_container[]     = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };

static const uint8_t mxf_sony_mpeg4_extradata[]            = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };

static const uint8_t mxf_ffv1_extradata[]                  = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x04,0x01,0x06,0x0c,0x01,0x00,0x00,0x00 }; // FFV1InitializationMetadata

static const uint8_t mxf_avid_project_name[]               = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };

static const uint8_t mxf_jp2k_rsiz[]                       = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x01,0x00,0x00,0x00 };

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 };

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 };

static const uint8_t mxf_apple_coll_max_cll[]              = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01,0x01 };

static const uint8_t mxf_apple_coll_max_fall[]             = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01,0x02 };

static const uint8_t mxf_mca_label_dictionary_id[]         = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x01,0x00,0x00,0x00 };

static const uint8_t mxf_mca_tag_symbol[]                  = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x02,0x00,0x00,0x00 };

static const uint8_t mxf_mca_tag_name[]                    = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x03,0x00,0x00,0x00 };

static const uint8_t mxf_group_of_soundfield_groups_link_id[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x04,0x00,0x00,0x00 };

static const uint8_t mxf_mca_link_id[]                     = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x05,0x00,0x00,0x00 };

static const uint8_t mxf_mca_channel_id[]                  = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x04,0x0a,0x00,0x00,0x00,0x00 };

static const uint8_t mxf_soundfield_group_link_id[]        = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x01,0x03,0x07,0x01,0x06,0x00,0x00,0x00 };

static const uint8_t mxf_mca_rfc5646_spoken_language[]     = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0d,0x03,0x01,0x01,0x02,0x03,0x15,0x00,0x00 };

static const uint8_t mxf_sub_descriptor[]                  = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x04,0x06,0x10,0x00,0x00 };

static const uint8_t mxf_mastering_display_prefix[13]      = { FF_MXF_MasteringDisplay_PREFIX };

static const uint8_t mxf_mastering_display_uls[4][16] = {

    FF_MXF_MasteringDisplayPrimaries,

    FF_MXF_MasteringDisplayWhitePointChromaticity,

    FF_MXF_MasteringDisplayMaximumLuminance,

    FF_MXF_MasteringDisplayMinimumLuminance,

};

#define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))

static void mxf_free_metadataset(MXFMetadataSet **ctx, enum MXFMetadataSetType type)

{

    MXFIndexTableSegment *seg;

    switch (type) {

    case Descriptor:

    case MultipleDescriptor:

        av_freep(&((MXFDescriptor *)*ctx)->extradata);

        av_freep(&((MXFDescriptor *)*ctx)->mastering);

        av_freep(&((MXFDescriptor *)*ctx)->coll);

        av_freep(&((MXFDescriptor *)*ctx)->file_descriptors_refs);

        av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);

        break;

    case FFV1SubDescriptor:

        av_freep(&((MXFFFV1SubDescriptor *)*ctx)->extradata);

        break;

    case AudioChannelLabelSubDescriptor:

    case SoundfieldGroupLabelSubDescriptor:

    case GroupOfSoundfieldGroupsLabelSubDescriptor:

        av_freep(&((MXFMCASubDescriptor *)*ctx)->language);

        av_freep(&((MXFMCASubDescriptor *)*ctx)->group_of_soundfield_groups_link_id_refs);

        break;

    case Sequence:

        av_freep(&((MXFSequence *)*ctx)->structural_components_refs);

        break;

    case EssenceGroup:

        av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);

        break;

    case SourcePackage:

    case MaterialPackage:

        av_freep(&((MXFPackage *)*ctx)->tracks_refs);

        av_freep(&((MXFPackage *)*ctx)->name);

        av_freep(&((MXFPackage *)*ctx)->comment_refs);

        break;

    case TaggedValue:

        av_freep(&((MXFTaggedValue *)*ctx)->name);

        av_freep(&((MXFTaggedValue *)*ctx)->value);

        break;

    case Track:

        av_freep(&((MXFTrack *)*ctx)->name);

        break;

    case IndexTableSegment:

        seg = (MXFIndexTableSegment *)*ctx;

        av_freep(&seg->temporal_offset_entries);

        av_freep(&seg->flag_entries);

        av_freep(&seg->stream_offset_entries);

    default:

        break;

    }

    av_freep(ctx);

}

static int64_t klv_decode_ber_length(AVIOContext *pb, int *llen)

{

    uint64_t size = avio_r8(pb);

    if (size & 0x80) { /* long form */

        int bytes_num = size & 0x7f;

        /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */

        if (bytes_num > 8)

            return AVERROR_INVALIDDATA;

        if (llen)

            *llen = bytes_num + 1;

        size = 0;

        while (bytes_num--)

            size = size << 8 | avio_r8(pb);

    } else if (llen) {

        *llen = 1;

    }

    if (size > INT64_MAX)

        return AVERROR_INVALIDDATA;

    return size;

}

static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)

{

    int i, b;

    for (i = 0; i < size && !avio_feof(pb); i++) {

        b = avio_r8(pb);

        if (b == key[0])

            i = 0;

        else if (b != key[i])

            i = -1;

    }

    return i == size;

}

// special case of mxf_read_sync for mxf_klv_key

static int mxf_read_sync_klv(AVIOContext *pb)

{

    uint32_t key = avio_rb32(pb);

    // key will never match mxf_klv_key on EOF

    if (key == AV_RB32(mxf_klv_key))

        return 1;

    while (!avio_feof(pb)) {

        key = (key << 8) | avio_r8(pb);

        if (key == AV_RB32(mxf_klv_key))

            return 1;

    }

    return 0;

}

static int klv_read_packet(MXFContext *mxf, KLVPacket *klv, AVIOContext *pb)

{

    int64_t length, pos;

    int llen;

    if (!mxf_read_sync_klv(pb))

        return AVERROR_INVALIDDATA;

    klv->offset = avio_tell(pb) - 4;

    if (klv->offset < mxf->run_in)

        return AVERROR_INVALIDDATA;

    memcpy(klv->key, mxf_klv_key, 4);

    int ret = ffio_read_size(pb, klv->key + 4, 12);

    if (ret < 0)

        return ret;

    length = klv_decode_ber_length(pb, &llen);

    if (length < 0)

        return length;

    klv->length = length;

    if (klv->offset > INT64_MAX - 16 - llen)

        return AVERROR_INVALIDDATA;

    pos = klv->offset + 16 + llen;

    if (pos > INT64_MAX - length)

        return AVERROR_INVALIDDATA;

    klv->next_klv = pos + length;

    return 0;

}

static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)

{

    for (int i = 0; i < s->nb_streams; i++) {

        MXFTrack *track = s->streams[i]->priv_data;

        /* SMPTE 379M 7.3 */

        if (track && (!body_sid || !track->body_sid || track->body_sid == body_sid) && !memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))

            return i;

    }

    /* return 0 if only one stream, for OP Atom files with 0 as track number */

    return s->nb_streams == 1 && s->streams[0]->priv_data ? 0 : -1;

}

static int find_body_sid_by_absolute_offset(MXFContext *mxf, int64_t offset)

{

    // we look for partition where the offset is placed

    int a, b, m;

    int64_t pack_ofs;

    a = -1;

    b = mxf->partitions_count;

    while (b - a > 1) {

        m = (a + b) >> 1;

        pack_ofs = mxf->partitions[m].pack_ofs;

        if (pack_ofs <= offset)

            a = m;

        else

            b = m;

    }

    if (a == -1)

        return 0;

    return mxf->partitions[a].body_sid;

}

static int mxf_get_eia608_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt, int64_t length)

{

    int count = avio_rb16(s->pb);

    int cdp_identifier, cdp_length, cdp_footer_id, ccdata_id, cc_count;

    int line_num, sample_coding, sample_count;

    int did, sdid, data_length;

    int ret;

    if (count > 1)

        av_log(s, AV_LOG_WARNING, "unsupported multiple ANC packets (%d) per KLV packet\n", count);

    for (int i = 0; i < count; i++) {

        if (length < 6) {

            av_log(s, AV_LOG_ERROR, "error reading s436m packet %"PRId64"\n", length);

            return AVERROR_INVALIDDATA;

        }

        line_num = avio_rb16(s->pb);

        avio_r8(s->pb); // wrapping type

        sample_coding = avio_r8(s->pb);

        sample_count = avio_rb16(s->pb);

        length -= 6 + 8 + sample_count;

        if (line_num != 9 && line_num != 11)

            continue;

        if (sample_coding == 7 || sample_coding == 8 || sample_coding == 9) {

            av_log(s, AV_LOG_WARNING, "unsupported s436m 10 bit sample coding\n");

            continue;

        }

        if (length < 0)

            return AVERROR_INVALIDDATA;

        avio_rb32(s->pb); // array count

        avio_rb32(s->pb); // array elem size

        did = avio_r8(s->pb);

        sdid = avio_r8(s->pb);

        data_length = avio_r8(s->pb);

        if (did != 0x61 || sdid != 1) {

            av_log(s, AV_LOG_WARNING, "unsupported did or sdid: %x %x\n", did, sdid);

            continue;

        }

        cdp_identifier = avio_rb16(s->pb); // cdp id

        if (cdp_identifier != 0x9669) {

            av_log(s, AV_LOG_ERROR, "wrong cdp identifier %x\n", cdp_identifier);

            return AVERROR_INVALIDDATA;

        }

        cdp_length = avio_r8(s->pb);

        avio_r8(s->pb); // cdp_frame_rate

        avio_r8(s->pb); // cdp_flags

        avio_rb16(s->pb); // cdp_hdr_sequence_cntr

        ccdata_id = avio_r8(s->pb); // ccdata_id

        if (ccdata_id != 0x72) {

            av_log(s, AV_LOG_ERROR, "wrong cdp data section %x\n", ccdata_id);

            return AVERROR_INVALIDDATA;

        }

        cc_count = avio_r8(s->pb) & 0x1f;

        ret = av_get_packet(s->pb, pkt, cc_count * 3);

        if (ret < 0)

            return ret;

        if (cdp_length - 9 - 4 <  cc_count * 3) {

            av_log(s, AV_LOG_ERROR, "wrong cdp size %d cc count %d\n", cdp_length, cc_count);

            return AVERROR_INVALIDDATA;

        }

        avio_skip(s->pb, data_length - 9 - 4 - cc_count * 3);

        cdp_footer_id = avio_r8(s->pb);

        if (cdp_footer_id != 0x74) {

            av_log(s, AV_LOG_ERROR, "wrong cdp footer section %x\n", cdp_footer_id);

            return AVERROR_INVALIDDATA;

        }

        avio_rb16(s->pb); // cdp_ftr_sequence_cntr

        avio_r8(s->pb); // packet_checksum

        break;

    }

    return 0;

}

/* XXX: use AVBitStreamFilter */

static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)

{

    const uint8_t *buf_ptr, *end_ptr;

    uint8_t *data_ptr;

    if (length > 61444) /* worst case PAL 1920 samples 8 channels */

        return AVERROR_INVALIDDATA;

    length = av_get_packet(pb, pkt, length);

    if (length < 0)

        return length;

    data_ptr = pkt->data;

    end_ptr = pkt->data + length;

    buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */

    if (st->codecpar->ch_layout.nb_channels > 8)

        return AVERROR_INVALIDDATA;

    for (; end_ptr - buf_ptr >= st->codecpar->ch_layout.nb_channels * 4; ) {

        for (int i = 0; i < st->codecpar->ch_layout.nb_channels; i++) {

            uint32_t sample = bytestream_get_le32(&buf_ptr);

            if (st->codecpar->bits_per_coded_sample == 24)

                bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);

            else

                bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);

        }

        // always 8 channels stored SMPTE 331M

        buf_ptr += 32 - st->codecpar->ch_layout.nb_channels * 4;

    }

    av_shrink_packet(pkt, data_ptr - pkt->data);

    return 0;

}

static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)

{

    static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};

    MXFContext *mxf = s->priv_data;

    AVIOContext *pb = s->pb;

    int64_t end = avio_tell(pb) + klv->length;

    int64_t size;

    uint64_t orig_size;

    uint64_t plaintext_size;

    uint8_t ivec[16];

    uint8_t tmpbuf[16];

    int ret;

    int index;

    int body_sid;

    if (!mxf->aesc && s->key && s->keylen == 16) {

        mxf->aesc = av_aes_alloc();

        if (!mxf->aesc)

            return AVERROR(ENOMEM);

        av_aes_init(mxf->aesc, s->key, 128, 1);

    }

    // crypto context

    size = klv_decode_ber_length(pb, NULL);

    if (size < 0)

        return size;

    avio_skip(pb, size);

    // plaintext offset

    klv_decode_ber_length(pb ,NULL);

    plaintext_size = avio_rb64(pb);

    // source klv key

    klv_decode_ber_length(pb, NULL);

    avio_read(pb, klv->key, 16);

    if (!IS_KLV_KEY(klv, mxf_essence_element_key))

        return AVERROR_INVALIDDATA;

    body_sid = find_body_sid_by_absolute_offset(mxf, klv->offset);

    index = mxf_get_stream_index(s, klv, body_sid);

    if (index < 0)

        return AVERROR_INVALIDDATA;

    // source size

    klv_decode_ber_length(pb, NULL);

    orig_size = avio_rb64(pb);

    if (orig_size < plaintext_size)

        return AVERROR_INVALIDDATA;

    // enc. code

    size = klv_decode_ber_length(pb, NULL);

    if (size < 32 || size - 32 < orig_size || (int)orig_size != orig_size)

        return AVERROR_INVALIDDATA;

    avio_read(pb, ivec, 16);

    ret = ffio_read_size(pb, tmpbuf, 16);

    if (ret < 16)

        return ret;

    if (mxf->aesc)

        av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);

    if (memcmp(tmpbuf, checkv, 16))

        av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");

    size -= 32;

    size = av_get_packet(pb, pkt, size);

    if (size < 0)

        return size;

    else if (size < plaintext_size)

        return AVERROR_INVALIDDATA;

    size -= plaintext_size;

    if (mxf->aesc)

        av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],

                     &pkt->data[plaintext_size], size >> 4, ivec, 1);

    av_shrink_packet(pkt, orig_size);

    pkt->stream_index = index;

    avio_skip(pb, end - avio_tell(pb));

    return 0;

}

static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)

{

    MXFContext *mxf = arg;

    int item_num = avio_rb32(pb);

    int item_len = avio_rb32(pb);

    if (item_len != 18) {

        avpriv_request_sample(pb, "Primer pack item length %d", item_len);

        return AVERROR_PATCHWELCOME;

    }

    if (item_num > 65536 || item_num < 0) {

        av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);

        return AVERROR_INVALIDDATA;

    }

    if (mxf->local_tags)

        av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");

    av_free(mxf->local_tags);

    mxf->local_tags_count = 0;

    mxf->local_tags = av_calloc(item_num, item_len);

    if (!mxf->local_tags)

        return AVERROR(ENOMEM);

    mxf->local_tags_count = item_num;

    avio_read(pb, mxf->local_tags, item_num*item_len);

    return 0;

}

static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)

{

    MXFContext *mxf = arg;

    AVFormatContext *s = mxf->fc;

    MXFPartition *partition, *tmp_part;

    UID op;

    uint64_t footer_partition;

    uint32_t nb_essence_containers;

    uint64_t this_partition;

    int ret;

    if (mxf->partitions_count >= INT_MAX / 2)

        return AVERROR_INVALIDDATA;

    av_assert0(klv_offset >= mxf->run_in);

    tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));

    if (!tmp_part)

        return AVERROR(ENOMEM);

    mxf->partitions = tmp_part;

    if (mxf->parsing_backward) {

        /* insert the new partition pack in the middle

         * this makes the entries in mxf->partitions sorted by offset */

        memmove(&mxf->partitions[mxf->last_forward_partition+1],

                &mxf->partitions[mxf->last_forward_partition],

                (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));

        partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];

    } else {

        mxf->last_forward_partition++;

        partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];

    }

    memset(partition, 0, sizeof(*partition));

    mxf->partitions_count++;

    partition->pack_length = avio_tell(pb) - klv_offset + size;

    partition->pack_ofs    = klv_offset;

    switch(uid[13]) {

    case 2:

        partition->type = Header;

        break;

    case 3:

        partition->type = BodyPartition;

        break;

    case 4:

        partition->type = Footer;

        break;

    default:

        av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);

        return AVERROR_INVALIDDATA;

    }

    /* consider both footers to be closed (there is only Footer and CompleteFooter) */

    partition->closed = partition->type == Footer || !(uid[14] & 1);

    partition->complete = uid[14] > 2;

    avio_skip(pb, 4);

    partition->kag_size = avio_rb32(pb);

    this_partition = avio_rb64(pb);

    if (this_partition != klv_offset - mxf->run_in) {

        av_log(mxf->fc, AV_LOG_ERROR,

               "this_partition %"PRId64" mismatches %"PRId64"\n",

               this_partition, klv_offset - mxf->run_in);

        return AVERROR_INVALIDDATA;

    }

    partition->previous_partition = avio_rb64(pb);

    footer_partition = avio_rb64(pb);

    partition->header_byte_count = avio_rb64(pb);

    partition->index_byte_count = avio_rb64(pb);

    partition->index_sid = avio_rb32(pb);

    partition->body_offset = avio_rb64(pb);

    partition->body_sid = avio_rb32(pb);

    if (partition->body_offset < 0)

        return AVERROR_INVALIDDATA;

    ret = ffio_read_size(pb, op, sizeof(UID));

    if (ret < 0) {

        av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");

        return ret;

    }

    nb_essence_containers = avio_rb32(pb);

    if (partition->type == Header) {

        char str[36];

        snprintf(str, sizeof(str), "%08x.%08x.%08x.%08x", AV_RB32(&op[0]), AV_RB32(&op[4]), AV_RB32(&op[8]), AV_RB32(&op[12]));

        av_dict_set(&s->metadata, "operational_pattern_ul", str, 0);

    }

    if (this_partition &&

        partition->previous_partition == this_partition) {

        av_log(mxf->fc, AV_LOG_ERROR,

               "PreviousPartition equal to ThisPartition %"PRIx64"\n",

               partition->previous_partition);

        /* override with the actual previous partition offset */

        if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {

            MXFPartition *prev =

                mxf->partitions + mxf->last_forward_partition - 2;

            partition->previous_partition = prev->pack_ofs - mxf->run_in;

        }

        /* if no previous body partition are found point to the header

         * partition */

        if (partition->previous_partition == this_partition)

            partition->previous_partition = 0;

        av_log(mxf->fc, AV_LOG_ERROR,

               "Overriding PreviousPartition with %"PRIx64"\n",

               partition->previous_partition);

    }

    /* some files don't have FooterPartition set in every partition */

    if (footer_partition) {

        if (mxf->footer_partition && mxf->footer_partition != footer_partition) {

            av_log(mxf->fc, AV_LOG_ERROR,

                   "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",

                   mxf->footer_partition, footer_partition);

        } else {

            mxf->footer_partition = footer_partition;

        }

    }

    av_log(mxf->fc, AV_LOG_TRACE,

            "PartitionPack: ThisPartition = 0x%"PRIX64

            ", PreviousPartition = 0x%"PRIX64", "

            "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",

            this_partition,

            partition->previous_partition, footer_partition,

            partition->index_sid, partition->body_sid);

    /* sanity check PreviousPartition if set */

    //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()

    if (partition->previous_partition &&

        mxf->run_in + partition->previous_partition >= klv_offset) {

        av_log(mxf->fc, AV_LOG_ERROR,

               "PreviousPartition points to this partition or forward\n");

        return AVERROR_INVALIDDATA;

    }

    if      (op[12] == 1 && op[13] == 1) mxf->op = OP1a;

    else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;

    else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;

    else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;

    else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;

    else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;

    else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;

    else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;

    else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;

    else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;

    else if (op[12] == 0x10) {

        /* SMPTE 390m: "There shall be exactly one essence container"

         * The following block deals with files that violate this, namely:

         * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a

         * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */

        if (nb_essence_containers != 1) {

            MXFOP mxfop = nb_essence_containers ? OP1a : OPAtom;

            /* only nag once */

            if (!mxf->op)

                av_log(mxf->fc, AV_LOG_WARNING,

                       "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",

                       nb_essence_containers,

                       mxfop == OP1a ? "OP1a" : "OPAtom");

            mxf->op = mxfop;

        } else

            mxf->op = OPAtom;

    } else {

        av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);

        mxf->op = OP1a;

    }

    if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {

        av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",

               partition->kag_size);

        if (mxf->op == OPSONYOpt)

            partition->kag_size = 512;

        else

            partition->kag_size = 1;

        av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);

    }

    return 0;

}

static uint64_t partition_score(MXFPartition *p)

{

    uint64_t score;

    if (!p)

        return 0;

    if (p->type == Footer)

        score = 5;

    else if (p->complete)

        score = 4;

    else if (p->closed)

        score = 3;

    else

        score = 1;

    return (score << 60) | ((uint64_t)p->pack_ofs >> 4);

}

static int mxf_add_metadata_set(MXFContext *mxf, MXFMetadataSet **metadata_set, enum MXFMetadataSetType type)

{

    MXFMetadataSetGroup *mg = &mxf->metadata_set_groups[type];

    int ret;

    // Index Table is special because it might be added manually without

    // partition and we iterate through all instances of them. Also some files

    // use the same Instance UID for different index tables...

    if (type != IndexTableSegment) {

        for (int i = 0; i < mg->metadata_sets_count; i++) {

            if (!memcmp((*metadata_set)->uid, mg->metadata_sets[i]->uid, 16)) {

                uint64_t old_s = mg->metadata_sets[i]->partition_score;

                uint64_t new_s = (*metadata_set)->partition_score;

                if (old_s > new_s) {

                     mxf_free_metadataset(metadata_set, type);

                     return 0;

                }

            }

        }

    }

    ret = av_dynarray_add_nofree(&mg->metadata_sets, &mg->metadata_sets_count, *metadata_set);

    if (ret < 0) {

        mxf_free_metadataset(metadata_set, type);

        return ret;

    }

    return 0;

}

static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)

{

    MXFCryptoContext *cryptocontext = arg;

    if (size != 16)

        return AVERROR_INVALIDDATA;

    if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))

        avio_read(pb, cryptocontext->source_container_ul, 16);

    return 0;

}

static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)

{

    int64_t ret;

    unsigned c = avio_rb32(pb);

    //avio_read() used int

    if (c > INT_MAX / sizeof(UID))

        return AVERROR_PATCHWELCOME;

    *count = c;

    av_free(*refs);

    *refs = av_malloc_array(*count, sizeof(UID));

    if (!*refs) {

        *count = 0;

        return AVERROR(ENOMEM);

    }

    avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */

    ret = avio_read(pb, (uint8_t *)*refs, *count * sizeof(UID));

    if (ret != *count * sizeof(UID)) {

        *count = ret < 0 ? 0   : ret / sizeof(UID);

        return   ret < 0 ? ret : AVERROR_INVALIDDATA;

    }

    return 0;

}

static inline int mxf_read_us_ascii_string(AVIOContext *pb, int size, char** str)

{

    int ret;

    size_t buf_size;

    if (size < 0 || size > INT_MAX - 1)

        return AVERROR(EINVAL);

    buf_size = size + 1;

    av_free(*str);

    *str = av_malloc(buf_size);

    if (!*str)

        return AVERROR(ENOMEM);

    ret = avio_get_str(pb, size, *str, buf_size);