Statistics
| Branch: | Revision:

ffmpeg / libavformat / mxfenc.c @ d7fb5a18

History | View | Annotate | Download (30.9 KB)

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