2ea462d23d3418fc396b0ee3a09dcaa72a217d1e
[ffmpeg.git] / 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     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 } MXFContainerEssencePair;
54
55 static const MXFContainerEssencePair mxf_essence_container_uls[] = {
56     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x60,0x01 },
57       { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x15,0x01,0x05,0x00 },
58       { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x00,0x00,0x00 }, CODEC_ID_MPEG2VIDEO },
59     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x01,0x00 },
60       { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x16,0x01,0x01,0x00 },
61       { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 }, CODEC_ID_PCM_S16LE },
62     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
63       { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
64       { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, CODEC_ID_NONE },
65 };
66
67 typedef struct MXFContext {
68     int64_t header_byte_count;
69     int64_t header_byte_count_offset;
70     int64_t header_footer_partition_offset;
71     int essence_container_count;
72     uint8_t essence_containers_indices[sizeof(mxf_essence_container_uls)/
73                                        sizeof(*mxf_essence_container_uls)];
74 } MXFContext;
75
76 typedef struct {
77     const UID key;
78     void (*write)();
79     enum CodecType type;
80 } MXFDescriptorWriteTableEntry;
81
82 static const uint8_t uuid_base[]            = { 0xAD,0xAB,0x44,0x24,0x2f,0x25,0x4d,0xc7,0x92,0xff,0x29,0xbd };
83 static const uint8_t umid_base[]            = { 0x06,0x0A,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x0F,0x00,0x13,0x00,0x00,0x00 };
84
85 /**
86  * complete key for operation pattern, partitions, and primer pack
87  */
88 static const uint8_t op1a_ul[]              = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x01,0x01,0x00 };
89 static const uint8_t header_partition_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }; // ClosedComplete
90 static const uint8_t footer_partition_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }; // ClosedComplete
91 static const uint8_t primer_pack_key[]      = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x05,0x01,0x00 };
92
93 /**
94  * partial key for header metadata
95  */
96 static const uint8_t header_metadata_key[]  = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01 };
97
98 static const uint8_t multiple_desc_ul[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x0D,0x01,0x03,0x01,0x02,0x7F,0x01,0x00 };
99
100 /**
101  * SMPTE RP210 http://www.smpte-ra.org/mdd/index.html
102  */
103 static const MXFLocalTagPair mxf_local_tag_batch[] = {
104     // preface set
105     { 0x3C0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x15,0x02,0x00,0x00,0x00,0x00}}, /* Instance UID */
106     { 0x3B02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x04,0x00,0x00}}, /* Last Modified Date */
107     { 0x3B05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x01,0x02,0x01,0x05,0x00,0x00,0x00}}, /* Version */
108     { 0x3B06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x04,0x00,0x00}}, /* Identifications reference */
109     { 0x3B03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x01,0x00,0x00}}, /* Content Storage reference */
110     { 0x3B09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x03,0x00,0x00,0x00,0x00}}, /* Operational Pattern UL */
111     { 0x3B0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x10,0x02,0x01,0x00,0x00}}, /* Essence Containers UL batch */
112     { 0x3B0B, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x10,0x02,0x02,0x00,0x00}}, /* DM Schemes UL batch */
113     // Identification
114     { 0x3C09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x01,0x00,0x00,0x00}}, /* This Generation UID */
115     { 0x3C01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x02,0x01,0x00,0x00}}, /* Company Name */
116     { 0x3C02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x03,0x01,0x00,0x00}}, /* Product Name */
117     { 0x3C04, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x05,0x01,0x00,0x00}}, /* Version String */
118     { 0x3C05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x07,0x00,0x00,0x00}}, /* Product ID */
119     { 0x3C06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x03,0x00,0x00}}, /* Modification Date */
120     // Content Storage
121     { 0x1901, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x05,0x01,0x00,0x00}}, /* Package strong reference batch */
122     // Essence Container Data
123     { 0x2701, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x06,0x01,0x00,0x00,0x00}}, /* Linked Package UID */
124     { 0x3F07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x01,0x03,0x04,0x04,0x00,0x00,0x00,0x00}}, /* BodySID */
125     // Package
126     { 0x4401, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x15,0x10,0x00,0x00,0x00,0x00}}, /* Package UID */
127     { 0x4405, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x01,0x03,0x00,0x00}}, /* Package Creation Date */
128     { 0x4404, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x05,0x00,0x00}}, /* Package Modified Date */
129     { 0x4403, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x05,0x00,0x00}}, /* Tracks Strong reference array */
130     { 0x4701, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x03,0x00,0x00}}, /* Descriptor */
131     // Track
132     { 0x4801, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x01,0x07,0x01,0x01,0x00,0x00,0x00,0x00}}, /* Track ID */
133     { 0x4804, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x01,0x04,0x01,0x03,0x00,0x00,0x00,0x00}}, /* Track Number */
134     { 0x4B01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x30,0x04,0x05,0x00,0x00,0x00,0x00}}, /* Edit Rate */
135     { 0x4B02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x03,0x01,0x03,0x00,0x00}}, /* Origin */
136     { 0x4803, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x04,0x00,0x00}}, /* Sequence reference */
137     // Sequence
138     { 0x0201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x07,0x01,0x00,0x00,0x00,0x00,0x00}}, /* Data Definition UL */
139     { 0x0202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x02,0x01,0x01,0x03,0x00,0x00}}, /* Duration */
140     { 0x1001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x09,0x00,0x00}}, /* Structural Components reference array */
141     // Source Clip
142     { 0x1201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x07,0x02,0x01,0x03,0x01,0x0A,0x00,0x00}}, /* Start position */
143     { 0x1101, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x03,0x01,0x00,0x00,0x00}}, /* SourcePackageID */
144     { 0x1102, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x03,0x02,0x00,0x00,0x00}}, /* SourceTrackID */
145     // File Descriptor
146     { 0x3F01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x06,0x01,0x01,0x04,0x06,0x0B,0x00,0x00}}, /* Sub Descriptors reference array */
147     { 0x3006, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x06,0x01,0x01,0x03,0x05,0x00,0x00,0x00}}, /* Linked Track ID */
148     { 0x3001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x06,0x01,0x01,0x00,0x00,0x00,0x00}}, /* SampleRate */
149     { 0x3004, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x01,0x02,0x00,0x00}}, /* Essence Container */
150     // Generic Picture Essence Descriptor
151     { 0x3203, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x02,0x02,0x00,0x00,0x00}}, /* Stored Width */
152     { 0x3202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x02,0x01,0x00,0x00,0x00}}, /* Stored Height */
153     { 0x320E, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x01,0x01,0x01,0x00,0x00,0x00}}, /* Aspect Ratio */
154     { 0x3201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x06,0x01,0x00,0x00,0x00,0x00}}, /* Picture Essence Coding */
155     // Generic Sound Essence Descriptor
156     { 0x3D03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x01,0x01,0x01,0x00,0x00}}, /* Audio sampling rate */
157     { 0x3D07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x01,0x01,0x04,0x00,0x00,0x00}}, /* ChannelCount */
158     { 0x3D01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x02,0x03,0x03,0x04,0x00,0x00,0x00}}, /* Quantization bits */
159     { 0x3D06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x06,0x01,0x00,0x00,0x00,0x00}}, /* Sound Essence Compression */
160 };
161
162 static void mxf_write_uuid(ByteIOContext *pb, enum CodecID type, int value)
163 {
164     put_buffer(pb, uuid_base, 12);
165     put_be16(pb, type);
166     put_be16(pb, value);
167 }
168
169 static void mxf_write_umid(ByteIOContext *pb, enum CodecID type, int value)
170 {
171     put_buffer(pb, umid_base, 16);
172     mxf_write_uuid(pb, type, value);
173 }
174
175 static void mxf_write_refs_count(ByteIOContext *pb, int ref_count)
176 {
177     put_be32(pb, ref_count);
178     put_be32(pb, 16);
179 }
180
181 static int klv_encode_ber_length(ByteIOContext *pb, uint64_t len)
182 {
183     // Determine the best BER size
184     int size;
185     if (len < 128) {
186         //short form
187         put_byte(pb, len);
188         return 1;
189     }
190
191     size = (av_log2(len) >> 3) + 1;
192
193     // long form
194     put_byte(pb, 0x80 + size);
195     while(size) {
196         size --;
197         put_byte(pb, len >> 8 * size & 0xff);
198     }
199     return 0;
200 }
201
202 /*
203  * Get essence container ul and return its index position
204  */
205 static const UID *mxf_get_essence_container_ul(enum CodecID type, int *index)
206 {
207     for (*index = 0; *index < sizeof(mxf_essence_container_uls)/
208                               sizeof(*mxf_essence_container_uls); (*index)++)
209         if (mxf_essence_container_uls[*index].id == type)
210             return &mxf_essence_container_uls[*index].container_ul;
211     *index = -1;
212     return NULL;
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 = sizeof(mxf_local_tag_batch)/sizeof(*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_package(AVFormatContext *s, enum MXFMetadataSetType type)
394 {
395     ByteIOContext *pb = s->pb;
396     int i;
397
398     if (type == MaterialPackage) {
399         mxf_write_metadata_key(pb, 0x013600);
400         PRINT_KEY(s, "Material Package key", pb->buf_ptr - 16);
401         klv_encode_ber_length(pb, 92 + 16 * s->nb_streams);
402     } else {
403         mxf_write_metadata_key(pb, 0x013700);
404         PRINT_KEY(s, "Source Package key", pb->buf_ptr - 16);
405         klv_encode_ber_length(pb, 112 + 16 * s->nb_streams); // 20 bytes length for descriptor reference
406     }
407
408     // write uid
409     mxf_write_local_tag(pb, 16, 0x3C0A);
410     mxf_write_uuid(pb, type, 0);
411     av_log(s,AV_LOG_DEBUG, "package type:%d\n", type);
412     PRINT_KEY(s, "package uid", pb->buf_ptr - 16);
413
414     // write package umid
415     mxf_write_local_tag(pb, 32, 0x4401);
416     mxf_write_umid(pb, type, 0);
417     PRINT_KEY(s, "package umid second part", pb->buf_ptr - 16);
418
419     // write create date
420     mxf_write_local_tag(pb, 8, 0x4405);
421     put_be64(pb, 0);
422
423     // write modified date
424     mxf_write_local_tag(pb, 8, 0x4404);
425     put_be64(pb, 0);
426
427     // write track refs
428     mxf_write_local_tag(pb, s->nb_streams * 16 + 8, 0x4403);
429     mxf_write_refs_count(pb, s->nb_streams);
430     for (i = 0; i < s->nb_streams; i++)
431         mxf_write_uuid(pb, type == MaterialPackage ? Track : Track + TypeBottom, i);
432
433     // write multiple descriptor reference
434     if (type == SourcePackage) {
435         mxf_write_local_tag(pb, 16, 0x4701);
436         mxf_write_uuid(pb, MultipleDescriptor, 0);
437     }
438 }
439
440 static void mxf_write_track(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)
441 {
442     ByteIOContext *pb = s->pb;
443     MXFStreamContext *sc = st->priv_data;
444
445     mxf_write_metadata_key(pb, 0x013b00);
446     PRINT_KEY(s, "track key", pb->buf_ptr - 16);
447     klv_encode_ber_length(pb, 80);
448
449     // write track uid
450     mxf_write_local_tag(pb, 16, 0x3C0A);
451     mxf_write_uuid(pb, type == MaterialPackage ? Track : Track + TypeBottom, st->index);
452     PRINT_KEY(s, "track uid", pb->buf_ptr - 16);
453
454     // write track id
455     mxf_write_local_tag(pb, 4, 0x4801);
456     put_be32(pb, st->index);
457
458     // write track number
459     mxf_write_local_tag(pb, 4, 0x4804);
460     if (type == MaterialPackage)
461         put_be32(pb, 0); // track number of material package is 0
462     else
463         put_buffer(pb, sc->track_essence_element_key + 12, 4);
464
465     mxf_write_local_tag(pb, 8, 0x4B01);
466     put_be32(pb, st->time_base.den);
467     put_be32(pb, st->time_base.num);
468
469     // write origin
470     mxf_write_local_tag(pb, 8, 0x4B02);
471     put_be64(pb, 0);
472
473     // write sequence refs
474     mxf_write_local_tag(pb, 16, 0x4803);
475     mxf_write_uuid(pb, type == MaterialPackage ? Sequence: Sequence + TypeBottom, st->index);
476 }
477
478 static void mxf_write_common_fields(ByteIOContext *pb, AVStream *st)
479 {
480     const MXFDataDefinitionUL *data_def_ul = mxf_get_data_definition_ul(st->codec->codec_type);
481     MXFStreamContext *sc = st->priv_data;
482
483     // find data define uls
484     mxf_write_local_tag(pb, 16, 0x0201);
485     put_buffer(pb, data_def_ul->uid, 16);
486
487     // write duration
488     mxf_write_local_tag(pb, 8, 0x0202);
489     put_be64(pb, sc->duration);
490 }
491
492 static void mxf_write_sequence(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)
493 {
494     ByteIOContext *pb = s->pb;
495
496     mxf_write_metadata_key(pb, 0x010f00);
497     PRINT_KEY(s, "sequence key", pb->buf_ptr - 16);
498     klv_encode_ber_length(pb, 80);
499
500     mxf_write_local_tag(pb, 16, 0x3C0A);
501     mxf_write_uuid(pb, type == MaterialPackage ? Sequence: Sequence + TypeBottom, st->index);
502
503     PRINT_KEY(s, "sequence uid", pb->buf_ptr - 16);
504     mxf_write_common_fields(pb, st);
505
506     // write structural component
507     mxf_write_local_tag(pb, 16 + 8, 0x1001);
508     mxf_write_refs_count(pb, 1);
509     mxf_write_uuid(pb, type == MaterialPackage ? SourceClip: SourceClip + TypeBottom, st->index);
510 }
511
512 static void mxf_write_structural_component(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)
513 {
514     ByteIOContext *pb = s->pb;
515     int i;
516
517     mxf_write_metadata_key(pb, 0x011100);
518     PRINT_KEY(s, "sturctural component key", pb->buf_ptr - 16);
519     klv_encode_ber_length(pb, 108);
520
521     // write uid
522     mxf_write_local_tag(pb, 16, 0x3C0A);
523     mxf_write_uuid(pb, type == MaterialPackage ? SourceClip: SourceClip + TypeBottom, st->index);
524
525     PRINT_KEY(s, "structural component uid", pb->buf_ptr - 16);
526     mxf_write_common_fields(pb, st);
527
528     // write start_position
529     mxf_write_local_tag(pb, 8, 0x1201);
530     put_be64(pb, 0);
531
532     // write source package uid, end of the reference
533     mxf_write_local_tag(pb, 32, 0x1101);
534     if (type == SourcePackage) {
535         for (i = 0; i < 4; i++)
536             put_be64(pb, 0);
537     } else
538         mxf_write_umid(pb, SourcePackage, 0);
539
540     // write source track id
541     mxf_write_local_tag(pb, 4, 0x1102);
542     if (type == SourcePackage)
543         put_be32(pb, 0);
544     else
545         put_be32(pb, st->index);
546 }
547
548 static void mxf_write_multi_descriptor(AVFormatContext *s)
549 {
550     ByteIOContext *pb = s->pb;
551     int i;
552
553     mxf_write_metadata_key(pb, 0x014400);
554     PRINT_KEY(s, "multiple descriptor key", pb->buf_ptr - 16);
555     klv_encode_ber_length(pb, 64 + 16 * s->nb_streams);
556
557     mxf_write_local_tag(pb, 16, 0x3C0A);
558     mxf_write_uuid(pb, MultipleDescriptor, 0);
559     PRINT_KEY(s, "multi_desc uid", pb->buf_ptr - 16);
560
561     // write sample rate
562     mxf_write_local_tag(pb, 8, 0x3001);
563     put_be32(pb, s->streams[0]->time_base.den);
564     put_be32(pb, s->streams[0]->time_base.num);
565
566     // write essence container ul
567     mxf_write_local_tag(pb, 16, 0x3004);
568     put_buffer(pb, multiple_desc_ul, 16);
569
570     // write sub descriptor refs
571     mxf_write_local_tag(pb, s->nb_streams * 16 + 8, 0x3F01);
572     mxf_write_refs_count(pb, s->nb_streams);
573     for (i = 0; i < s->nb_streams; i++)
574         mxf_write_uuid(pb, SubDescriptor, i);
575 }
576
577 static void mxf_write_generic_desc(ByteIOContext *pb, const MXFDescriptorWriteTableEntry *desc_tbl, AVStream *st)
578 {
579     MXFStreamContext *sc = st->priv_data;
580
581     put_buffer(pb, desc_tbl->key, 16);
582     klv_encode_ber_length(pb, 108);
583
584     mxf_write_local_tag(pb, 16, 0x3C0A);
585     mxf_write_uuid(pb, SubDescriptor, st->index);
586
587     mxf_write_local_tag(pb, 4, 0x3006);
588     put_be32(pb, st->index);
589
590     mxf_write_local_tag(pb, 8, 0x3001);
591     put_be32(pb, st->time_base.den);
592     put_be32(pb, st->time_base.num);
593
594     mxf_write_local_tag(pb, 16, 0x3004);
595     put_buffer(pb, *sc->essence_container_ul, 16);
596
597     mxf_write_local_tag(pb, 16, 0x3201);
598     put_buffer(pb, *sc->codec_ul, 16);
599 }
600
601 static void mxf_write_mpegvideo_desc(AVFormatContext *s, const MXFDescriptorWriteTableEntry *desc_tbl, AVStream *st)
602 {
603     ByteIOContext *pb = s->pb;
604
605     mxf_write_generic_desc(pb, desc_tbl, st);
606
607     mxf_write_local_tag(pb, 4, 0x3203);
608     put_be32(pb, st->codec->width);
609
610     mxf_write_local_tag(pb, 4, 0x3202);
611     put_be32(pb, st->codec->height);
612
613     mxf_write_local_tag(pb, 8, 0x320E);
614     put_be32(pb, st->codec->height * st->sample_aspect_ratio.den);
615     put_be32(pb, st->codec->width  * st->sample_aspect_ratio.num);
616 }
617
618 static void mxf_write_wav_desc(AVFormatContext *s, const MXFDescriptorWriteTableEntry *desc_tbl, AVStream *st)
619 {
620     ByteIOContext *pb = s->pb;
621
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
636 static const MXFDescriptorWriteTableEntry mxf_descriptor_write_table[] = {
637     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_write_mpegvideo_desc, CODEC_ID_MPEG2VIDEO},
638     { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_write_wav_desc, CODEC_ID_PCM_S16LE},
639     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, CODEC_ID_NONE},
640 };
641
642 static void mxf_build_structural_metadata(AVFormatContext *s, enum MXFMetadataSetType type)
643 {
644     int i;
645     const MXFDescriptorWriteTableEntry *desc = NULL;
646
647     mxf_write_package(s, type);
648     if (type == SourcePackage)
649         mxf_write_multi_descriptor(s);
650
651     for (i = 0; i < s->nb_streams; i++) {
652         AVStream *st = s->streams[i];
653         mxf_write_track(s, st, type);
654         mxf_write_sequence(s, st, type);
655         mxf_write_structural_component(s, st, type);
656
657         if (type == SourcePackage) {
658             for (desc = mxf_descriptor_write_table; desc->write; desc++) {
659                 if (s->streams[i]->codec->codec_id == desc->type) {
660                     desc->write(s, desc, st);
661                     break;
662                 }
663             }
664         }
665     }
666 }
667
668 static int mxf_write_header_metadata_sets(AVFormatContext *s)
669 {
670     mxf_write_preface(s);
671     mxf_write_identification(s);
672     mxf_write_content_storage(s);
673     mxf_build_structural_metadata(s, MaterialPackage);
674     mxf_build_structural_metadata(s, SourcePackage);
675     return 0;
676 }
677
678 static void mxf_write_partition(AVFormatContext *s, int64_t byte_position, int bodysid, const uint8_t *key)
679 {
680     MXFContext *mxf = s->priv_data;
681     ByteIOContext *pb = s->pb;
682
683     // write klv
684     put_buffer(pb, key, 16);
685
686     klv_encode_ber_length(pb, 88 + 16 * mxf->essence_container_count);
687
688     // write partition value
689     put_be16(pb, 1); // majorVersion
690     put_be16(pb, 2); // minorVersion
691     put_be32(pb, 1); // kagSize
692
693     put_be64(pb, byte_position); // thisPartition
694     put_be64(pb, 0); // previousPartition
695
696     // set offset
697     if (!byte_position)
698         mxf->header_footer_partition_offset = url_ftell(pb);
699     put_be64(pb, byte_position); // footerPartition,update later
700
701     // set offset
702     if (!byte_position)
703         mxf->header_byte_count_offset = url_ftell(pb);
704     put_be64(pb, 0); // headerByteCount, update later
705
706     // no indexTable
707     put_be64(pb, 0); // indexByteCount
708     put_be32(pb, 0); // indexSID
709     put_be64(pb, 0); // bodyOffset
710
711     put_be32(pb, bodysid); // bodySID
712     put_buffer(pb, op1a_ul, 16); // operational pattern
713
714     // essence container
715     mxf_write_essence_container_refs(s);
716 }
717
718 static const UID mxf_mpeg2_codec_uls[] = {
719     { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x10,0x00 }, // MP-ML I-Frame
720     { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x11,0x00 }, // MP-ML Long GOP
721     { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x02,0x00 }, // 422P-ML I-Frame
722     { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x03,0x00 }, // 422P-ML Long GOP
723     { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x02,0x00 }, // MP-HL I-Frame
724     { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x03,0x00 }, // MP-HL Long GOP
725     { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x02,0x00 }, // 422P-HL I-Frame
726     { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x03,0x00 }, // 422P-HL Long GOP
727 };
728
729 static const UID *mxf_get_mpeg2_codec_ul(AVCodecContext *avctx)
730 {
731     if (avctx->profile == 4) { // Main
732         if (avctx->level == 8) // Main
733             return avctx->gop_size ?
734                 &mxf_mpeg2_codec_uls[1] :
735                 &mxf_mpeg2_codec_uls[0];
736         else if (avctx->level == 4) // High
737             return avctx->gop_size ?
738                 &mxf_mpeg2_codec_uls[5] :
739                 &mxf_mpeg2_codec_uls[4];
740     } else if (avctx->profile == 0) { // 422
741         if (avctx->level == 5) // Main
742             return avctx->gop_size ?
743                 &mxf_mpeg2_codec_uls[3] :
744                 &mxf_mpeg2_codec_uls[2];
745         else if (avctx->level == 2) // High
746             return avctx->gop_size ?
747                 &mxf_mpeg2_codec_uls[7] :
748                 &mxf_mpeg2_codec_uls[6];
749     }
750     return NULL;
751 }
752
753 static int mxf_write_header(AVFormatContext *s)
754 {
755     MXFContext *mxf = s->priv_data;
756     ByteIOContext *pb = s->pb;
757     int64_t header_metadata_start, offset_now;
758     int i, index;
759     uint8_t present[sizeof(mxf_essence_container_uls)/
760                     sizeof(*mxf_essence_container_uls)] = {0};
761
762     for (i = 0; i < s->nb_streams; i++) {
763         AVStream *st = s->streams[i];
764         MXFStreamContext *sc = av_mallocz(sizeof(*sc));
765         if (!sc)
766             return AVERROR(ENOMEM);
767         st->priv_data = sc;
768         // set pts information
769         if (st->codec->codec_type == CODEC_TYPE_VIDEO)
770             av_set_pts_info(st, 64, 1, st->codec->time_base.den);
771         else if (st->codec->codec_type == CODEC_TYPE_AUDIO)
772             av_set_pts_info(st, 64, 1, st->codec->sample_rate);
773         sc->duration = -1;
774
775         sc->essence_container_ul = mxf_get_essence_container_ul(st->codec->codec_id, &index);
776         if (!sc->essence_container_ul) {
777             av_log(s, AV_LOG_ERROR, "track %d: could not find essence container ul, "
778                    "codec not currently supported in container\n", i);
779             return -1;
780         }
781
782         if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO) {
783             if (st->codec->profile == FF_PROFILE_UNKNOWN ||
784                 st->codec->level == FF_LEVEL_UNKNOWN) {
785                 av_log(s, AV_LOG_ERROR, "track %d: profile and level must be set for mpeg-2\n", i);
786                 return -1;
787             }
788             sc->codec_ul = mxf_get_mpeg2_codec_ul(st->codec);
789             if (!sc->codec_ul) {
790                 av_log(s, AV_LOG_ERROR, "track %d: could not find codec ul for mpeg-2, "
791                        "unsupported profile/level\n", i);
792                 return -1;
793             }
794         } else
795             sc->codec_ul = &mxf_essence_container_uls[index].codec_ul;
796
797         if (!present[index]) {
798             mxf->essence_containers_indices[mxf->essence_container_count++] = index;
799             present[index] = 1;
800         } else
801             present[index]++;
802         memcpy(sc->track_essence_element_key, mxf_essence_container_uls[index].element_ul, 15);
803         sc->track_essence_element_key[15] = present[index];
804         PRINT_KEY(s, "track essence element key", sc->track_essence_element_key);
805     }
806
807     mxf_write_partition(s, 0, 1, header_partition_key);
808
809     // mark the start of the headermetadata and calculate metadata size
810     header_metadata_start = url_ftell(s->pb);
811     mxf_write_primer_pack(s);
812     if (mxf_write_header_metadata_sets(s) < 0)
813         goto fail;
814     offset_now = url_ftell(s->pb);
815     mxf->header_byte_count = offset_now - header_metadata_start;
816     // update header_byte_count
817     url_fseek(pb, mxf->header_byte_count_offset, SEEK_SET);
818     put_be64(pb, mxf->header_byte_count);
819     url_fseek(pb, offset_now, SEEK_SET);
820
821     put_flush_packet(pb);
822     return 0;
823 fail:
824     mxf_free(s);
825     return -1;
826 }
827
828 static int mxf_write_packet(AVFormatContext *s, AVPacket *pkt)
829 {
830     ByteIOContext *pb = s->pb;
831     AVStream *st = s->streams[pkt->stream_index];
832     MXFStreamContext *sc = st->priv_data;
833
834     put_buffer(pb, sc->track_essence_element_key, 16); // write key
835     klv_encode_ber_length(pb, pkt->size); // write length
836     put_buffer(pb, pkt->data, pkt->size); // write value
837
838     sc->duration = FFMAX(pkt->pts + pkt->duration, sc->duration);
839
840     put_flush_packet(pb);
841     return 0;
842 }
843
844 static void mxf_update_header_partition(AVFormatContext *s, int64_t footer_partition_offset)
845 {
846     MXFContext *mxf = s->priv_data;
847     ByteIOContext *pb = s->pb;
848
849     url_fseek(pb, mxf->header_footer_partition_offset, SEEK_SET);
850     put_be64(pb, footer_partition_offset);
851     put_flush_packet(pb);
852 }
853
854
855 static int mxf_write_footer(AVFormatContext *s)
856 {
857     ByteIOContext *pb = s->pb;
858     int64_t byte_position= url_ftell(pb);
859
860     mxf_write_partition(s, byte_position, 0, footer_partition_key);
861     put_flush_packet(pb);
862     if (!url_is_streamed(s->pb))
863         mxf_update_header_partition(s, byte_position);
864     mxf_free(s);
865     return 0;
866 }
867
868 AVOutputFormat mxf_muxer = {
869     "mxf",
870     NULL_IF_CONFIG_SMALL("Material eXchange Format"),
871     NULL,
872     "mxf",
873     sizeof(MXFContext),
874     CODEC_ID_PCM_S16LE,
875     CODEC_ID_MPEG2VIDEO,
876     mxf_write_header,
877     mxf_write_packet,
878     mxf_write_footer,
879 };
880
881