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