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

   1 /*
   2  * MXF muxer
   3  * Copyright (c) 2008 GUCAS, Zhentan Feng <spyfeng at gmail 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 379M MXF Generic Container
  27  * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
  28  * SMPTE RP210: SMPTE Metadata Dictionary
  29  * SMPTE RP224: Registry of SMPTE Universal Labels
  30  */
  31
  32 //#define DEBUG
  33
  34 #include "mxf.h"
  35
  36 typedef struct {
  37     int local_tag;
  38     UID uid;
  39 } MXFLocalTagPair;
  40
  41 typedef struct {
  42     UID track_essence_element_key;
  43     const UID *essence_container_ul;
  44 } MXFStreamContext;
  45
  46 typedef struct {
  47     UID container_ul;
  48     UID element_ul;
  49     enum CodecID id;
  50 } MXFContainerEssencePair;
  51
  52 static const MXFContainerEssencePair mxf_essence_container_uls[] = {
  53     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x60,0x01 },
  54       { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x15,0x01,0x05,0x00 }, CODEC_ID_MPEG2VIDEO },
  55     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x01,0x00 },
  56       { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x16,0x01,0x01,0x00 }, CODEC_ID_PCM_S16LE },
  57     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
  58       { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, CODEC_ID_NONE },
  59 };
  60
  61 typedef struct MXFContext {
  62     int64_t header_byte_count;
  63     int64_t header_byte_count_offset;
  64     int64_t header_footer_partition_offset;
  65     int essence_container_count;
  66     uint8_t essence_containers_indices[sizeof(mxf_essence_container_uls)/
  67                                        sizeof(*mxf_essence_container_uls)];
  68 } MXFContext;
  69
  70 typedef struct {
  71     const UID key;
  72     void (*write)();
  73     enum CodecType type;
  74 } MXFDescriptorWriteTableEntry;
  75
  76 static const uint8_t uuid_base[]            = { 0xAD,0xAB,0x44,0x24,0x2f,0x25,0x4d,0xc7,0x92,0xff,0x29,0xbd };
  77 static const uint8_t umid_base[]            = { 0x06,0x0A,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x0F,0x00,0x13,0x00,0x00,0x00 };
  78
  79 /**
  80  * complete key for operation pattern, partitions, and primer pack
  81  */
  82 static const uint8_t op1a_ul[]              = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x01,0x01,0x00 };
  83 static const uint8_t header_partition_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }; // ClosedComplete
  84 static const uint8_t footer_partition_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }; // ClosedComplete
  85 static const uint8_t primer_pack_key[]      = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x05,0x01,0x00 };
  86
  87 /**
  88  * partial key for header metadata
  89  */
  90 static const uint8_t header_metadata_key[]  = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01 };
  91
  92 static const uint8_t multiple_desc_ul[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x0D,0x01,0x03,0x01,0x02,0x7F,0x01,0x00 };
  93
  94 /**
  95  * SMPTE RP210 http://www.smpte-ra.org/mdd/index.html
  96  */
  97 static const MXFLocalTagPair mxf_local_tag_batch[] = {
  98     // preface set
  99     { 0x3C0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x15,0x02,0x00,0x00,0x00,0x00}}, /* Instance UID */
 100     { 0x3B02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x04,0x00,0x00}}, /* Last Modified Date */
 101     { 0x3B05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x01,0x02,0x01,0x05,0x00,0x00,0x00}}, /* Version */
 102     { 0x3B06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x04,0x00,0x00}}, /* Identifications reference */
 103     { 0x3B03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x01,0x00,0x00}}, /* Content Storage reference */
 104     { 0x3B09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x03,0x00,0x00,0x00,0x00}}, /* Operational Pattern UL */
 105     { 0x3B0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x10,0x02,0x01,0x00,0x00}}, /* Essence Containers UL batch */
 106     { 0x3B0B, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x10,0x02,0x02,0x00,0x00}}, /* DM Schemes UL batch */
 107     // Identification
 108     { 0x3C09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x01,0x00,0x00,0x00}}, /* This Generation UID */
 109     { 0x3C01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x02,0x01,0x00,0x00}}, /* Company Name */
 110     { 0x3C02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x03,0x01,0x00,0x00}}, /* Product Name */
 111     { 0x3C04, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x05,0x01,0x00,0x00}}, /* Version String */
 112     { 0x3C05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x07,0x00,0x00,0x00}}, /* Product ID */
 113     { 0x3C06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x03,0x00,0x00}}, /* Modification Date */
 114     // Content Storage
 115     { 0x1901, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x05,0x01,0x00,0x00}}, /* Package strong reference batch */
 116     // Essence Container Data
 117     { 0x2701, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x06,0x01,0x00,0x00,0x00}}, /* Linked Package UID */
 118     { 0x3F07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x01,0x03,0x04,0x04,0x00,0x00,0x00,0x00}}, /* BodySID */
 119     // Package
 120     { 0x4401, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x15,0x10,0x00,0x00,0x00,0x00}}, /* Package UID */
 121     { 0x4405, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x01,0x03,0x00,0x00}}, /* Package Creation Date */
 122     { 0x4404, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x05,0x00,0x00}}, /* Package Modified Date */
 123     { 0x4403, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x05,0x00,0x00}}, /* Tracks Strong reference array */
 124     { 0x4701, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x03,0x00,0x00}}, /* Descriptor */
 125     // Track
 126     { 0x4801, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x01,0x07,0x01,0x01,0x00,0x00,0x00,0x00}}, /* Track ID */
 127     { 0x4804, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x01,0x04,0x01,0x03,0x00,0x00,0x00,0x00}}, /* Track Number */
 128     { 0x4B01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x30,0x04,0x05,0x00,0x00,0x00,0x00}}, /* Edit Rate */
 129     { 0x4B02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x03,0x01,0x03,0x00,0x00}}, /* Origin */
 130     { 0x4803, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x04,0x00,0x00}}, /* Sequence reference */
 131     // Sequence
 132     { 0x0201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x07,0x01,0x00,0x00,0x00,0x00,0x00}}, /* Data Definition UL */
 133     { 0x0202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x02,0x01,0x01,0x03,0x00,0x00}}, /* Duration */
 134     { 0x1001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x09,0x00,0x00}}, /* Structural Components reference array */
 135     // Source Clip
 136     { 0x1201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x07,0x02,0x01,0x03,0x01,0x0A,0x00,0x00}}, /* Start position */
 137     { 0x1101, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x03,0x01,0x00,0x00,0x00}}, /* SourcePackageID */
 138     { 0x1102, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x03,0x02,0x00,0x00,0x00}}, /* SourceTrackID */
 139     // File Descriptor
 140     { 0x3F01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x06,0x01,0x01,0x04,0x06,0x0B,0x00,0x00}}, /* Sub Descriptors reference array */
 141     { 0x3006, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x06,0x01,0x01,0x03,0x05,0x00,0x00,0x00}}, /* Linked Track ID */
 142     { 0x3001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x06,0x01,0x01,0x00,0x00,0x00,0x00}}, /* SampleRate */
 143     { 0x3004, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x01,0x02,0x00,0x00}}, /* Essence Container */
 144     // Generic Picture Essence Descriptor
 145     { 0x3203, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x02,0x02,0x00,0x00,0x00}}, /* Stored Width */
 146     { 0x3202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x02,0x01,0x00,0x00,0x00}}, /* Stored Height */
 147     { 0x320E, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x01,0x01,0x01,0x00,0x00,0x00}}, /* Aspect Ratio */
 148     { 0x3201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x06,0x01,0x00,0x00,0x00,0x00}}, /* Picture Essence Coding */
 149     // Generic Sound Essence Descriptor
 150     { 0x3D03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x01,0x01,0x01,0x00,0x00}}, /* Audio sampling rate */
 151     { 0x3D07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x01,0x01,0x04,0x00,0x00,0x00}}, /* ChannelCount */
 152     { 0x3D01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x02,0x03,0x03,0x04,0x00,0x00,0x00}}, /* Quantization bits */
 153     { 0x3D06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x06,0x01,0x00,0x00,0x00,0x00}}, /* Sound Essence Compression */
 154 };
 155
 156 static void mxf_write_uuid(ByteIOContext *pb, enum CodecID type, int value)
 157 {
 158     put_buffer(pb, uuid_base, 12);
 159     put_be16(pb, type);
 160     put_be16(pb, value);
 161 }
 162
 163 static void mxf_write_umid(ByteIOContext *pb, enum CodecID type, int value)
 164 {
 165     put_buffer(pb, umid_base, 16);
 166     mxf_write_uuid(pb, type, value);
 167 }
 168
 169 static void mxf_write_refs_count(ByteIOContext *pb, int ref_count)
 170 {
 171     put_be32(pb, ref_count);
 172     put_be32(pb, 16);
 173 }
 174
 175 static int klv_encode_ber_length(ByteIOContext *pb, uint64_t len)
 176 {
 177     // Determine the best BER size
 178     int size;
 179     if (len < 128) {
 180         //short form
 181         put_byte(pb, len);
 182         return 1;
 183     }
 184
 185     size = (av_log2(len) >> 3) + 1;
 186
 187     // long form
 188     put_byte(pb, 0x80 + size);
 189     while(size) {
 190         size --;
 191         put_byte(pb, len >> 8 * size & 0xff);
 192     }
 193     return 0;
 194 }
 195
 196 /*
 197  * Get essence container ul and return its index position
 198  */
 199 static const UID *mxf_get_essence_container_ul(enum CodecID type, int *index)
 200 {
 201     const MXFContainerEssencePair *uls = mxf_essence_container_uls;
 202     for (*index = 0; *index < sizeof(mxf_essence_container_uls)/
 203                               sizeof(*mxf_essence_container_uls); (*index)++)
 204         if (mxf_essence_container_uls[*index].id == type)
 205             return &uls->container_ul;
 206     *index = -1;
 207     return NULL;
 208 }
 209
 210 static void mxf_write_primer_pack(AVFormatContext *s)
 211 {
 212     ByteIOContext *pb = s->pb;
 213     int local_tag_number, i = 0;
 214
 215     local_tag_number = sizeof(mxf_local_tag_batch)/sizeof(*mxf_local_tag_batch);
 216
 217     put_buffer(pb, primer_pack_key, 16);
 218     klv_encode_ber_length(pb, local_tag_number * 18 + 8);
 219
 220     put_be32(pb, local_tag_number); // local_tag num
 221     put_be32(pb, 18); // item size, always 18 according to the specs
 222
 223     for (i = 0; i < local_tag_number; i++) {
 224         put_be16(pb, mxf_local_tag_batch[i].local_tag);
 225         put_buffer(pb, mxf_local_tag_batch[i].uid, 16);
 226     }
 227 }
 228
 229 static void mxf_write_local_tag(ByteIOContext *pb, int size, int tag)
 230 {
 231     put_be16(pb, tag);
 232     put_be16(pb, size);
 233 }
 234
 235 static void mxf_write_metadata_key(ByteIOContext *pb, unsigned int value)
 236 {
 237     put_buffer(pb, header_metadata_key, 13);
 238     put_be24(pb, value);
 239 }
 240
 241 static void mxf_free(AVFormatContext *s)
 242 {
 243     int i;
 244
 245     for (i = 0; i < s->nb_streams; i++) {
 246         AVStream *st = s->streams[i];
 247         av_freep(&st->priv_data);
 248     }
 249 }
 250
 251 static const MXFDataDefinitionUL *mxf_get_data_definition_ul(enum CodecType type)
 252 {
 253     const MXFDataDefinitionUL *uls = ff_mxf_data_definition_uls;
 254     while (uls->type != CODEC_TYPE_DATA) {
 255         if (type == uls->type)
 256             break;
 257         uls++;
 258     }
 259     return uls;
 260 }
 261
 262 static void mxf_write_essence_container_refs(AVFormatContext *s)
 263 {
 264     MXFContext *c = s->priv_data;
 265     ByteIOContext *pb = s->pb;
 266     int i;
 267
 268     mxf_write_refs_count(pb, c->essence_container_count);
 269     av_log(s,AV_LOG_DEBUG, "essence container count:%d\n", c->essence_container_count);
 270     for (i = 0; i < c->essence_container_count; i++) {
 271         put_buffer(pb, mxf_essence_container_uls[c->essence_containers_indices[i]].container_ul, 16);
 272         PRINT_KEY(s, "essence container ul:\n", mxf_essence_container_uls[c->essence_containers_indices[i]].container_ul);
 273     }
 274 }
 275
 276 static void mxf_write_preface(AVFormatContext *s)
 277 {
 278     MXFContext *mxf = s->priv_data;
 279     ByteIOContext *pb = s->pb;
 280
 281     mxf_write_metadata_key(pb, 0x012f00);
 282     PRINT_KEY(s, "preface key", pb->buf_ptr - 16);
 283     klv_encode_ber_length(pb, 130 + 16 * mxf->essence_container_count);
 284
 285     // write preface set uid
 286     mxf_write_local_tag(pb, 16, 0x3C0A);
 287     mxf_write_uuid(pb, Preface, 0);
 288     PRINT_KEY(s, "preface uid", pb->buf_ptr - 16);
 289
 290     // write create date as unknown
 291     mxf_write_local_tag(pb, 8, 0x3B02);
 292     put_be64(pb, 0);
 293
 294     // write version
 295     mxf_write_local_tag(pb, 2, 0x3B05);
 296     put_be16(pb, 1);
 297
 298     // write identification_refs
 299     mxf_write_local_tag(pb, 16 + 8, 0x3B06);
 300     mxf_write_refs_count(pb, 1);
 301     mxf_write_uuid(pb, Identification, 0);
 302
 303     // write content_storage_refs
 304     mxf_write_local_tag(pb, 16, 0x3B03);
 305     mxf_write_uuid(pb, ContentStorage, 0);
 306
 307     mxf_write_local_tag(pb, 16, 0x3B09);
 308     put_buffer(pb, op1a_ul, 16);
 309
 310     // write essence_container_refs
 311     mxf_write_local_tag(pb, 8 + 16 * mxf->essence_container_count, 0x3B0A);
 312     mxf_write_essence_container_refs(s);
 313
 314     // write dm_scheme_refs
 315     mxf_write_local_tag(pb, 8, 0x3B0B);
 316     put_be64(pb, 0);
 317 }
 318
 319 /*
 320  * Write a local tag containing an ascii string as utf-16
 321  */
 322 static void mxf_write_local_tag_utf16(ByteIOContext *pb, int tag, const char *value)
 323 {
 324     int i, size = strlen(value);
 325     mxf_write_local_tag(pb, size*2, tag);
 326     for (i = 0; i < size; i++)
 327         put_be16(pb, value[i]);
 328 }
 329
 330 static void mxf_write_identification(AVFormatContext *s)
 331 {
 332     ByteIOContext *pb = s->pb;
 333     const char *company = "FFmpeg";
 334     const char *product = "OP1a Muxer";
 335     const char *version;
 336     int length;
 337
 338     mxf_write_metadata_key(pb, 0x013000);
 339     PRINT_KEY(s, "identification key", pb->buf_ptr - 16);
 340
 341     version = s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT ?
 342         "0.0.0" : AV_STRINGIFY(LIBAVFORMAT_VERSION);
 343     length = 84 + (strlen(company)+strlen(product)+strlen(version))*2; // utf-16
 344     klv_encode_ber_length(pb, length);
 345
 346     // write uid
 347     mxf_write_local_tag(pb, 16, 0x3C0A);
 348     mxf_write_uuid(pb, Identification, 0);
 349     PRINT_KEY(s, "identification uid", pb->buf_ptr - 16);
 350
 351     // write generation uid
 352     mxf_write_local_tag(pb, 16, 0x3C09);
 353     mxf_write_uuid(pb, Identification, 1);
 354
 355     mxf_write_local_tag_utf16(pb, 0x3C01, company); // Company Name
 356     mxf_write_local_tag_utf16(pb, 0x3C02, product); // Product Name
 357     mxf_write_local_tag_utf16(pb, 0x3C04, version); // Version String
 358
 359     // write product uid
 360     mxf_write_local_tag(pb, 16, 0x3C05);
 361     mxf_write_uuid(pb, Identification, 2);
 362
 363     // write modified date
 364     mxf_write_local_tag(pb, 8, 0x3C06);
 365     put_be64(pb, 0);
 366 }
 367
 368 static void mxf_write_content_storage(AVFormatContext *s)
 369 {
 370     ByteIOContext *pb = s->pb;
 371
 372     mxf_write_metadata_key(pb, 0x011800);
 373     PRINT_KEY(s, "content storage key", pb->buf_ptr - 16);
 374     klv_encode_ber_length(pb, 64);
 375
 376     // write uid
 377     mxf_write_local_tag(pb, 16, 0x3C0A);
 378     mxf_write_uuid(pb, ContentStorage, 0);
 379     PRINT_KEY(s, "content storage uid", pb->buf_ptr - 16);
 380
 381     // write package reference
 382     mxf_write_local_tag(pb, 16 * 2 + 8, 0x1901);
 383     mxf_write_refs_count(pb, 2);
 384     mxf_write_uuid(pb, MaterialPackage, 0);
 385     mxf_write_uuid(pb, SourcePackage, 0);
 386 }
 387
 388 static void mxf_write_package(AVFormatContext *s, enum MXFMetadataSetType type)
 389 {
 390     ByteIOContext *pb = s->pb;
 391     int i;
 392
 393     if (type == MaterialPackage) {
 394         mxf_write_metadata_key(pb, 0x013600);
 395         PRINT_KEY(s, "Material Package key", pb->buf_ptr - 16);
 396         klv_encode_ber_length(pb, 92 + 16 * s->nb_streams);
 397     } else {
 398         mxf_write_metadata_key(pb, 0x013700);
 399         PRINT_KEY(s, "Source Package key", pb->buf_ptr - 16);
 400         klv_encode_ber_length(pb, 112 + 16 * s->nb_streams); // 20 bytes length for descriptor reference
 401     }
 402
 403     // write uid
 404     mxf_write_local_tag(pb, 16, 0x3C0A);
 405     mxf_write_uuid(pb, type, 0);
 406     av_log(s,AV_LOG_DEBUG, "package type:%d\n", type);
 407     PRINT_KEY(s, "package uid", pb->buf_ptr - 16);
 408
 409     // write package umid
 410     mxf_write_local_tag(pb, 32, 0x4401);
 411     mxf_write_umid(pb, type, 0);
 412     PRINT_KEY(s, "package umid second part", pb->buf_ptr - 16);
 413
 414     // write create date
 415     mxf_write_local_tag(pb, 8, 0x4405);
 416     put_be64(pb, 0);
 417
 418     // write modified date
 419     mxf_write_local_tag(pb, 8, 0x4404);
 420     put_be64(pb, 0);
 421
 422     // write track refs
 423     mxf_write_local_tag(pb, s->nb_streams * 16 + 8, 0x4403);
 424     mxf_write_refs_count(pb, s->nb_streams);
 425     for (i = 0; i < s->nb_streams; i++)
 426         mxf_write_uuid(pb, type == MaterialPackage ? Track : Track + TypeBottom, i);
 427
 428     // write multiple descriptor reference
 429     if (type == SourcePackage) {
 430         mxf_write_local_tag(pb, 16, 0x4701);
 431         mxf_write_uuid(pb, MultipleDescriptor, 0);
 432     }
 433 }
 434
 435 static void mxf_write_track(AVFormatContext *s, int stream_index, enum MXFMetadataSetType type)
 436 {
 437     ByteIOContext *pb = s->pb;
 438     AVStream *st = s->streams[stream_index];
 439     MXFStreamContext *sc = st->priv_data;
 440
 441     mxf_write_metadata_key(pb, 0x013b00);
 442     PRINT_KEY(s, "track key", pb->buf_ptr - 16);
 443     klv_encode_ber_length(pb, 80);
 444
 445     // write track uid
 446     mxf_write_local_tag(pb, 16, 0x3C0A);
 447     mxf_write_uuid(pb, type == MaterialPackage ? Track : Track + TypeBottom, stream_index);
 448     PRINT_KEY(s, "track uid", pb->buf_ptr - 16);
 449
 450     // write track id
 451     mxf_write_local_tag(pb, 4, 0x4801);
 452     put_be32(pb, stream_index);
 453
 454     // write track number
 455     mxf_write_local_tag(pb, 4, 0x4804);
 456     if (type == MaterialPackage)
 457         put_be32(pb, 0); // track number of material package is 0
 458     else
 459         put_buffer(pb, sc->track_essence_element_key + 12, 4);
 460
 461     mxf_write_local_tag(pb, 8, 0x4B01);
 462     put_be32(pb, st->time_base.den);
 463     put_be32(pb, st->time_base.num);
 464
 465     // write origin
 466     mxf_write_local_tag(pb, 8, 0x4B02);
 467     put_be64(pb, 0);
 468
 469     // write sequence refs
 470     mxf_write_local_tag(pb, 16, 0x4803);
 471     mxf_write_uuid(pb, type == MaterialPackage ? Sequence: Sequence + TypeBottom, stream_index);
 472 }
 473
 474 static void mxf_write_common_fields(ByteIOContext *pb, AVStream *st)
 475 {
 476     const MXFDataDefinitionUL *data_def_ul = mxf_get_data_definition_ul(st->codec->codec_type);
 477     // find data define uls
 478     mxf_write_local_tag(pb, 16, 0x0201);
 479     put_buffer(pb, data_def_ul->uid, 16);
 480
 481     // write duration
 482     mxf_write_local_tag(pb, 8, 0x0202);
 483     put_be64(pb, st->duration);
 484 }
 485
 486 static void mxf_write_sequence(AVFormatContext *s, int stream_index, enum MXFMetadataSetType type)
 487 {
 488     ByteIOContext *pb = s->pb;
 489     AVStream *st = s->streams[stream_index];
 490
 491     mxf_write_metadata_key(pb, 0x010f00);
 492     PRINT_KEY(s, "sequence key", pb->buf_ptr - 16);
 493     klv_encode_ber_length(pb, 80);
 494
 495     mxf_write_local_tag(pb, 16, 0x3C0A);
 496     mxf_write_uuid(pb, type == MaterialPackage ? Sequence: Sequence + TypeBottom, stream_index);
 497
 498     PRINT_KEY(s, "sequence uid", pb->buf_ptr - 16);
 499     mxf_write_common_fields(pb, st);
 500
 501     // write structural component
 502     mxf_write_local_tag(pb, 16 + 8, 0x1001);
 503     mxf_write_refs_count(pb, 1);
 504     mxf_write_uuid(pb, type == MaterialPackage ? SourceClip: SourceClip + TypeBottom, stream_index);
 505 }
 506
 507 static void mxf_write_structural_component(AVFormatContext *s, int stream_index, enum MXFMetadataSetType type)
 508 {
 509     ByteIOContext *pb = s->pb;
 510     AVStream *st = s->streams[stream_index];
 511     int i;
 512
 513     mxf_write_metadata_key(pb, 0x011100);
 514     PRINT_KEY(s, "sturctural component key", pb->buf_ptr - 16);
 515     klv_encode_ber_length(pb, 108);
 516
 517     // write uid
 518     mxf_write_local_tag(pb, 16, 0x3C0A);
 519     mxf_write_uuid(pb, type == MaterialPackage ? SourceClip: SourceClip + TypeBottom, stream_index);
 520
 521     PRINT_KEY(s, "structural component uid", pb->buf_ptr - 16);
 522     mxf_write_common_fields(pb, st);
 523
 524     // write start_position
 525     mxf_write_local_tag(pb, 8, 0x1201);
 526     put_be64(pb, 0);
 527
 528     // write source package uid, end of the reference
 529     mxf_write_local_tag(pb, 32, 0x1101);
 530     if (type == SourcePackage) {
 531         for (i = 0; i < 4; i++)
 532             put_be64(pb, 0);
 533     } else
 534         mxf_write_umid(pb, SourcePackage, 0);
 535
 536     // write source track id
 537     mxf_write_local_tag(pb, 4, 0x1102);
 538     if (type == SourcePackage)
 539         put_be32(pb, 0);
 540     else
 541         put_be32(pb, stream_index);
 542 }
 543
 544 static void mxf_write_multi_descriptor(AVFormatContext *s)
 545 {
 546     ByteIOContext *pb = s->pb;
 547     int i;
 548
 549     mxf_write_metadata_key(pb, 0x014400);
 550     PRINT_KEY(s, "multiple descriptor key", pb->buf_ptr - 16);
 551     klv_encode_ber_length(pb, 64 + 16 * s->nb_streams);
 552
 553     mxf_write_local_tag(pb, 16, 0x3C0A);
 554     mxf_write_uuid(pb, MultipleDescriptor, 0);
 555     PRINT_KEY(s, "multi_desc uid", pb->buf_ptr - 16);
 556
 557     // write sample rate
 558     mxf_write_local_tag(pb, 8, 0x3001);
 559     put_be32(pb, s->streams[0]->time_base.den);
 560     put_be32(pb, s->streams[0]->time_base.num);
 561
 562     // write essence container ul
 563     mxf_write_local_tag(pb, 16, 0x3004);
 564     put_buffer(pb, multiple_desc_ul, 16);
 565
 566     // write sub descriptor refs
 567     mxf_write_local_tag(pb, s->nb_streams * 16 + 8, 0x3F01);
 568     mxf_write_refs_count(pb, s->nb_streams);
 569     for (i = 0; i < s->nb_streams; i++)
 570         mxf_write_uuid(pb, SubDescriptor, i);
 571 }
 572
 573 static void mxf_write_generic_desc(ByteIOContext *pb, const MXFDescriptorWriteTableEntry *desc_tbl, AVStream *st)
 574 {
 575     MXFStreamContext *sc = st->priv_data;
 576
 577     put_buffer(pb, desc_tbl->key, 16);
 578     klv_encode_ber_length(pb, 108);
 579
 580     mxf_write_local_tag(pb, 16, 0x3C0A);
 581     mxf_write_uuid(pb, SubDescriptor, st->index);
 582
 583     mxf_write_local_tag(pb, 4, 0x3006);
 584     put_be32(pb, st->index);
 585
 586     mxf_write_local_tag(pb, 8, 0x3001);
 587     put_be32(pb, st->time_base.den);
 588     put_be32(pb, st->time_base.num);
 589
 590     mxf_write_local_tag(pb, 16, 0x3004);
 591     put_buffer(pb, *sc->essence_container_ul, 16);
 592 }
 593
 594 static void mxf_write_mpegvideo_desc(AVFormatContext *s, const MXFDescriptorWriteTableEntry *desc_tbl, int stream_index)
 595 {
 596     ByteIOContext *pb = s->pb;
 597     AVStream *st = s->streams[stream_index];
 598
 599     mxf_write_generic_desc(pb, desc_tbl, st);
 600
 601     mxf_write_local_tag(pb, 4, 0x3203);
 602     put_be32(pb, st->codec->width);
 603
 604     mxf_write_local_tag(pb, 4, 0x3202);
 605     put_be32(pb, st->codec->height);
 606
 607     mxf_write_local_tag(pb, 8, 0x320E);
 608     put_be32(pb, st->codec->height * st->sample_aspect_ratio.den);
 609     put_be32(pb, st->codec->width  * st->sample_aspect_ratio.num);
 610
 611     // tmp write, will modified later
 612     mxf_write_local_tag(pb, 16, 0x3201);
 613     put_buffer(pb, ff_mxf_codec_uls->uid, 16);
 614 }
 615
 616 static void mxf_write_wav_desc(AVFormatContext *s, const MXFDescriptorWriteTableEntry *desc_tbl, int stream_index)
 617 {
 618     ByteIOContext *pb = s->pb;
 619     AVStream *st;
 620
 621     st = s->streams[stream_index];
 622     mxf_write_generic_desc(pb, desc_tbl, st);
 623
 624     // write audio sampling rate
 625     mxf_write_local_tag(pb, 8, 0x3D03);
 626     put_be32(pb, st->codec->sample_rate);
 627     put_be32(pb, 1);
 628
 629     mxf_write_local_tag(pb, 4, 0x3D07);
 630     put_be32(pb, st->codec->channels);
 631
 632     mxf_write_local_tag(pb, 4, 0x3D01);
 633     put_be32(pb, st->codec->bits_per_sample);
 634
 635     // tmp write, will modified later
 636     mxf_write_local_tag(pb, 16, 0x3201);
 637     put_buffer(pb, (ff_mxf_codec_uls + 8)->uid, 16);
 638 }
 639
 640 static const MXFDescriptorWriteTableEntry mxf_descriptor_write_table[] = {
 641     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_write_mpegvideo_desc, CODEC_ID_MPEG2VIDEO},
 642     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_write_wav_desc, CODEC_ID_PCM_S16LE},
 643     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, CODEC_ID_NONE},
 644 };
 645
 646 static void mxf_build_structural_metadata(AVFormatContext *s, enum MXFMetadataSetType type)
 647 {
 648     int i;
 649     const MXFDescriptorWriteTableEntry *desc = NULL;
 650
 651     mxf_write_package(s, type);
 652     if (type == SourcePackage)
 653         mxf_write_multi_descriptor(s);
 654
 655     for (i = 0; i < s->nb_streams; i++) {
 656         mxf_write_track(s, i, type);
 657         mxf_write_sequence(s, i, type);
 658         mxf_write_structural_component(s, i, type);
 659
 660         if (type == SourcePackage) {
 661             for (desc = mxf_descriptor_write_table; desc->write; desc++) {
 662                 if (s->streams[i]->codec->codec_id == desc->type) {
 663                     desc->write(s, desc, i);
 664                     break;
 665                 }
 666             }
 667         }
 668     }
 669 }
 670
 671 static int mxf_write_header_metadata_sets(AVFormatContext *s)
 672 {
 673     mxf_write_preface(s);
 674     mxf_write_identification(s);
 675     mxf_write_content_storage(s);
 676     mxf_build_structural_metadata(s, MaterialPackage);
 677     mxf_build_structural_metadata(s, SourcePackage);
 678     return 0;
 679 }
 680
 681 static void mxf_write_partition(AVFormatContext *s, int64_t byte_position, int bodysid, const uint8_t *key)
 682 {
 683     MXFContext *mxf = s->priv_data;
 684     ByteIOContext *pb = s->pb;
 685
 686     // write klv
 687     put_buffer(pb, key, 16);
 688
 689     klv_encode_ber_length(pb, 88 + 16 * mxf->essence_container_count);
 690
 691     // write partition value
 692     put_be16(pb, 1); // majorVersion
 693     put_be16(pb, 2); // minorVersion
 694     put_be32(pb, 1); // kagSize
 695
 696     put_be64(pb, byte_position); // thisPartition
 697     put_be64(pb, 0); // previousPartition
 698
 699     // set offset
 700     if (!byte_position)
 701         mxf->header_footer_partition_offset = url_ftell(pb);
 702     put_be64(pb, byte_position); // footerPartition,update later
 703
 704     // set offset
 705     if (!byte_position)
 706         mxf->header_byte_count_offset = url_ftell(pb);
 707     put_be64(pb, 0); // headerByteCount, update later
 708
 709     // no indexTable
 710     put_be64(pb, 0); // indexByteCount
 711     put_be32(pb, 0); // indexSID
 712     put_be64(pb, 0); // bodyOffset
 713
 714     put_be32(pb, bodysid); // bodySID
 715     put_buffer(pb, op1a_ul, 16); // operational pattern
 716
 717     // essence container
 718     mxf_write_essence_container_refs(s);
 719 }
 720
 721 static int mux_write_header(AVFormatContext *s)
 722 {
 723     MXFContext *mxf = s->priv_data;
 724     ByteIOContext *pb = s->pb;
 725     int64_t header_metadata_start, offset_now;
 726     int i, index;
 727     uint8_t present[sizeof(mxf_essence_container_uls)/
 728                     sizeof(*mxf_essence_container_uls)] = {0};
 729
 730     for (i = 0; i < s->nb_streams; i++) {
 731         AVStream *st = s->streams[i];
 732         MXFStreamContext *sc = av_mallocz(sizeof(*sc));
 733         if (!sc)
 734             return AVERROR(ENOMEM);
 735         st->priv_data = sc;
 736         // set pts information
 737         if (st->codec->codec_type == CODEC_TYPE_VIDEO)
 738             av_set_pts_info(st, 64, 1, st->codec->time_base.den);
 739         else if (st->codec->codec_type == CODEC_TYPE_AUDIO)
 740             av_set_pts_info(st, 64, 1, st->codec->sample_rate);
 741         sc->essence_container_ul = mxf_get_essence_container_ul(st->codec->codec_id, &index);
 742         if (!sc->essence_container_ul) {
 743             av_log(s, AV_LOG_ERROR, "track %d: could not find essence container ul, "
 744                    "codec not currently supported in container\n", i);
 745             return -1;
 746         }
 747         if (!present[index]) {
 748             mxf->essence_containers_indices[mxf->essence_container_count++] = index;
 749             present[index] = 1;
 750         } else
 751             present[index]++;
 752         memcpy(sc->track_essence_element_key, mxf_essence_container_uls[index].element_ul, 15);
 753         sc->track_essence_element_key[15] = present[index];
 754         PRINT_KEY(s, "track essence element key", sc->track_essence_element_key);
 755     }
 756
 757     mxf_write_partition(s, 0, 1, header_partition_key);
 758
 759     // mark the start of the headermetadata and calculate metadata size
 760     header_metadata_start = url_ftell(s->pb);
 761     mxf_write_primer_pack(s);
 762     if (mxf_write_header_metadata_sets(s) < 0)
 763         goto fail;
 764     offset_now = url_ftell(s->pb);
 765     mxf->header_byte_count = offset_now - header_metadata_start;
 766     // update header_byte_count
 767     url_fseek(pb, mxf->header_byte_count_offset, SEEK_SET);
 768     put_be64(pb, mxf->header_byte_count);
 769     url_fseek(pb, offset_now, SEEK_SET);
 770
 771     put_flush_packet(pb);
 772     return 0;
 773 fail:
 774     mxf_free(s);
 775     return -1;
 776 }
 777
 778 static int mux_write_packet(AVFormatContext *s, AVPacket *pkt)
 779 {
 780     ByteIOContext *pb = s->pb;
 781     AVStream *st = s->streams[pkt->stream_index];
 782     MXFStreamContext *sc = st->priv_data;
 783
 784     put_buffer(pb, sc->track_essence_element_key, 16); // write key
 785     klv_encode_ber_length(pb, pkt->size); // write length
 786     put_buffer(pb, pkt->data, pkt->size); // write value
 787
 788     put_flush_packet(pb);
 789     return 0;
 790 }
 791
 792 static void mxf_update_header_partition(AVFormatContext *s, int64_t footer_partition_offset)
 793 {
 794     MXFContext *mxf = s->priv_data;
 795     ByteIOContext *pb = s->pb;
 796
 797     url_fseek(pb, mxf->header_footer_partition_offset, SEEK_SET);
 798     put_be64(pb, footer_partition_offset);
 799     put_flush_packet(pb);
 800 }
 801
 802
 803 static int mux_write_footer(AVFormatContext *s)
 804 {
 805     ByteIOContext *pb = s->pb;
 806     int64_t byte_position= url_ftell(pb);
 807
 808     if (!url_is_streamed(s->pb)) {
 809         mxf_write_partition(s, byte_position, 0, footer_partition_key);
 810         put_flush_packet(pb);
 811         mxf_update_header_partition(s, byte_position);
 812     }
 813     mxf_free(s);
 814     return 0;
 815 }
 816
 817 AVOutputFormat mxf_muxer = {
 818     "mxf",
 819     NULL_IF_CONFIG_SMALL("Material eXchange Format"),
 820     NULL,
 821     "mxf",
 822     sizeof(MXFContext),
 823     CODEC_ID_PCM_S16LE,
 824     CODEC_ID_MPEG2VIDEO,
 825     mux_write_header,
 826     mux_write_packet,
 827     mux_write_footer,
 828 };
 829
 830