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