PeerStreamer

/*

 * MXF muxer

 * Copyright (c) 2008 GUCAS, Zhentan Feng <spyfeng at gmail dot com>

 * Copyright (c) 2008 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>

 *

 * This file is part of Libav.

 *

 * Libav 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.

 *

 * Libav 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 Libav; 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 379M MXF Generic Container

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

 * SMPTE RP210: SMPTE Metadata Dictionary

 * SMPTE RP224: Registry of SMPTE Universal Labels

 */

//#define DEBUG

#include <math.h>

#include <time.h>

#include "libavutil/random_seed.h"

#include "libavcodec/bytestream.h"

#include "audiointerleave.h"

#include "avformat.h"

#include "mxf.h"

static const int NTSC_samples_per_frame[] = { 1602, 1601, 1602, 1601, 1602, 0 };

static const int PAL_samples_per_frame[]  = { 1920, 0 };

extern AVOutputFormat ff_mxf_d10_muxer;

#define EDIT_UNITS_PER_BODY 250

#define KAG_SIZE 512

typedef struct {

    int local_tag;

    UID uid;

} MXFLocalTagPair;

typedef struct {

    uint8_t flags;

    uint64_t offset;

    unsigned slice_offset; ///< offset of audio slice

    uint16_t temporal_ref;

} MXFIndexEntry;

typedef struct {

    AudioInterleaveContext aic;

    UID track_essence_element_key;

    int index;               ///< index in mxf_essence_container_uls table

    const UID *codec_ul;

    int order;               ///< interleaving order if dts are equal

    int interlaced;          ///< wether picture is interlaced

    int temporal_reordering;

    AVRational aspect_ratio; ///< display aspect ratio

    int closed_gop;          ///< gop is closed, used in mpeg-2 frame parsing

} MXFStreamContext;

typedef struct {

    UID container_ul;

    UID element_ul;

    UID codec_ul;

    void (*write_desc)(AVFormatContext *, AVStream *);

} MXFContainerEssenceEntry;

static const struct {

    enum CodecID id;

    int index;

} mxf_essence_mappings[] = {

    { CODEC_ID_MPEG2VIDEO, 0 },

    { CODEC_ID_PCM_S24LE,  1 },

    { CODEC_ID_PCM_S16LE,  1 },

    { CODEC_ID_NONE }

};

static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st);

static void mxf_write_aes3_desc(AVFormatContext *s, AVStream *st);

static void mxf_write_mpegvideo_desc(AVFormatContext *s, AVStream *st);

static void mxf_write_cdci_desc(AVFormatContext *s, AVStream *st);

static void mxf_write_generic_sound_desc(AVFormatContext *s, AVStream *st);

static const MXFContainerEssenceEntry mxf_essence_container_uls[] = {

    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x60,0x01 },

      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x15,0x01,0x05,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x00,0x00,0x00 },

      mxf_write_mpegvideo_desc },

    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x03,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x16,0x01,0x03,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },

      mxf_write_aes3_desc },

    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x01,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x16,0x01,0x01,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },

      mxf_write_wav_desc },

    // D-10 625/50 PAL 50mb/s

    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 },

      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x05,0x01,0x01,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x01 },

      mxf_write_cdci_desc },

    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 },

      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x06,0x01,0x10,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },

      mxf_write_generic_sound_desc },

    // D-10 525/60 NTSC 50mb/s

    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x02,0x01 },

      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x05,0x01,0x01,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x02 },

      mxf_write_cdci_desc },

    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x02,0x01 },

      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x06,0x01,0x10,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },

      mxf_write_generic_sound_desc },

    // D-10 625/50 PAL 40mb/s

    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x03,0x01 },

      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x05,0x01,0x01,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x03 },

      mxf_write_cdci_desc },

    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x03,0x01 },

      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x06,0x01,0x10,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },

      mxf_write_generic_sound_desc },

    // D-10 525/60 NTSC 40mb/s

    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x04,0x01 },

      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x05,0x01,0x01,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x04 },

      mxf_write_cdci_desc },

    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x04,0x01 },

      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x06,0x01,0x10,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },

      mxf_write_generic_sound_desc },

    // D-10 625/50 PAL 30mb/s

    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x05,0x01 },

      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x05,0x01,0x01,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x05 },

      mxf_write_cdci_desc },

    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x05,0x01 },

      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x06,0x01,0x10,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },

      mxf_write_generic_sound_desc },

    // D-10 525/60 NTSC 30mb/s

    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x06,0x01 },

      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x05,0x01,0x01,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x06 },

      mxf_write_cdci_desc },

    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x06,0x01 },

      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x06,0x01,0x10,0x00 },

      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },

      mxf_write_generic_sound_desc },

    { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },

      { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },

      { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },

      NULL },

};

typedef struct MXFContext {

    int64_t footer_partition_offset;

    int essence_container_count;

    AVRational time_base;

    int header_written;

    MXFIndexEntry *index_entries;

    unsigned edit_units_count;

    uint64_t timestamp;   ///< timestamp, as year(16),month(8),day(8),hour(8),minutes(8),msec/4(8)

    uint8_t slice_count;  ///< index slice count minus 1 (1 if no audio, 0 otherwise)

    int last_indexed_edit_unit;

    uint64_t *body_partition_offset;

    unsigned body_partitions_count;

    int last_key_index;  ///< index of last key frame

    uint64_t duration;

    AVStream *timecode_track;

    int timecode_base;       ///< rounded time code base (25 or 30)

    int timecode_start;      ///< frame number computed from mpeg-2 gop header timecode

    int timecode_drop_frame; ///< time code use drop frame method frop mpeg-2 essence gop header

    int edit_unit_byte_count; ///< fixed edit unit byte count

    uint64_t body_offset;

    uint32_t instance_number;

    uint8_t umid[16];        ///< unique material identifier

} MXFContext;

static const uint8_t uuid_base[]            = { 0xAD,0xAB,0x44,0x24,0x2f,0x25,0x4d,0xc7,0x92,0xff,0x29,0xbd };

static const uint8_t umid_ul[]              = { 0x06,0x0A,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x01,0x0D,0x00,0x13 };

/**

 * complete key for operation pattern, partitions, and primer pack

 */

static const uint8_t op1a_ul[]                     = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x01,0x09,0x00 };

static const uint8_t footer_partition_key[]        = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }; // ClosedComplete

static const uint8_t primer_pack_key[]             = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x05,0x01,0x00 };

static const uint8_t index_table_segment_key[]     = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 };

static const uint8_t random_index_pack_key[]       = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x11,0x01,0x00 };

static const uint8_t header_open_partition_key[]   = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }; // OpenIncomplete

static const uint8_t header_closed_partition_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }; // ClosedComplete

static const uint8_t klv_fill_key[]                = { 0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x03,0x01,0x02,0x10,0x01,0x00,0x00,0x00 };

static const uint8_t body_partition_key[]          = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }; // ClosedComplete

/**

 * partial key for header metadata

 */

static const uint8_t header_metadata_key[]  = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01 };

static const uint8_t multiple_desc_ul[]     = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x0D,0x01,0x03,0x01,0x02,0x7F,0x01,0x00 };

/**

 * SMPTE RP210 http://www.smpte-ra.org/mdd/index.html

 */

static const MXFLocalTagPair mxf_local_tag_batch[] = {

    // preface set

    { 0x3C0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x15,0x02,0x00,0x00,0x00,0x00}}, /* Instance UID */

    { 0x3B02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x04,0x00,0x00}}, /* Last Modified Date */

    { 0x3B05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x01,0x02,0x01,0x05,0x00,0x00,0x00}}, /* Version */

    { 0x3B06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x04,0x00,0x00}}, /* Identifications reference */

    { 0x3B03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x01,0x00,0x00}}, /* Content Storage reference */

    { 0x3B09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x03,0x00,0x00,0x00,0x00}}, /* Operational Pattern UL */

    { 0x3B0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x10,0x02,0x01,0x00,0x00}}, /* Essence Containers UL batch */

    { 0x3B0B, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x10,0x02,0x02,0x00,0x00}}, /* DM Schemes UL batch */

    // Identification

    { 0x3C09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x01,0x00,0x00,0x00}}, /* This Generation UID */

    { 0x3C01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x02,0x01,0x00,0x00}}, /* Company Name */

    { 0x3C02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x03,0x01,0x00,0x00}}, /* Product Name */

    { 0x3C04, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x05,0x01,0x00,0x00}}, /* Version String */

    { 0x3C05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x07,0x00,0x00,0x00}}, /* Product ID */

    { 0x3C06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x03,0x00,0x00}}, /* Modification Date */

    // Content Storage

    { 0x1901, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x05,0x01,0x00,0x00}}, /* Package strong reference batch */

    { 0x1902, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x05,0x02,0x00,0x00}}, /* Package strong reference batch */

    // Essence Container Data

    { 0x2701, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x06,0x01,0x00,0x00,0x00}}, /* Linked Package UID */

    { 0x3F07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x01,0x03,0x04,0x04,0x00,0x00,0x00,0x00}}, /* BodySID */

    // Package

    { 0x4401, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x15,0x10,0x00,0x00,0x00,0x00}}, /* Package UID */

    { 0x4405, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x01,0x03,0x00,0x00}}, /* Package Creation Date */

    { 0x4404, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x05,0x00,0x00}}, /* Package Modified Date */

    { 0x4403, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x05,0x00,0x00}}, /* Tracks Strong reference array */

    { 0x4701, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x03,0x00,0x00}}, /* Descriptor */

    // Track

    { 0x4801, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x01,0x07,0x01,0x01,0x00,0x00,0x00,0x00}}, /* Track ID */

    { 0x4804, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x01,0x04,0x01,0x03,0x00,0x00,0x00,0x00}}, /* Track Number */

    { 0x4B01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x30,0x04,0x05,0x00,0x00,0x00,0x00}}, /* Edit Rate */

    { 0x4B02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x03,0x01,0x03,0x00,0x00}}, /* Origin */

    { 0x4803, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x04,0x00,0x00}}, /* Sequence reference */

    // Sequence

    { 0x0201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x07,0x01,0x00,0x00,0x00,0x00,0x00}}, /* Data Definition UL */

    { 0x0202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x02,0x01,0x01,0x03,0x00,0x00}}, /* Duration */

    { 0x1001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x09,0x00,0x00}}, /* Structural Components reference array */

    // Source Clip

    { 0x1201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x03,0x01,0x04,0x00,0x00}}, /* Start position */

    { 0x1101, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x03,0x01,0x00,0x00,0x00}}, /* SourcePackageID */

    { 0x1102, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x03,0x02,0x00,0x00,0x00}}, /* SourceTrackID */

    // Timecode Component

    { 0x1501, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x03,0x01,0x05,0x00,0x00}}, /* Start Time Code */

    { 0x1502, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x04,0x01,0x01,0x02,0x06,0x00,0x00}}, /* Rounded Time Code Base */

    { 0x1503, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x04,0x01,0x01,0x05,0x00,0x00,0x00}}, /* Drop Frame */

    // File Descriptor

    { 0x3F01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x06,0x01,0x01,0x04,0x06,0x0B,0x00,0x00}}, /* Sub Descriptors reference array */

    { 0x3006, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x06,0x01,0x01,0x03,0x05,0x00,0x00,0x00}}, /* Linked Track ID */

    { 0x3001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x06,0x01,0x01,0x00,0x00,0x00,0x00}}, /* SampleRate */

    { 0x3004, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x01,0x02,0x00,0x00}}, /* Essence Container */

    // Generic Picture Essence Descriptor

    { 0x320C, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x03,0x01,0x04,0x00,0x00,0x00}}, /* Frame Layout */

    { 0x320D, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x03,0x02,0x05,0x00,0x00,0x00}}, /* Video Line Map */

    { 0x3203, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x02,0x02,0x00,0x00,0x00}}, /* Stored Width */

    { 0x3202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x02,0x01,0x00,0x00,0x00}}, /* Stored Height */

    { 0x3209, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0C,0x00,0x00,0x00}}, /* Display Width */

    { 0x3208, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0B,0x00,0x00,0x00}}, /* Display Height */

    { 0x320E, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x01,0x01,0x01,0x00,0x00,0x00}}, /* Aspect Ratio */

    { 0x3201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x06,0x01,0x00,0x00,0x00,0x00}}, /* Picture Essence Coding */

    // CDCI Picture Essence Descriptor

    { 0x3301, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x05,0x03,0x0A,0x00,0x00,0x00}}, /* Component Depth */

    { 0x3302, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x05,0x00,0x00,0x00}}, /* Horizontal Subsampling */

    // Generic Sound Essence Descriptor

    { 0x3D02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x02,0x03,0x01,0x04,0x00,0x00,0x00}}, /* Locked/Unlocked */

    { 0x3D03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x01,0x01,0x01,0x00,0x00}}, /* Audio sampling rate */

    { 0x3D07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x01,0x01,0x04,0x00,0x00,0x00}}, /* ChannelCount */

    { 0x3D01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x02,0x03,0x03,0x04,0x00,0x00,0x00}}, /* Quantization bits */

    { 0x3D06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x02,0x04,0x02,0x00,0x00,0x00,0x00}}, /* Sound Essence Compression */

    // Index Table Segment

    { 0x3F0B, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x05,0x30,0x04,0x06,0x00,0x00,0x00,0x00}}, /* Index Edit Rate */

    { 0x3F0C, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x07,0x02,0x01,0x03,0x01,0x0A,0x00,0x00}}, /* Index Start Position */

    { 0x3F0D, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x07,0x02,0x02,0x01,0x01,0x02,0x00,0x00}}, /* Index Duration */

    { 0x3F05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x06,0x02,0x01,0x00,0x00,0x00,0x00}}, /* Edit Unit Byte Count */

    { 0x3F06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x01,0x03,0x04,0x05,0x00,0x00,0x00,0x00}}, /* IndexSID */

    { 0x3F08, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x04,0x04,0x01,0x01,0x00,0x00,0x00}}, /* Slice Count */

    { 0x3F09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x04,0x04,0x01,0x06,0x00,0x00,0x00}}, /* Delta Entry Array */

    { 0x3F0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x04,0x04,0x02,0x05,0x00,0x00,0x00}}, /* Index Entry Array */

    // MPEG video Descriptor

    { 0x8000, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x0B,0x00,0x00}}, /* BitRate */

    { 0x8007, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x0A,0x00,0x00}}, /* ProfileAndLevel */

    // Wave Audio Essence Descriptor

    { 0x3D09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x03,0x05,0x00,0x00,0x00}}, /* Average Bytes Per Second */

    { 0x3D0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x02,0x01,0x00,0x00,0x00}}, /* Block Align */

};

static void mxf_write_uuid(AVIOContext *pb, enum MXFMetadataSetType type, int value)

{

    avio_write(pb, uuid_base, 12);

    avio_wb16(pb, type);

    avio_wb16(pb, value);

}

static void mxf_write_umid(AVFormatContext *s, int type)

{

    MXFContext *mxf = s->priv_data;

    avio_write(s->pb, umid_ul, 13);

    avio_wb24(s->pb, mxf->instance_number);

    avio_write(s->pb, mxf->umid, 15);

    avio_w8(s->pb, type);

}

static void mxf_write_refs_count(AVIOContext *pb, int ref_count)

{

    avio_wb32(pb, ref_count);

    avio_wb32(pb, 16);

}

static int klv_ber_length(uint64_t len)

{

    if (len < 128)

        return 1;

    else

        return (av_log2(len) >> 3) + 2;

}

static int klv_encode_ber_length(AVIOContext *pb, uint64_t len)

{

    // Determine the best BER size

    int size;

    if (len < 128) {

        //short form

        avio_w8(pb, len);

        return 1;

    }

    size = (av_log2(len) >> 3) + 1;

    // long form

    avio_w8(pb, 0x80 + size);

    while(size) {

        size--;

        avio_w8(pb, len >> 8 * size & 0xff);

    }

    return 0;

}

static void klv_encode_ber4_length(AVIOContext *pb, int len)

{

    avio_w8(pb, 0x80 + 3);

    avio_wb24(pb, len);

}

/*

 * Get essence container ul index

 */

static int mxf_get_essence_container_ul_index(enum CodecID id)

{

    int i;

    for (i = 0; mxf_essence_mappings[i].id; i++)

        if (mxf_essence_mappings[i].id == id)

            return mxf_essence_mappings[i].index;

    return -1;

}

static void mxf_write_primer_pack(AVFormatContext *s)

{

    AVIOContext *pb = s->pb;

    int local_tag_number, i = 0;

    local_tag_number = FF_ARRAY_ELEMS(mxf_local_tag_batch);

    avio_write(pb, primer_pack_key, 16);

    klv_encode_ber_length(pb, local_tag_number * 18 + 8);

    avio_wb32(pb, local_tag_number); // local_tag num

    avio_wb32(pb, 18); // item size, always 18 according to the specs

    for (i = 0; i < local_tag_number; i++) {

        avio_wb16(pb, mxf_local_tag_batch[i].local_tag);

        avio_write(pb, mxf_local_tag_batch[i].uid, 16);

    }

}

static void mxf_write_local_tag(AVIOContext *pb, int size, int tag)

{

    avio_wb16(pb, tag);

    avio_wb16(pb, size);

}

static void mxf_write_metadata_key(AVIOContext *pb, unsigned int value)

{

    avio_write(pb, header_metadata_key, 13);

    avio_wb24(pb, value);

}

static void mxf_free(AVFormatContext *s)

{

    int i;

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

        AVStream *st = s->streams[i];

        av_freep(&st->priv_data);

    }

}

static const MXFCodecUL *mxf_get_data_definition_ul(int type)

{

    const MXFCodecUL *uls = ff_mxf_data_definition_uls;

    while (uls->uid[0]) {

        if (type == uls->id)

            break;

        uls++;

    }

    return uls;

}

static void mxf_write_essence_container_refs(AVFormatContext *s)

{

    MXFContext *c = s->priv_data;

    AVIOContext *pb = s->pb;

    int i;

    mxf_write_refs_count(pb, c->essence_container_count);

    av_log(s,AV_LOG_DEBUG, "essence container count:%d\n", c->essence_container_count);

    for (i = 0; i < c->essence_container_count; i++) {

        MXFStreamContext *sc = s->streams[i]->priv_data;

        avio_write(pb, mxf_essence_container_uls[sc->index].container_ul, 16);

    }

}

static void mxf_write_preface(AVFormatContext *s)

{

    MXFContext *mxf = s->priv_data;

    AVIOContext *pb = s->pb;

    mxf_write_metadata_key(pb, 0x012f00);

    PRINT_KEY(s, "preface key", pb->buf_ptr - 16);

    klv_encode_ber_length(pb, 130 + 16 * mxf->essence_container_count);

    // write preface set uid

    mxf_write_local_tag(pb, 16, 0x3C0A);

    mxf_write_uuid(pb, Preface, 0);

    PRINT_KEY(s, "preface uid", pb->buf_ptr - 16);

    // last modified date

    mxf_write_local_tag(pb, 8, 0x3B02);

    avio_wb64(pb, mxf->timestamp);

    // write version

    mxf_write_local_tag(pb, 2, 0x3B05);

    avio_wb16(pb, 258); // v1.2

    // write identification_refs

    mxf_write_local_tag(pb, 16 + 8, 0x3B06);

    mxf_write_refs_count(pb, 1);

    mxf_write_uuid(pb, Identification, 0);

    // write content_storage_refs

    mxf_write_local_tag(pb, 16, 0x3B03);

    mxf_write_uuid(pb, ContentStorage, 0);

    // operational pattern

    mxf_write_local_tag(pb, 16, 0x3B09);

    avio_write(pb, op1a_ul, 16);

    // write essence_container_refs

    mxf_write_local_tag(pb, 8 + 16 * mxf->essence_container_count, 0x3B0A);

    mxf_write_essence_container_refs(s);

    // write dm_scheme_refs

    mxf_write_local_tag(pb, 8, 0x3B0B);

    avio_wb64(pb, 0);

}

/*

 * Write a local tag containing an ascii string as utf-16

 */

static void mxf_write_local_tag_utf16(AVIOContext *pb, int tag, const char *value)

{

    int i, size = strlen(value);

    mxf_write_local_tag(pb, size*2, tag);

    for (i = 0; i < size; i++)

        avio_wb16(pb, value[i]);

}

static void mxf_write_identification(AVFormatContext *s)

{

    MXFContext *mxf = s->priv_data;

    AVIOContext *pb = s->pb;

    const char *company = "FFmpeg";

    const char *product = "OP1a Muxer";

    const char *version;

    int length;

    mxf_write_metadata_key(pb, 0x013000);

    PRINT_KEY(s, "identification key", pb->buf_ptr - 16);

    version = s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT ?

        "0.0.0" : AV_STRINGIFY(LIBAVFORMAT_VERSION);

    length = 84 + (strlen(company)+strlen(product)+strlen(version))*2; // utf-16

    klv_encode_ber_length(pb, length);

    // write uid

    mxf_write_local_tag(pb, 16, 0x3C0A);

    mxf_write_uuid(pb, Identification, 0);

    PRINT_KEY(s, "identification uid", pb->buf_ptr - 16);

    // write generation uid

    mxf_write_local_tag(pb, 16, 0x3C09);

    mxf_write_uuid(pb, Identification, 1);

    mxf_write_local_tag_utf16(pb, 0x3C01, company); // Company Name

    mxf_write_local_tag_utf16(pb, 0x3C02, product); // Product Name

    mxf_write_local_tag_utf16(pb, 0x3C04, version); // Version String

    // write product uid

    mxf_write_local_tag(pb, 16, 0x3C05);

    mxf_write_uuid(pb, Identification, 2);

    // modification date

    mxf_write_local_tag(pb, 8, 0x3C06);

    avio_wb64(pb, mxf->timestamp);

}

static void mxf_write_content_storage(AVFormatContext *s)

{

    AVIOContext *pb = s->pb;

    mxf_write_metadata_key(pb, 0x011800);

    PRINT_KEY(s, "content storage key", pb->buf_ptr - 16);

    klv_encode_ber_length(pb, 92);

    // write uid

    mxf_write_local_tag(pb, 16, 0x3C0A);

    mxf_write_uuid(pb, ContentStorage, 0);

    PRINT_KEY(s, "content storage uid", pb->buf_ptr - 16);

    // write package reference

    mxf_write_local_tag(pb, 16 * 2 + 8, 0x1901);

    mxf_write_refs_count(pb, 2);

    mxf_write_uuid(pb, MaterialPackage, 0);

    mxf_write_uuid(pb, SourcePackage, 0);

    // write essence container data

    mxf_write_local_tag(pb, 8 + 16, 0x1902);

    mxf_write_refs_count(pb, 1);

    mxf_write_uuid(pb, EssenceContainerData, 0);

}

static void mxf_write_track(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)

{

    MXFContext *mxf = s->priv_data;

    AVIOContext *pb = s->pb;

    MXFStreamContext *sc = st->priv_data;

    mxf_write_metadata_key(pb, 0x013b00);

    PRINT_KEY(s, "track key", pb->buf_ptr - 16);

    klv_encode_ber_length(pb, 80);

    // write track uid

    mxf_write_local_tag(pb, 16, 0x3C0A);

    mxf_write_uuid(pb, type == MaterialPackage ? Track : Track + TypeBottom, st->index);

    PRINT_KEY(s, "track uid", pb->buf_ptr - 16);

    // write track id

    mxf_write_local_tag(pb, 4, 0x4801);

    avio_wb32(pb, st->index+2);

    // write track number

    mxf_write_local_tag(pb, 4, 0x4804);

    if (type == MaterialPackage)

        avio_wb32(pb, 0); // track number of material package is 0

    else

        avio_write(pb, sc->track_essence_element_key + 12, 4);

    mxf_write_local_tag(pb, 8, 0x4B01);

    avio_wb32(pb, mxf->time_base.den);

    avio_wb32(pb, mxf->time_base.num);

    // write origin

    mxf_write_local_tag(pb, 8, 0x4B02);

    avio_wb64(pb, 0);

    // write sequence refs

    mxf_write_local_tag(pb, 16, 0x4803);

    mxf_write_uuid(pb, type == MaterialPackage ? Sequence: Sequence + TypeBottom, st->index);

}

static const uint8_t smpte_12m_timecode_track_data_ul[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x01,0x03,0x02,0x01,0x01,0x00,0x00,0x00 };

static void mxf_write_common_fields(AVFormatContext *s, AVStream *st)

{

    MXFContext *mxf = s->priv_data;

    AVIOContext *pb = s->pb;

    // find data define uls

    mxf_write_local_tag(pb, 16, 0x0201);

    if (st == mxf->timecode_track)

        avio_write(pb, smpte_12m_timecode_track_data_ul, 16);

    else {

        const MXFCodecUL *data_def_ul = mxf_get_data_definition_ul(st->codec->codec_type);

        avio_write(pb, data_def_ul->uid, 16);

    }

    // write duration

    mxf_write_local_tag(pb, 8, 0x0202);

    avio_wb64(pb, mxf->duration);

}

static void mxf_write_sequence(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)

{

    MXFContext *mxf = s->priv_data;

    AVIOContext *pb = s->pb;

    enum MXFMetadataSetType component;

    mxf_write_metadata_key(pb, 0x010f00);

    PRINT_KEY(s, "sequence key", pb->buf_ptr - 16);

    klv_encode_ber_length(pb, 80);

    mxf_write_local_tag(pb, 16, 0x3C0A);

    mxf_write_uuid(pb, type == MaterialPackage ? Sequence: Sequence + TypeBottom, st->index);

    PRINT_KEY(s, "sequence uid", pb->buf_ptr - 16);

    mxf_write_common_fields(s, st);

    // write structural component

    mxf_write_local_tag(pb, 16 + 8, 0x1001);

    mxf_write_refs_count(pb, 1);

    if (st == mxf->timecode_track)

        component = TimecodeComponent;

    else

        component = SourceClip;

    if (type == SourcePackage)

        component += TypeBottom;

    mxf_write_uuid(pb, component, st->index);

}

static void mxf_write_timecode_component(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)

{

    MXFContext *mxf = s->priv_data;

    AVIOContext *pb = s->pb;

    mxf_write_metadata_key(pb, 0x011400);

    klv_encode_ber_length(pb, 75);

    // UID

    mxf_write_local_tag(pb, 16, 0x3C0A);

    mxf_write_uuid(pb, type == MaterialPackage ? TimecodeComponent :

                   TimecodeComponent + TypeBottom, st->index);

    mxf_write_common_fields(s, st);

    // Start Time Code

    mxf_write_local_tag(pb, 8, 0x1501);

    avio_wb64(pb, mxf->timecode_start);

    // Rounded Time Code Base

    mxf_write_local_tag(pb, 2, 0x1502);

    avio_wb16(pb, mxf->timecode_base);

    // Drop Frame

    mxf_write_local_tag(pb, 1, 0x1503);

    avio_w8(pb, mxf->timecode_drop_frame);

}

static void mxf_write_structural_component(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)

{

    AVIOContext *pb = s->pb;

    int i;

    mxf_write_metadata_key(pb, 0x011100);

    PRINT_KEY(s, "sturctural component key", pb->buf_ptr - 16);

    klv_encode_ber_length(pb, 108);

    // write uid

    mxf_write_local_tag(pb, 16, 0x3C0A);

    mxf_write_uuid(pb, type == MaterialPackage ? SourceClip: SourceClip + TypeBottom, st->index);