3 * Copyright (c) 2008 GUCAS, Zhentan Feng <spyfeng at gmail dot com>
4 * Copyright (c) 2008 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
26 * SMPTE 377M MXF File Format Specifications
27 * SMPTE 379M MXF Generic Container
28 * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
29 * SMPTE RP210: SMPTE Metadata Dictionary
30 * SMPTE RP224: Registry of SMPTE Universal Labels
38 #include "libavutil/fifo.h"
39 #include "libavutil/random_seed.h"
40 #include "libavcodec/bytestream.h"
41 #include "audiointerleave.h"
45 static const int NTSC_samples_per_frame
[] = { 1602, 1601, 1602, 1601, 1602, 0 };
46 static const int PAL_samples_per_frame
[] = { 1920, 0 };
48 AVOutputFormat mxf_d10_muxer
;
50 #define EDIT_UNITS_PER_BODY 250
61 unsigned slice_offset
; ///< offset of audio slice
65 AudioInterleaveContext aic
;
66 UID track_essence_element_key
;
67 int index
; ///< index in mxf_essence_container_uls table
69 int order
; ///< interleaving order if dts are equal
70 int interlaced
; ///< wether picture is interlaced
71 int temporal_reordering
;
72 AVRational aspect_ratio
; ///< display aspect ratio
80 } MXFContainerEssenceEntry
;
85 } mxf_essence_mappings
[] = {
86 { CODEC_ID_MPEG2VIDEO
, 0 },
87 { CODEC_ID_PCM_S24LE
, 1 },
88 { CODEC_ID_PCM_S16LE
, 1 },
92 static void mxf_write_wav_desc(AVFormatContext
*s
, AVStream
*st
);
93 static void mxf_write_aes3_desc(AVFormatContext
*s
, AVStream
*st
);
94 static void mxf_write_mpegvideo_desc(AVFormatContext
*s
, AVStream
*st
);
95 static void mxf_write_cdci_desc(AVFormatContext
*s
, AVStream
*st
);
96 static void mxf_write_generic_sound_desc(AVFormatContext
*s
, AVStream
*st
);
98 static const MXFContainerEssenceEntry mxf_essence_container_uls
[] = {
99 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x60,0x01 },
100 { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x15,0x01,0x05,0x00 },
101 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x00,0x00,0x00 },
102 mxf_write_mpegvideo_desc
},
103 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x03,0x00 },
104 { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x16,0x01,0x03,0x00 },
105 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
106 mxf_write_aes3_desc
},
107 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x01,0x00 },
108 { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x16,0x01,0x01,0x00 },
109 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
110 mxf_write_wav_desc
},
111 // D-10 625/50 PAL 50mb/s
112 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 },
113 { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x05,0x01,0x01,0x00 },
114 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x01 },
115 mxf_write_cdci_desc
},
116 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 },
117 { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x06,0x01,0x10,0x00 },
118 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
119 mxf_write_generic_sound_desc
},
120 // D-10 525/60 NTSC 50mb/s
121 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x02,0x01 },
122 { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x05,0x01,0x01,0x00 },
123 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x02 },
124 mxf_write_cdci_desc
},
125 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x02,0x01 },
126 { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x06,0x01,0x10,0x00 },
127 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
128 mxf_write_generic_sound_desc
},
129 // D-10 625/50 PAL 40mb/s
130 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x03,0x01 },
131 { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x05,0x01,0x01,0x00 },
132 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x03 },
133 mxf_write_cdci_desc
},
134 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x03,0x01 },
135 { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x06,0x01,0x10,0x00 },
136 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
137 mxf_write_generic_sound_desc
},
138 // D-10 525/60 NTSC 40mb/s
139 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x04,0x01 },
140 { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x05,0x01,0x01,0x00 },
141 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x04 },
142 mxf_write_cdci_desc
},
143 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x04,0x01 },
144 { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x06,0x01,0x10,0x00 },
145 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
146 mxf_write_generic_sound_desc
},
147 // D-10 625/50 PAL 30mb/s
148 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x05,0x01 },
149 { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x05,0x01,0x01,0x00 },
150 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x05 },
151 mxf_write_cdci_desc
},
152 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x05,0x01 },
153 { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x06,0x01,0x10,0x00 },
154 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
155 mxf_write_generic_sound_desc
},
156 // D-10 525/60 NTSC 30mb/s
157 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x06,0x01 },
158 { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x05,0x01,0x01,0x00 },
159 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x06 },
160 mxf_write_cdci_desc
},
161 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x06,0x01 },
162 { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x06,0x01,0x10,0x00 },
163 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
164 mxf_write_generic_sound_desc
},
165 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
166 { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
167 { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
171 typedef struct MXFContext
{
172 int64_t footer_partition_offset
;
173 int essence_container_count
;
174 AVRational time_base
;
176 MXFIndexEntry
*index_entries
;
177 unsigned edit_units_count
;
178 uint64_t timestamp
; ///< timestamp, as year(16),month(8),day(8),hour(8),minutes(8),msec/4(8)
179 uint8_t slice_count
; ///< index slice count minus 1 (1 if no audio, 0 otherwise)
180 int last_indexed_edit_unit
;
181 uint64_t *body_partition_offset
;
182 unsigned body_partitions_count
;
183 int last_key_index
; ///< index of last key frame
185 AVStream
*timecode_track
;
186 int timecode_base
; ///< rounded time code base (25 or 30)
187 int timecode_start
; ///< frame number computed from mpeg-2 gop header timecode
188 int timecode_drop_frame
; ///< time code use drop frame method frop mpeg-2 essence gop header
189 int edit_unit_byte_count
; ///< fixed edit unit byte count
190 uint64_t body_offset
;
191 uint32_t instance_number
;
192 uint8_t umid
[16]; ///< unique material identifier
195 static const uint8_t uuid_base
[] = { 0xAD,0xAB,0x44,0x24,0x2f,0x25,0x4d,0xc7,0x92,0xff,0x29,0xbd };
196 static const uint8_t umid_ul
[] = { 0x06,0x0A,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x01,0x0D,0x00,0x13 };
199 * complete key for operation pattern, partitions, and primer pack
201 static const uint8_t op1a_ul
[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x01,0x09,0x00 };
202 static const uint8_t footer_partition_key
[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }; // ClosedComplete
203 static const uint8_t primer_pack_key
[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x05,0x01,0x00 };
204 static const uint8_t index_table_segment_key
[] = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 };
205 static const uint8_t random_index_pack_key
[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x11,0x01,0x00 };
206 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
207 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
208 static const uint8_t klv_fill_key
[] = { 0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x03,0x01,0x02,0x10,0x01,0x00,0x00,0x00 };
209 static const uint8_t body_partition_key
[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }; // ClosedComplete
212 * partial key for header metadata
214 static const uint8_t header_metadata_key
[] = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01 };
215 static const uint8_t multiple_desc_ul
[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x0D,0x01,0x03,0x01,0x02,0x7F,0x01,0x00 };
218 * SMPTE RP210 http://www.smpte-ra.org/mdd/index.html
220 static const MXFLocalTagPair mxf_local_tag_batch
[] = {
222 { 0x3C0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x15,0x02,0x00,0x00,0x00,0x00}}, /* Instance UID */
223 { 0x3B02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x04,0x00,0x00}}, /* Last Modified Date */
224 { 0x3B05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x01,0x02,0x01,0x05,0x00,0x00,0x00}}, /* Version */
225 { 0x3B06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x04,0x00,0x00}}, /* Identifications reference */
226 { 0x3B03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x01,0x00,0x00}}, /* Content Storage reference */
227 { 0x3B09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x03,0x00,0x00,0x00,0x00}}, /* Operational Pattern UL */
228 { 0x3B0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x10,0x02,0x01,0x00,0x00}}, /* Essence Containers UL batch */
229 { 0x3B0B, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x10,0x02,0x02,0x00,0x00}}, /* DM Schemes UL batch */
231 { 0x3C09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x01,0x00,0x00,0x00}}, /* This Generation UID */
232 { 0x3C01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x02,0x01,0x00,0x00}}, /* Company Name */
233 { 0x3C02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x03,0x01,0x00,0x00}}, /* Product Name */
234 { 0x3C04, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x05,0x01,0x00,0x00}}, /* Version String */
235 { 0x3C05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x07,0x00,0x00,0x00}}, /* Product ID */
236 { 0x3C06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x03,0x00,0x00}}, /* Modification Date */
238 { 0x1901, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x05,0x01,0x00,0x00}}, /* Package strong reference batch */
239 { 0x1902, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x05,0x02,0x00,0x00}}, /* Package strong reference batch */
240 // Essence Container Data
241 { 0x2701, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x06,0x01,0x00,0x00,0x00}}, /* Linked Package UID */
242 { 0x3F07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x01,0x03,0x04,0x04,0x00,0x00,0x00,0x00}}, /* BodySID */
244 { 0x4401, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x15,0x10,0x00,0x00,0x00,0x00}}, /* Package UID */
245 { 0x4405, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x01,0x03,0x00,0x00}}, /* Package Creation Date */
246 { 0x4404, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x05,0x00,0x00}}, /* Package Modified Date */
247 { 0x4403, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x05,0x00,0x00}}, /* Tracks Strong reference array */
248 { 0x4701, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x03,0x00,0x00}}, /* Descriptor */
250 { 0x4801, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x01,0x07,0x01,0x01,0x00,0x00,0x00,0x00}}, /* Track ID */
251 { 0x4804, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x01,0x04,0x01,0x03,0x00,0x00,0x00,0x00}}, /* Track Number */
252 { 0x4B01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x30,0x04,0x05,0x00,0x00,0x00,0x00}}, /* Edit Rate */
253 { 0x4B02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x03,0x01,0x03,0x00,0x00}}, /* Origin */
254 { 0x4803, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x04,0x00,0x00}}, /* Sequence reference */
256 { 0x0201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x07,0x01,0x00,0x00,0x00,0x00,0x00}}, /* Data Definition UL */
257 { 0x0202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x02,0x01,0x01,0x03,0x00,0x00}}, /* Duration */
258 { 0x1001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x09,0x00,0x00}}, /* Structural Components reference array */
260 { 0x1201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x03,0x01,0x04,0x00,0x00}}, /* Start position */
261 { 0x1101, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x03,0x01,0x00,0x00,0x00}}, /* SourcePackageID */
262 { 0x1102, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x03,0x02,0x00,0x00,0x00}}, /* SourceTrackID */
263 // Timecode Component
264 { 0x1501, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x03,0x01,0x05,0x00,0x00}}, /* Start Time Code */
265 { 0x1502, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x04,0x01,0x01,0x02,0x06,0x00,0x00}}, /* Rounded Time Code Base */
266 { 0x1503, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x04,0x01,0x01,0x05,0x00,0x00,0x00}}, /* Drop Frame */
268 { 0x3F01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x06,0x01,0x01,0x04,0x06,0x0B,0x00,0x00}}, /* Sub Descriptors reference array */
269 { 0x3006, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x06,0x01,0x01,0x03,0x05,0x00,0x00,0x00}}, /* Linked Track ID */
270 { 0x3001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x06,0x01,0x01,0x00,0x00,0x00,0x00}}, /* SampleRate */
271 { 0x3004, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x01,0x02,0x00,0x00}}, /* Essence Container */
272 // Generic Picture Essence Descriptor
273 { 0x320C, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x03,0x01,0x04,0x00,0x00,0x00}}, /* Frame Layout */
274 { 0x320D, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x03,0x02,0x05,0x00,0x00,0x00}}, /* Video Line Map */
275 { 0x3203, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x02,0x02,0x00,0x00,0x00}}, /* Stored Width */
276 { 0x3202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x02,0x01,0x00,0x00,0x00}}, /* Stored Height */
277 { 0x3209, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0C,0x00,0x00,0x00}}, /* Display Width */
278 { 0x3208, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0B,0x00,0x00,0x00}}, /* Display Height */
279 { 0x320E, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x01,0x01,0x01,0x00,0x00,0x00}}, /* Aspect Ratio */
280 { 0x3201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x06,0x01,0x00,0x00,0x00,0x00}}, /* Picture Essence Coding */
281 // CDCI Picture Essence Descriptor
282 { 0x3301, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x05,0x03,0x0A,0x00,0x00,0x00}}, /* Component Depth */
283 { 0x3302, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x05,0x00,0x00,0x00}}, /* Horizontal Subsampling */
284 // Generic Sound Essence Descriptor
285 { 0x3D02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x02,0x03,0x01,0x04,0x00,0x00,0x00}}, /* Locked/Unlocked */
286 { 0x3D03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x01,0x01,0x01,0x00,0x00}}, /* Audio sampling rate */
287 { 0x3D07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x01,0x01,0x04,0x00,0x00,0x00}}, /* ChannelCount */
288 { 0x3D01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x02,0x03,0x03,0x04,0x00,0x00,0x00}}, /* Quantization bits */
289 { 0x3D06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x02,0x04,0x02,0x00,0x00,0x00,0x00}}, /* Sound Essence Compression */
290 // Index Table Segment
291 { 0x3F0B, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x05,0x30,0x04,0x06,0x00,0x00,0x00,0x00}}, /* Index Edit Rate */
292 { 0x3F0C, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x07,0x02,0x01,0x03,0x01,0x0A,0x00,0x00}}, /* Index Start Position */
293 { 0x3F0D, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x07,0x02,0x02,0x01,0x01,0x02,0x00,0x00}}, /* Index Duration */
294 { 0x3F05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x06,0x02,0x01,0x00,0x00,0x00,0x00}}, /* Edit Unit Byte Count */
295 { 0x3F06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x01,0x03,0x04,0x05,0x00,0x00,0x00,0x00}}, /* IndexSID */
296 { 0x3F08, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x04,0x04,0x01,0x01,0x00,0x00,0x00}}, /* Slice Count */
297 { 0x3F09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x04,0x04,0x01,0x06,0x00,0x00,0x00}}, /* Delta Entry Array */
298 { 0x3F0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x04,0x04,0x02,0x05,0x00,0x00,0x00}}, /* Index Entry Array */
299 // MPEG video Descriptor
300 { 0x8000, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x0B,0x00,0x00}}, /* BitRate */
301 // Wave Audio Essence Descriptor
302 { 0x3D09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x03,0x05,0x00,0x00,0x00}}, /* Average Bytes Per Second */
303 { 0x3D0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x02,0x01,0x00,0x00,0x00}}, /* Block Align */
306 static void mxf_write_uuid(ByteIOContext
*pb
, enum MXFMetadataSetType type
, int value
)
308 put_buffer(pb
, uuid_base
, 12);
313 static void mxf_write_umid(AVFormatContext
*s
, int type
)
315 MXFContext
*mxf
= s
->priv_data
;
316 put_buffer(s
->pb
, umid_ul
, 13);
317 put_be24(s
->pb
, mxf
->instance_number
);
318 put_buffer(s
->pb
, mxf
->umid
, 15);
319 put_byte(s
->pb
, type
);
322 static void mxf_write_refs_count(ByteIOContext
*pb
, int ref_count
)
324 put_be32(pb
, ref_count
);
328 static int klv_ber_length(uint64_t len
)
333 return (av_log2(len
) >> 3) + 2;
336 static int klv_encode_ber_length(ByteIOContext
*pb
, uint64_t len
)
338 // Determine the best BER size
346 size
= (av_log2(len
) >> 3) + 1;
349 put_byte(pb
, 0x80 + size
);
352 put_byte(pb
, len
>> 8 * size
& 0xff);
357 static void klv_encode_ber4_length(ByteIOContext
*pb
, int len
)
359 put_byte(pb
, 0x80 + 3);
364 * Get essence container ul index
366 static int mxf_get_essence_container_ul_index(enum CodecID id
)
369 for (i
= 0; mxf_essence_mappings
[i
].id
; i
++)
370 if (mxf_essence_mappings
[i
].id
== id
)
371 return mxf_essence_mappings
[i
].index
;
375 static void mxf_write_primer_pack(AVFormatContext
*s
)
377 ByteIOContext
*pb
= s
->pb
;
378 int local_tag_number
, i
= 0;
380 local_tag_number
= FF_ARRAY_ELEMS(mxf_local_tag_batch
);
382 put_buffer(pb
, primer_pack_key
, 16);
383 klv_encode_ber_length(pb
, local_tag_number
* 18 + 8);
385 put_be32(pb
, local_tag_number
); // local_tag num
386 put_be32(pb
, 18); // item size, always 18 according to the specs
388 for (i
= 0; i
< local_tag_number
; i
++) {
389 put_be16(pb
, mxf_local_tag_batch
[i
].local_tag
);
390 put_buffer(pb
, mxf_local_tag_batch
[i
].uid
, 16);
394 static void mxf_write_local_tag(ByteIOContext
*pb
, int size
, int tag
)
400 static void mxf_write_metadata_key(ByteIOContext
*pb
, unsigned int value
)
402 put_buffer(pb
, header_metadata_key
, 13);
406 static void mxf_free(AVFormatContext
*s
)
410 for (i
= 0; i
< s
->nb_streams
; i
++) {
411 AVStream
*st
= s
->streams
[i
];
412 av_freep(&st
->priv_data
);
416 static const MXFCodecUL
*mxf_get_data_definition_ul(int type
)
418 const MXFCodecUL
*uls
= ff_mxf_data_definition_uls
;
419 while (uls
->uid
[0]) {
427 static void mxf_write_essence_container_refs(AVFormatContext
*s
)
429 MXFContext
*c
= s
->priv_data
;
430 ByteIOContext
*pb
= s
->pb
;
433 mxf_write_refs_count(pb
, c
->essence_container_count
);
434 av_log(s
,AV_LOG_DEBUG
, "essence container count:%d\n", c
->essence_container_count
);
435 for (i
= 0; i
< c
->essence_container_count
; i
++) {
436 MXFStreamContext
*sc
= s
->streams
[i
]->priv_data
;
437 put_buffer(pb
, mxf_essence_container_uls
[sc
->index
].container_ul
, 16);
441 static void mxf_write_preface(AVFormatContext
*s
)
443 MXFContext
*mxf
= s
->priv_data
;
444 ByteIOContext
*pb
= s
->pb
;
446 mxf_write_metadata_key(pb
, 0x012f00);
447 PRINT_KEY(s
, "preface key", pb
->buf_ptr
- 16);
448 klv_encode_ber_length(pb
, 130 + 16 * mxf
->essence_container_count
);
450 // write preface set uid
451 mxf_write_local_tag(pb
, 16, 0x3C0A);
452 mxf_write_uuid(pb
, Preface
, 0);
453 PRINT_KEY(s
, "preface uid", pb
->buf_ptr
- 16);
455 // last modified date
456 mxf_write_local_tag(pb
, 8, 0x3B02);
457 put_be64(pb
, mxf
->timestamp
);
460 mxf_write_local_tag(pb
, 2, 0x3B05);
461 put_be16(pb
, 258); // v1.2
463 // write identification_refs
464 mxf_write_local_tag(pb
, 16 + 8, 0x3B06);
465 mxf_write_refs_count(pb
, 1);
466 mxf_write_uuid(pb
, Identification
, 0);
468 // write content_storage_refs
469 mxf_write_local_tag(pb
, 16, 0x3B03);
470 mxf_write_uuid(pb
, ContentStorage
, 0);
472 // operational pattern
473 mxf_write_local_tag(pb
, 16, 0x3B09);
474 put_buffer(pb
, op1a_ul
, 16);
476 // write essence_container_refs
477 mxf_write_local_tag(pb
, 8 + 16 * mxf
->essence_container_count
, 0x3B0A);
478 mxf_write_essence_container_refs(s
);
480 // write dm_scheme_refs
481 mxf_write_local_tag(pb
, 8, 0x3B0B);
486 * Write a local tag containing an ascii string as utf-16
488 static void mxf_write_local_tag_utf16(ByteIOContext
*pb
, int tag
, const char *value
)
490 int i
, size
= strlen(value
);
491 mxf_write_local_tag(pb
, size
*2, tag
);
492 for (i
= 0; i
< size
; i
++)
493 put_be16(pb
, value
[i
]);
496 static void mxf_write_identification(AVFormatContext
*s
)
498 MXFContext
*mxf
= s
->priv_data
;
499 ByteIOContext
*pb
= s
->pb
;
500 const char *company
= "FFmpeg";
501 const char *product
= "OP1a Muxer";
505 mxf_write_metadata_key(pb
, 0x013000);
506 PRINT_KEY(s
, "identification key", pb
->buf_ptr
- 16);
508 version
= s
->streams
[0]->codec
->flags
& CODEC_FLAG_BITEXACT
?
509 "0.0.0" : AV_STRINGIFY(LIBAVFORMAT_VERSION
);
510 length
= 84 + (strlen(company
)+strlen(product
)+strlen(version
))*2; // utf-16
511 klv_encode_ber_length(pb
, length
);
514 mxf_write_local_tag(pb
, 16, 0x3C0A);
515 mxf_write_uuid(pb
, Identification
, 0);
516 PRINT_KEY(s
, "identification uid", pb
->buf_ptr
- 16);
518 // write generation uid
519 mxf_write_local_tag(pb
, 16, 0x3C09);
520 mxf_write_uuid(pb
, Identification
, 1);
522 mxf_write_local_tag_utf16(pb
, 0x3C01, company
); // Company Name
523 mxf_write_local_tag_utf16(pb
, 0x3C02, product
); // Product Name
524 mxf_write_local_tag_utf16(pb
, 0x3C04, version
); // Version String
527 mxf_write_local_tag(pb
, 16, 0x3C05);
528 mxf_write_uuid(pb
, Identification
, 2);
531 mxf_write_local_tag(pb
, 8, 0x3C06);
532 put_be64(pb
, mxf
->timestamp
);
535 static void mxf_write_content_storage(AVFormatContext
*s
)
537 ByteIOContext
*pb
= s
->pb
;
539 mxf_write_metadata_key(pb
, 0x011800);
540 PRINT_KEY(s
, "content storage key", pb
->buf_ptr
- 16);
541 klv_encode_ber_length(pb
, 92);
544 mxf_write_local_tag(pb
, 16, 0x3C0A);
545 mxf_write_uuid(pb
, ContentStorage
, 0);
546 PRINT_KEY(s
, "content storage uid", pb
->buf_ptr
- 16);
548 // write package reference
549 mxf_write_local_tag(pb
, 16 * 2 + 8, 0x1901);
550 mxf_write_refs_count(pb
, 2);
551 mxf_write_uuid(pb
, MaterialPackage
, 0);
552 mxf_write_uuid(pb
, SourcePackage
, 0);
554 // write essence container data
555 mxf_write_local_tag(pb
, 8 + 16, 0x1902);
556 mxf_write_refs_count(pb
, 1);
557 mxf_write_uuid(pb
, EssenceContainerData
, 0);
560 static void mxf_write_track(AVFormatContext
*s
, AVStream
*st
, enum MXFMetadataSetType type
)
562 MXFContext
*mxf
= s
->priv_data
;
563 ByteIOContext
*pb
= s
->pb
;
564 MXFStreamContext
*sc
= st
->priv_data
;
566 mxf_write_metadata_key(pb
, 0x013b00);
567 PRINT_KEY(s
, "track key", pb
->buf_ptr
- 16);
568 klv_encode_ber_length(pb
, 80);
571 mxf_write_local_tag(pb
, 16, 0x3C0A);
572 mxf_write_uuid(pb
, type
== MaterialPackage
? Track
: Track
+ TypeBottom
, st
->index
);
573 PRINT_KEY(s
, "track uid", pb
->buf_ptr
- 16);
576 mxf_write_local_tag(pb
, 4, 0x4801);
577 put_be32(pb
, st
->index
+2);
579 // write track number
580 mxf_write_local_tag(pb
, 4, 0x4804);
581 if (type
== MaterialPackage
)
582 put_be32(pb
, 0); // track number of material package is 0
584 put_buffer(pb
, sc
->track_essence_element_key
+ 12, 4);
586 mxf_write_local_tag(pb
, 8, 0x4B01);
587 put_be32(pb
, mxf
->time_base
.den
);
588 put_be32(pb
, mxf
->time_base
.num
);
591 mxf_write_local_tag(pb
, 8, 0x4B02);
594 // write sequence refs
595 mxf_write_local_tag(pb
, 16, 0x4803);
596 mxf_write_uuid(pb
, type
== MaterialPackage
? Sequence
: Sequence
+ TypeBottom
, st
->index
);
599 static const uint8_t smpte_12m_timecode_track_data_ul
[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x01,0x03,0x02,0x01,0x01,0x00,0x00,0x00 };
601 static void mxf_write_common_fields(AVFormatContext
*s
, AVStream
*st
)
603 MXFContext
*mxf
= s
->priv_data
;
604 ByteIOContext
*pb
= s
->pb
;
606 // find data define uls
607 mxf_write_local_tag(pb
, 16, 0x0201);
608 if (st
== mxf
->timecode_track
)
609 put_buffer(pb
, smpte_12m_timecode_track_data_ul
, 16);
611 const MXFCodecUL
*data_def_ul
= mxf_get_data_definition_ul(st
->codec
->codec_type
);
612 put_buffer(pb
, data_def_ul
->uid
, 16);
616 mxf_write_local_tag(pb
, 8, 0x0202);
617 put_be64(pb
, mxf
->duration
);
620 static void mxf_write_sequence(AVFormatContext
*s
, AVStream
*st
, enum MXFMetadataSetType type
)
622 MXFContext
*mxf
= s
->priv_data
;
623 ByteIOContext
*pb
= s
->pb
;
624 enum MXFMetadataSetType component
;
626 mxf_write_metadata_key(pb
, 0x010f00);
627 PRINT_KEY(s
, "sequence key", pb
->buf_ptr
- 16);
628 klv_encode_ber_length(pb
, 80);
630 mxf_write_local_tag(pb
, 16, 0x3C0A);
631 mxf_write_uuid(pb
, type
== MaterialPackage
? Sequence
: Sequence
+ TypeBottom
, st
->index
);
633 PRINT_KEY(s
, "sequence uid", pb
->buf_ptr
- 16);
634 mxf_write_common_fields(s
, st
);
636 // write structural component
637 mxf_write_local_tag(pb
, 16 + 8, 0x1001);
638 mxf_write_refs_count(pb
, 1);
639 if (st
== mxf
->timecode_track
)
640 component
= TimecodeComponent
;
642 component
= SourceClip
;
643 if (type
== SourcePackage
)
644 component
+= TypeBottom
;
645 mxf_write_uuid(pb
, component
, st
->index
);
648 static void mxf_write_timecode_component(AVFormatContext
*s
, AVStream
*st
, enum MXFMetadataSetType type
)
650 MXFContext
*mxf
= s
->priv_data
;
651 ByteIOContext
*pb
= s
->pb
;
653 mxf_write_metadata_key(pb
, 0x011400);
654 klv_encode_ber_length(pb
, 75);
657 mxf_write_local_tag(pb
, 16, 0x3C0A);
658 mxf_write_uuid(pb
, type
== MaterialPackage
? TimecodeComponent
:
659 TimecodeComponent
+ TypeBottom
, st
->index
);
661 mxf_write_common_fields(s
, st
);
664 mxf_write_local_tag(pb
, 8, 0x1501);
665 put_be64(pb
, mxf
->timecode_start
);
667 // Rounded Time Code Base
668 mxf_write_local_tag(pb
, 2, 0x1502);
669 put_be16(pb
, mxf
->timecode_base
);
672 mxf_write_local_tag(pb
, 1, 0x1503);
673 put_byte(pb
, mxf
->timecode_drop_frame
);
676 static void mxf_write_structural_component(AVFormatContext
*s
, AVStream
*st
, enum MXFMetadataSetType type
)
678 ByteIOContext
*pb
= s
->pb
;
681 mxf_write_metadata_key(pb
, 0x011100);
682 PRINT_KEY(s
, "sturctural component key", pb
->buf_ptr
- 16);
683 klv_encode_ber_length(pb
, 108);
686 mxf_write_local_tag(pb
, 16, 0x3C0A);
687 mxf_write_uuid(pb
, type
== MaterialPackage
? SourceClip
: SourceClip
+ TypeBottom
, st
->index
);
689 PRINT_KEY(s
, "structural component uid", pb
->buf_ptr
- 16);
690 mxf_write_common_fields(s
, st
);
692 // write start_position
693 mxf_write_local_tag(pb
, 8, 0x1201);
696 // write source package uid, end of the reference
697 mxf_write_local_tag(pb
, 32, 0x1101);
698 if (type
== SourcePackage
) {
699 for (i
= 0; i
< 4; i
++)
702 mxf_write_umid(s
, 1);
704 // write source track id
705 mxf_write_local_tag(pb
, 4, 0x1102);
706 if (type
== SourcePackage
)
709 put_be32(pb
, st
->index
+2);
712 static void mxf_write_multi_descriptor(AVFormatContext
*s
)
714 MXFContext
*mxf
= s
->priv_data
;
715 ByteIOContext
*pb
= s
->pb
;
719 mxf_write_metadata_key(pb
, 0x014400);
720 PRINT_KEY(s
, "multiple descriptor key", pb
->buf_ptr
- 16);
721 klv_encode_ber_length(pb
, 64 + 16 * s
->nb_streams
);
723 mxf_write_local_tag(pb
, 16, 0x3C0A);
724 mxf_write_uuid(pb
, MultipleDescriptor
, 0);
725 PRINT_KEY(s
, "multi_desc uid", pb
->buf_ptr
- 16);
728 mxf_write_local_tag(pb
, 8, 0x3001);
729 put_be32(pb
, mxf
->time_base
.den
);
730 put_be32(pb
, mxf
->time_base
.num
);
732 // write essence container ul
733 mxf_write_local_tag(pb
, 16, 0x3004);
734 if (mxf
->essence_container_count
> 1)
735 ul
= multiple_desc_ul
;
737 MXFStreamContext
*sc
= s
->streams
[0]->priv_data
;
738 ul
= mxf_essence_container_uls
[sc
->index
].container_ul
;
740 put_buffer(pb
, ul
, 16);
742 // write sub descriptor refs
743 mxf_write_local_tag(pb
, s
->nb_streams
* 16 + 8, 0x3F01);
744 mxf_write_refs_count(pb
, s
->nb_streams
);
745 for (i
= 0; i
< s
->nb_streams
; i
++)
746 mxf_write_uuid(pb
, SubDescriptor
, i
);
749 static void mxf_write_generic_desc(AVFormatContext
*s
, AVStream
*st
, const UID key
, unsigned size
)
751 MXFContext
*mxf
= s
->priv_data
;
752 MXFStreamContext
*sc
= st
->priv_data
;
753 ByteIOContext
*pb
= s
->pb
;
755 put_buffer(pb
, key
, 16);
756 klv_encode_ber_length(pb
, size
+20+8+12+20);
758 mxf_write_local_tag(pb
, 16, 0x3C0A);
759 mxf_write_uuid(pb
, SubDescriptor
, st
->index
);
761 mxf_write_local_tag(pb
, 4, 0x3006);
762 put_be32(pb
, st
->index
+2);
764 mxf_write_local_tag(pb
, 8, 0x3001);
765 put_be32(pb
, mxf
->time_base
.den
);
766 put_be32(pb
, mxf
->time_base
.num
);
768 mxf_write_local_tag(pb
, 16, 0x3004);
769 put_buffer(pb
, mxf_essence_container_uls
[sc
->index
].container_ul
, 16);
772 static const UID mxf_mpegvideo_descriptor_key
= { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 };
773 static const UID mxf_wav_descriptor_key
= { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 };
774 static const UID mxf_aes3_descriptor_key
= { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 };
775 static const UID mxf_cdci_descriptor_key
= { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x28,0x00 };
776 static const UID mxf_generic_sound_descriptor_key
= { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x42,0x00 };
778 static void mxf_write_cdci_common(AVFormatContext
*s
, AVStream
*st
, const UID key
, unsigned size
)
780 MXFStreamContext
*sc
= st
->priv_data
;
781 ByteIOContext
*pb
= s
->pb
;
782 int stored_height
= (st
->codec
->height
+15)/16*16;
786 mxf_write_generic_desc(s
, st
, key
, size
+8+8+8+8+8+8+5+16+sc
->interlaced
*4+12+20);
788 mxf_write_local_tag(pb
, 4, 0x3203);
789 put_be32(pb
, st
->codec
->width
);
791 mxf_write_local_tag(pb
, 4, 0x3202);
792 put_be32(pb
, stored_height
>>sc
->interlaced
);
794 mxf_write_local_tag(pb
, 4, 0x3209);
795 put_be32(pb
, st
->codec
->width
);
797 if (st
->codec
->height
== 608) // PAL + VBI
798 display_height
= 576;
799 else if (st
->codec
->height
== 512) // NTSC + VBI
800 display_height
= 486;
802 display_height
= st
->codec
->height
;
804 mxf_write_local_tag(pb
, 4, 0x3208);
805 put_be32(pb
, display_height
>>sc
->interlaced
);
808 mxf_write_local_tag(pb
, 4, 0x3301);
811 // horizontal subsampling
812 mxf_write_local_tag(pb
, 4, 0x3302);
816 mxf_write_local_tag(pb
, 1, 0x320C);
817 put_byte(pb
, sc
->interlaced
);
820 switch (st
->codec
->height
) {
821 case 576: f1
= 23; f2
= 336; break;
822 case 608: f1
= 7; f2
= 320; break;
823 case 480: f1
= 20; f2
= 283; break;
824 case 512: f1
= 7; f2
= 270; break;
825 case 720: f1
= 26; f2
= 0; break; // progressive
826 case 1080: f1
= 21; f2
= 584; break;
827 default: f1
= 0; f2
= 0; break;
830 if (!sc
->interlaced
) {
835 mxf_write_local_tag(pb
, 12+sc
->interlaced
*4, 0x320D);
836 put_be32(pb
, sc
->interlaced
? 2 : 1);
842 mxf_write_local_tag(pb
, 8, 0x320E);
843 put_be32(pb
, sc
->aspect_ratio
.num
);
844 put_be32(pb
, sc
->aspect_ratio
.den
);
846 mxf_write_local_tag(pb
, 16, 0x3201);
847 put_buffer(pb
, *sc
->codec_ul
, 16);
850 static void mxf_write_cdci_desc(AVFormatContext
*s
, AVStream
*st
)
852 mxf_write_cdci_common(s
, st
, mxf_cdci_descriptor_key
, 0);
855 static void mxf_write_mpegvideo_desc(AVFormatContext
*s
, AVStream
*st
)
857 ByteIOContext
*pb
= s
->pb
;
859 mxf_write_cdci_common(s
, st
, mxf_mpegvideo_descriptor_key
, 8);
862 mxf_write_local_tag(pb
, 4, 0x8000);
863 put_be32(pb
, st
->codec
->bit_rate
);
866 static void mxf_write_generic_sound_common(AVFormatContext
*s
, AVStream
*st
, const UID key
, unsigned size
)
868 ByteIOContext
*pb
= s
->pb
;
870 mxf_write_generic_desc(s
, st
, key
, size
+5+12+8+8);
873 mxf_write_local_tag(pb
, 1, 0x3D02);
876 // write audio sampling rate
877 mxf_write_local_tag(pb
, 8, 0x3D03);
878 put_be32(pb
, st
->codec
->sample_rate
);
881 mxf_write_local_tag(pb
, 4, 0x3D07);
882 put_be32(pb
, st
->codec
->channels
);
884 mxf_write_local_tag(pb
, 4, 0x3D01);
885 put_be32(pb
, av_get_bits_per_sample(st
->codec
->codec_id
));
888 static void mxf_write_wav_common(AVFormatContext
*s
, AVStream
*st
, const UID key
, unsigned size
)
890 ByteIOContext
*pb
= s
->pb
;
892 mxf_write_generic_sound_common(s
, st
, key
, size
+6+8);
894 mxf_write_local_tag(pb
, 2, 0x3D0A);
895 put_be16(pb
, st
->codec
->block_align
);
898 mxf_write_local_tag(pb
, 4, 0x3D09);
899 put_be32(pb
, st
->codec
->block_align
*st
->codec
->sample_rate
);
902 static void mxf_write_wav_desc(AVFormatContext
*s
, AVStream
*st
)
904 mxf_write_wav_common(s
, st
, mxf_wav_descriptor_key
, 0);
907 static void mxf_write_aes3_desc(AVFormatContext
*s
, AVStream
*st
)
909 mxf_write_wav_common(s
, st
, mxf_aes3_descriptor_key
, 0);
912 static void mxf_write_generic_sound_desc(AVFormatContext
*s
, AVStream
*st
)
914 mxf_write_generic_sound_common(s
, st
, mxf_generic_sound_descriptor_key
, 0);
917 static void mxf_write_package(AVFormatContext
*s
, enum MXFMetadataSetType type
)
919 MXFContext
*mxf
= s
->priv_data
;
920 ByteIOContext
*pb
= s
->pb
;
921 int i
, track_count
= s
->nb_streams
+1;
923 if (type
== MaterialPackage
) {
924 mxf_write_metadata_key(pb
, 0x013600);
925 PRINT_KEY(s
, "Material Package key", pb
->buf_ptr
- 16);
926 klv_encode_ber_length(pb
, 92 + 16*track_count
);
928 mxf_write_metadata_key(pb
, 0x013700);
929 PRINT_KEY(s
, "Source Package key", pb
->buf_ptr
- 16);
930 klv_encode_ber_length(pb
, 112 + 16*track_count
); // 20 bytes length for descriptor reference
934 mxf_write_local_tag(pb
, 16, 0x3C0A);
935 mxf_write_uuid(pb
, type
, 0);
936 av_log(s
,AV_LOG_DEBUG
, "package type:%d\n", type
);
937 PRINT_KEY(s
, "package uid", pb
->buf_ptr
- 16);
939 // write package umid
940 mxf_write_local_tag(pb
, 32, 0x4401);
941 mxf_write_umid(s
, type
== SourcePackage
);
942 PRINT_KEY(s
, "package umid second part", pb
->buf_ptr
- 16);
944 // package creation date
945 mxf_write_local_tag(pb
, 8, 0x4405);
946 put_be64(pb
, mxf
->timestamp
);
948 // package modified date
949 mxf_write_local_tag(pb
, 8, 0x4404);
950 put_be64(pb
, mxf
->timestamp
);
953 mxf_write_local_tag(pb
, track_count
*16 + 8, 0x4403);
954 mxf_write_refs_count(pb
, track_count
);
955 mxf_write_uuid(pb
, type
== MaterialPackage
? Track
:
956 Track
+ TypeBottom
, -1); // timecode track
957 for (i
= 0; i
< s
->nb_streams
; i
++)
958 mxf_write_uuid(pb
, type
== MaterialPackage
? Track
: Track
+ TypeBottom
, i
);
960 // write multiple descriptor reference
961 if (type
== SourcePackage
) {
962 mxf_write_local_tag(pb
, 16, 0x4701);
963 if (s
->nb_streams
> 1) {
964 mxf_write_uuid(pb
, MultipleDescriptor
, 0);
965 mxf_write_multi_descriptor(s
);
967 mxf_write_uuid(pb
, SubDescriptor
, 0);
970 // write timecode track
971 mxf_write_track(s
, mxf
->timecode_track
, type
);
972 mxf_write_sequence(s
, mxf
->timecode_track
, type
);
973 mxf_write_timecode_component(s
, mxf
->timecode_track
, type
);
975 for (i
= 0; i
< s
->nb_streams
; i
++) {
976 AVStream
*st
= s
->streams
[i
];
977 mxf_write_track(s
, st
, type
);
978 mxf_write_sequence(s
, st
, type
);
979 mxf_write_structural_component(s
, st
, type
);
981 if (type
== SourcePackage
) {
982 MXFStreamContext
*sc
= st
->priv_data
;
983 mxf_essence_container_uls
[sc
->index
].write_desc(s
, st
);
988 static int mxf_write_essence_container_data(AVFormatContext
*s
)
990 ByteIOContext
*pb
= s
->pb
;
992 mxf_write_metadata_key(pb
, 0x012300);
993 klv_encode_ber_length(pb
, 72);
995 mxf_write_local_tag(pb
, 16, 0x3C0A); // Instance UID
996 mxf_write_uuid(pb
, EssenceContainerData
, 0);
998 mxf_write_local_tag(pb
, 32, 0x2701); // Linked Package UID
999 mxf_write_umid(s
, 1);
1001 mxf_write_local_tag(pb
, 4, 0x3F07); // BodySID
1004 mxf_write_local_tag(pb
, 4, 0x3F06); // IndexSID
1010 static int mxf_write_header_metadata_sets(AVFormatContext
*s
)
1012 mxf_write_preface(s
);
1013 mxf_write_identification(s
);
1014 mxf_write_content_storage(s
);
1015 mxf_write_package(s
, MaterialPackage
);
1016 mxf_write_package(s
, SourcePackage
);
1017 mxf_write_essence_container_data(s
);
1021 static unsigned klv_fill_size(uint64_t size
)
1023 unsigned pad
= KAG_SIZE
- (size
& (KAG_SIZE
-1));
1024 if (pad
< 20) // smallest fill item possible
1025 return pad
+ KAG_SIZE
;
1027 return pad
& (KAG_SIZE
-1);
1030 static void mxf_write_index_table_segment(AVFormatContext
*s
)
1032 MXFContext
*mxf
= s
->priv_data
;
1033 ByteIOContext
*pb
= s
->pb
;
1035 int temporal_reordering
= 0;
1036 int key_index
= mxf
->last_key_index
;
1038 av_log(s
, AV_LOG_DEBUG
, "edit units count %d\n", mxf
->edit_units_count
);
1040 if (!mxf
->edit_units_count
&& !mxf
->edit_unit_byte_count
)
1043 put_buffer(pb
, index_table_segment_key
, 16);
1045 if (mxf
->edit_unit_byte_count
) {
1046 klv_encode_ber_length(pb
, 80);
1048 klv_encode_ber_length(pb
, 85 + 12+(s
->nb_streams
+1)*6 +
1049 12+mxf
->edit_units_count
*(11+mxf
->slice_count
*4));
1053 mxf_write_local_tag(pb
, 16, 0x3C0A);
1054 mxf_write_uuid(pb
, IndexTableSegment
, 0);
1057 mxf_write_local_tag(pb
, 8, 0x3F0B);
1058 put_be32(pb
, mxf
->time_base
.den
);
1059 put_be32(pb
, mxf
->time_base
.num
);
1061 // index start position
1062 mxf_write_local_tag(pb
, 8, 0x3F0C);
1063 put_be64(pb
, mxf
->last_indexed_edit_unit
);
1066 mxf_write_local_tag(pb
, 8, 0x3F0D);
1067 put_be64(pb
, mxf
->edit_units_count
);
1069 // edit unit byte count
1070 mxf_write_local_tag(pb
, 4, 0x3F05);
1071 put_be32(pb
, mxf
->edit_unit_byte_count
);
1074 mxf_write_local_tag(pb
, 4, 0x3F06);
1078 mxf_write_local_tag(pb
, 4, 0x3F07);
1081 if (!mxf
->edit_unit_byte_count
) {
1082 // real slice count - 1
1083 mxf_write_local_tag(pb
, 1, 0x3F08);
1084 put_byte(pb
, mxf
->slice_count
);
1086 // delta entry array
1087 mxf_write_local_tag(pb
, 8 + (s
->nb_streams
+1)*6, 0x3F09);
1088 put_be32(pb
, s
->nb_streams
+1); // num of entries
1089 put_be32(pb
, 6); // size of one entry
1090 // write system item delta entry
1092 put_byte(pb
, 0); // slice entry
1093 put_be32(pb
, 0); // element delta
1094 for (i
= 0; i
< s
->nb_streams
; i
++) {
1095 AVStream
*st
= s
->streams
[i
];
1096 MXFStreamContext
*sc
= st
->priv_data
;
1097 put_byte(pb
, sc
->temporal_reordering
);
1098 if (sc
->temporal_reordering
)
1099 temporal_reordering
= 1;
1100 if (i
== 0) { // video track
1101 put_byte(pb
, 0); // slice number
1102 put_be32(pb
, KAG_SIZE
); // system item size including klv fill
1103 } else { // audio track
1104 unsigned audio_frame_size
= sc
->aic
.samples
[0]*sc
->aic
.sample_size
;
1105 audio_frame_size
+= klv_fill_size(audio_frame_size
);
1107 put_be32(pb
, (i
-1)*audio_frame_size
); // element delta
1111 mxf_write_local_tag(pb
, 8 + mxf
->edit_units_count
*(11+mxf
->slice_count
*4), 0x3F0A);
1112 put_be32(pb
, mxf
->edit_units_count
); // num of entries
1113 put_be32(pb
, 11+mxf
->slice_count
*4); // size of one entry
1114 for (i
= 0; i
< mxf
->edit_units_count
; i
++) {
1115 if (temporal_reordering
) {
1116 int temporal_offset
= 0;
1117 for (j
= i
+1; j
< mxf
->edit_units_count
; j
++) {
1119 if (mxf
->index_entries
[j
].flags
& 0x10) { // backward prediction
1120 // next is not b, so is reordered
1121 if (!(mxf
->index_entries
[i
+1].flags
& 0x10)) {
1122 if ((mxf
->index_entries
[i
].flags
& 0x11) == 0) // i frame
1123 temporal_offset
= 0;
1125 temporal_offset
= -temporal_offset
;
1130 put_byte(pb
, temporal_offset
);
1133 if (!(mxf
->index_entries
[i
].flags
& 0x33)) { // I frame
1134 mxf
->last_key_index
= key_index
;
1137 if (mxf
->index_entries
[i
].flags
& 0x10 && // backward prediction
1138 !(mxf
->index_entries
[key_index
].flags
& 0x80)) { // open gop
1139 put_byte(pb
, mxf
->last_key_index
- i
);
1141 put_byte(pb
, key_index
- i
); // key frame offset
1142 if ((mxf
->index_entries
[i
].flags
& 0x20) == 0x20) // only forward
1143 mxf
->last_key_index
= key_index
;
1145 put_byte(pb
, mxf
->index_entries
[i
].flags
);
1147 put_be64(pb
, mxf
->index_entries
[i
].offset
);
1148 if (s
->nb_streams
> 1)
1149 put_be32(pb
, mxf
->index_entries
[i
].slice_offset
);
1152 mxf
->last_key_index
= key_index
- mxf
->edit_units_count
;
1153 mxf
->last_indexed_edit_unit
+= mxf
->edit_units_count
;
1154 mxf
->edit_units_count
= 0;
1158 static void mxf_write_klv_fill(AVFormatContext
*s
)
1160 unsigned pad
= klv_fill_size(url_ftell(s
->pb
));
1162 put_buffer(s
->pb
, klv_fill_key
, 16);
1164 klv_encode_ber4_length(s
->pb
, pad
);
1167 assert(!(url_ftell(s
->pb
) & (KAG_SIZE
-1)));
1171 static void mxf_write_partition(AVFormatContext
*s
, int bodysid
,
1173 const uint8_t *key
, int write_metadata
)
1175 MXFContext
*mxf
= s
->priv_data
;
1176 ByteIOContext
*pb
= s
->pb
;
1177 int64_t header_byte_count_offset
;
1178 unsigned index_byte_count
= 0;
1179 uint64_t partition_offset
= url_ftell(pb
);
1181 if (!mxf
->edit_unit_byte_count
&& mxf
->edit_units_count
)
1182 index_byte_count
= 85 + 12+(s
->nb_streams
+1)*6 +
1183 12+mxf
->edit_units_count
*(11+mxf
->slice_count
*4);
1184 else if (mxf
->edit_unit_byte_count
&& indexsid
)
1185 index_byte_count
= 80;
1187 if (index_byte_count
) {
1188 // add encoded ber length
1189 index_byte_count
+= 16 + klv_ber_length(index_byte_count
);
1190 index_byte_count
+= klv_fill_size(index_byte_count
);
1193 if (!memcmp(key
, body_partition_key
, 16)) {
1194 mxf
->body_partition_offset
=
1195 av_realloc(mxf
->body_partition_offset
,
1196 (mxf
->body_partitions_count
+1)*
1197 sizeof(*mxf
->body_partition_offset
));
1198 mxf
->body_partition_offset
[mxf
->body_partitions_count
++] = partition_offset
;
1202 put_buffer(pb
, key
, 16);
1203 klv_encode_ber_length(pb
, 88 + 16 * mxf
->essence_container_count
);
1205 // write partition value
1206 put_be16(pb
, 1); // majorVersion
1207 put_be16(pb
, 2); // minorVersion
1208 put_be32(pb
, KAG_SIZE
); // KAGSize
1210 put_be64(pb
, partition_offset
); // ThisPartition
1212 if (!memcmp(key
, body_partition_key
, 16) && mxf
->body_partitions_count
> 1)
1213 put_be64(pb
, mxf
->body_partition_offset
[mxf
->body_partitions_count
-2]); // PreviousPartition
1214 else if (!memcmp(key
, footer_partition_key
, 16) && mxf
->body_partitions_count
)
1215 put_be64(pb
, mxf
->body_partition_offset
[mxf
->body_partitions_count
-1]); // PreviousPartition
1219 put_be64(pb
, mxf
->footer_partition_offset
); // footerPartition
1222 header_byte_count_offset
= url_ftell(pb
);
1223 put_be64(pb
, 0); // headerByteCount, update later
1226 put_be64(pb
, index_byte_count
); // indexByteCount
1227 put_be32(pb
, index_byte_count
? indexsid
: 0); // indexSID
1230 if (bodysid
&& mxf
->edit_units_count
&& mxf
->body_partitions_count
) {
1231 put_be64(pb
, mxf
->body_offset
);
1235 put_be32(pb
, bodysid
); // bodySID
1237 // operational pattern
1238 put_buffer(pb
, op1a_ul
, 16);
1240 // essence container
1241 mxf_write_essence_container_refs(s
);
1243 if (write_metadata
) {
1244 // mark the start of the headermetadata and calculate metadata size
1246 unsigned header_byte_count
;
1248 mxf_write_klv_fill(s
);
1249 start
= url_ftell(s
->pb
);
1250 mxf_write_primer_pack(s
);
1251 mxf_write_header_metadata_sets(s
);
1252 pos
= url_ftell(s
->pb
);
1253 header_byte_count
= pos
- start
+ klv_fill_size(pos
);
1255 // update header_byte_count
1256 url_fseek(pb
, header_byte_count_offset
, SEEK_SET
);
1257 put_be64(pb
, header_byte_count
);
1258 url_fseek(pb
, pos
, SEEK_SET
);
1261 put_flush_packet(pb
);
1264 static const UID mxf_mpeg2_codec_uls
[] = {
1265 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x10,0x00 }, // MP-ML I-Frame
1266 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x11,0x00 }, // MP-ML Long GOP
1267 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x02,0x00 }, // 422P-ML I-Frame
1268 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x03,0x00 }, // 422P-ML Long GOP
1269 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x02,0x00 }, // MP-HL I-Frame
1270 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x03,0x00 }, // MP-HL Long GOP
1271 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x02,0x00 }, // 422P-HL I-Frame
1272 { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x03,0x00 }, // 422P-HL Long GOP
1275 static const UID
*mxf_get_mpeg2_codec_ul(AVCodecContext
*avctx
)
1277 if (avctx
->profile
== 4) { // Main
1278 if (avctx
->level
== 8) // Main
1279 return avctx
->gop_size
?
1280 &mxf_mpeg2_codec_uls
[1] :
1281 &mxf_mpeg2_codec_uls
[0];
1282 else if (avctx
->level
== 4) // High
1283 return avctx
->gop_size
?
1284 &mxf_mpeg2_codec_uls
[5] :
1285 &mxf_mpeg2_codec_uls
[4];
1286 } else if (avctx
->profile
== 0) { // 422
1287 if (avctx
->level
== 5) // Main
1288 return avctx
->gop_size
?
1289 &mxf_mpeg2_codec_uls
[3] :
1290 &mxf_mpeg2_codec_uls
[2];
1291 else if (avctx
->level
== 2) // High
1292 return avctx
->gop_size
?
1293 &mxf_mpeg2_codec_uls
[7] :
1294 &mxf_mpeg2_codec_uls
[6];
1299 static int mxf_parse_mpeg2_frame(AVFormatContext
*s
, AVStream
*st
, AVPacket
*pkt
, int *flags
)
1301 MXFStreamContext
*sc
= st
->priv_data
;
1302 MXFContext
*mxf
= s
->priv_data
;
1308 for(i
= 0; i
< pkt
->size
- 4; i
++) {
1309 c
= (c
<<8) + pkt
->data
[i
];
1311 if ((pkt
->data
[i
+1] & 0xf0) == 0x10) { // seq ext
1312 st
->codec
->profile
= pkt
->data
[i
+1] & 0x07;
1313 st
->codec
->level
= pkt
->data
[i
+2] >> 4;
1314 } else if (i
+ 5 < pkt
->size
&& (pkt
->data
[i
+1] & 0xf0) == 0x80) { // pict coding ext
1315 sc
->interlaced
= !(pkt
->data
[i
+5] & 0x80); // progressive frame
1318 } else if (c
== 0x1b8) { // gop
1319 if (pkt
->data
[i
+4]>>6 & 0x01) // closed
1320 *flags
|= 0x80; // random access
1321 if (!mxf
->header_written
) {
1322 unsigned hours
= (pkt
->data
[i
+1]>>2) & 0x1f;
1323 unsigned minutes
= ((pkt
->data
[i
+1] & 0x03) << 4) | (pkt
->data
[i
+2]>>4);
1324 unsigned seconds
= ((pkt
->data
[i
+2] & 0x07) << 3) | (pkt
->data
[i
+3]>>5);
1325 unsigned frames
= ((pkt
->data
[i
+3] & 0x1f) << 1) | (pkt
->data
[i
+4]>>7);
1326 mxf
->timecode_drop_frame
= !!(pkt
->data
[i
+1] & 0x80);
1327 mxf
->timecode_start
= (hours
*3600 + minutes
*60 + seconds
) *
1328 mxf
->timecode_base
+ frames
;
1329 if (mxf
->timecode_drop_frame
) {
1330 unsigned tminutes
= 60 * hours
+ minutes
;
1331 mxf
->timecode_start
-= 2 * (tminutes
- tminutes
/ 10);
1333 av_log(s
, AV_LOG_DEBUG
, "frame %d %d:%d:%d%c%d\n", mxf
->timecode_start
,
1334 hours
, minutes
, seconds
, mxf
->timecode_drop_frame
? ';':':', frames
);
1336 } else if (c
== 0x1b3) { // seq
1338 switch ((pkt
->data
[i
+4]>>4) & 0xf) {
1339 case 2: sc
->aspect_ratio
= (AVRational
){ 4, 3}; break;
1340 case 3: sc
->aspect_ratio
= (AVRational
){ 16, 9}; break;
1341 case 4: sc
->aspect_ratio
= (AVRational
){221,100}; break;
1343 av_reduce(&sc
->aspect_ratio
.num
, &sc
->aspect_ratio
.den
,
1344 st
->codec
->width
, st
->codec
->height
, 1024*1024);
1346 } else if (c
== 0x100) { // pic
1347 int pict_type
= (pkt
->data
[i
+2]>>3) & 0x07;
1348 if (pict_type
== 2) { // P frame
1350 st
->codec
->gop_size
= 1;
1351 } else if (pict_type
== 3) { // B frame
1353 sc
->temporal_reordering
= -1;
1354 } else if (!pict_type
) {
1355 av_log(s
, AV_LOG_ERROR
, "error parsing mpeg2 frame\n");
1360 if (s
->oformat
!= &mxf_d10_muxer
)
1361 sc
->codec_ul
= mxf_get_mpeg2_codec_ul(st
->codec
);
1362 return !!sc
->codec_ul
;
1365 static uint64_t mxf_parse_timestamp(time_t timestamp
)
1367 struct tm
*time
= gmtime(×tamp
);
1368 return (uint64_t)(time
->tm_year
+1900) << 48 |
1369 (uint64_t)(time
->tm_mon
+1) << 40 |
1370 (uint64_t) time
->tm_mday
<< 32 |
1371 time
->tm_hour
<< 24 |
1372 time
->tm_min
<< 16 |
1376 static void mxf_gen_umid(AVFormatContext
*s
)
1378 MXFContext
*mxf
= s
->priv_data
;
1379 uint32_t seed
= ff_random_get_seed();
1380 uint64_t umid
= seed
+ 0x5294713400000000LL
;
1382 AV_WB64(mxf
->umid
, umid
);
1383 AV_WB64(mxf
->umid
+8, umid
>>8);
1385 mxf
->instance_number
= seed
;
1388 static int mxf_write_header(AVFormatContext
*s
)
1390 MXFContext
*mxf
= s
->priv_data
;
1392 uint8_t present
[FF_ARRAY_ELEMS(mxf_essence_container_uls
)] = {0};
1393 const int *samples_per_frame
= NULL
;
1398 for (i
= 0; i
< s
->nb_streams
; i
++) {
1399 AVStream
*st
= s
->streams
[i
];
1400 MXFStreamContext
*sc
= av_mallocz(sizeof(*sc
));
1402 return AVERROR(ENOMEM
);
1405 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
1407 av_log(s
, AV_LOG_ERROR
, "video stream must be first track\n");
1410 if (fabs(av_q2d(st
->codec
->time_base
) - 1/25.0) < 0.0001) {
1411 samples_per_frame
= PAL_samples_per_frame
;
1412 mxf
->time_base
= (AVRational
){ 1, 25 };
1413 mxf
->timecode_base
= 25;
1414 } else if (fabs(av_q2d(st
->codec
->time_base
) - 1001/30000.0) < 0.0001) {
1415 samples_per_frame
= NTSC_samples_per_frame
;
1416 mxf
->time_base
= (AVRational
){ 1001, 30000 };
1417 mxf
->timecode_base
= 30;
1419 av_log(s
, AV_LOG_ERROR
, "unsupported video frame rate\n");
1422 av_set_pts_info(st
, 64, mxf
->time_base
.num
, mxf
->time_base
.den
);
1423 if (s
->oformat
== &mxf_d10_muxer
) {
1424 if (st
->codec
->bit_rate
== 50000000)
1425 if (mxf
->time_base
.den
== 25) sc
->index
= 3;
1427 else if (st
->codec
->bit_rate
== 40000000)
1428 if (mxf
->time_base
.den
== 25) sc
->index
= 7;
1430 else if (st
->codec
->bit_rate
== 30000000)
1431 if (mxf
->time_base
.den
== 25) sc
->index
= 11;
1432 else sc
->index
= 13;
1434 av_log(s
, AV_LOG_ERROR
, "error MXF D-10 only support 30/40/50 mbit/s\n");
1438 mxf
->edit_unit_byte_count
= KAG_SIZE
; // system element
1439 mxf
->edit_unit_byte_count
+= 16 + 4 + (uint64_t)st
->codec
->bit_rate
*
1440 mxf
->time_base
.num
/ (8*mxf
->time_base
.den
);
1441 mxf
->edit_unit_byte_count
+= klv_fill_size(mxf
->edit_unit_byte_count
);
1442 mxf
->edit_unit_byte_count
+= 16 + 4 + 4 + samples_per_frame
[0]*8*4;
1443 mxf
->edit_unit_byte_count
+= klv_fill_size(mxf
->edit_unit_byte_count
);
1445 } else if (st
->codec
->codec_type
== CODEC_TYPE_AUDIO
) {
1446 if (st
->codec
->sample_rate
!= 48000) {
1447 av_log(s
, AV_LOG_ERROR
, "only 48khz is implemented\n");
1450 av_set_pts_info(st
, 64, 1, st
->codec
->sample_rate
);
1451 if (s
->oformat
== &mxf_d10_muxer
) {
1452 if (st
->index
!= 1) {
1453 av_log(s
, AV_LOG_ERROR
, "MXF D-10 only support one audio track\n");
1456 if (st
->codec
->codec_id
!= CODEC_ID_PCM_S16LE
&&
1457 st
->codec
->codec_id
!= CODEC_ID_PCM_S24LE
) {
1458 av_log(s
, AV_LOG_ERROR
, "MXF D-10 only support 16 or 24 bits le audio\n");
1460 sc
->index
= ((MXFStreamContext
*)s
->streams
[0]->priv_data
)->index
+ 1;
1462 mxf
->slice_count
= 1;
1466 sc
->index
= mxf_get_essence_container_ul_index(st
->codec
->codec_id
);
1467 if (sc
->index
== -1) {
1468 av_log(s
, AV_LOG_ERROR
, "track %d: could not find essence container ul, "
1469 "codec not currently supported in container\n", i
);
1474 sc
->codec_ul
= &mxf_essence_container_uls
[sc
->index
].codec_ul
;
1476 memcpy(sc
->track_essence_element_key
, mxf_essence_container_uls
[sc
->index
].element_ul
, 15);
1477 sc
->track_essence_element_key
[15] = present
[sc
->index
];
1478 PRINT_KEY(s
, "track essence element key", sc
->track_essence_element_key
);
1480 if (!present
[sc
->index
])
1481 mxf
->essence_container_count
++;
1482 present
[sc
->index
]++;
1485 if (s
->oformat
== &mxf_d10_muxer
) {
1486 mxf
->essence_container_count
= 1;
1489 if (!(s
->streams
[0]->codec
->flags
& CODEC_FLAG_BITEXACT
))
1492 for (i
= 0; i
< s
->nb_streams
; i
++) {
1493 MXFStreamContext
*sc
= s
->streams
[i
]->priv_data
;
1494 // update element count
1495 sc
->track_essence_element_key
[13] = present
[sc
->index
];
1496 sc
->order
= AV_RB32(sc
->track_essence_element_key
+12);
1500 mxf
->timestamp
= mxf_parse_timestamp(s
->timestamp
);
1503 mxf
->timecode_track
= av_mallocz(sizeof(*mxf
->timecode_track
));
1504 if (!mxf
->timecode_track
)
1505 return AVERROR(ENOMEM
);
1506 mxf
->timecode_track
->priv_data
= av_mallocz(sizeof(MXFStreamContext
));
1507 if (!mxf
->timecode_track
->priv_data
)
1508 return AVERROR(ENOMEM
);
1509 mxf
->timecode_track
->index
= -1;
1511 if (!samples_per_frame
)
1512 samples_per_frame
= PAL_samples_per_frame
;
1514 if (ff_audio_interleave_init(s
, samples_per_frame
, mxf
->time_base
) < 0)
1520 static const uint8_t system_metadata_pack_key
[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04,0x01,0x01,0x00 };
1521 static const uint8_t system_metadata_package_set_key
[] = { 0x06,0x0E,0x2B,0x34,0x02,0x43,0x01,0x01,0x0D,0x01,0x03,0x01,0x04,0x01,0x02,0x01 };
1523 static uint32_t ff_framenum_to_12m_time_code(unsigned frame
, int drop
, int fps
)
1525 return (0 << 31) | // color frame flag
1526 (0 << 30) | // drop frame flag
1527 ( ((frame
% fps
) / 10) << 28) | // tens of frames
1528 ( ((frame
% fps
) % 10) << 24) | // units of frames
1529 (0 << 23) | // field phase (NTSC), b0 (PAL)
1530 ((((frame
/ fps
) % 60) / 10) << 20) | // tens of seconds
1531 ((((frame
/ fps
) % 60) % 10) << 16) | // units of seconds
1532 (0 << 15) | // b0 (NTSC), b2 (PAL)
1533 ((((frame
/ (fps
* 60)) % 60) / 10) << 12) | // tens of minutes
1534 ((((frame
/ (fps
* 60)) % 60) % 10) << 8) | // units of minutes
1536 (0 << 6) | // b2 (NSC), field phase (PAL)
1537 ((((frame
/ (fps
* 3600) % 24)) / 10) << 4) | // tens of hours
1538 ( (frame
/ (fps
* 3600) % 24)) % 10; // units of hours
1541 static void mxf_write_system_item(AVFormatContext
*s
)
1543 MXFContext
*mxf
= s
->priv_data
;
1544 ByteIOContext
*pb
= s
->pb
;
1548 frame
= mxf
->timecode_start
+ mxf
->last_indexed_edit_unit
+ mxf
->edit_units_count
;
1550 // write system metadata pack
1551 put_buffer(pb
, system_metadata_pack_key
, 16);
1552 klv_encode_ber4_length(pb
, 57);
1553 put_byte(pb
, 0x5c); // UL, user date/time stamp, picture and sound item present
1554 put_byte(pb
, 0x04); // content package rate
1555 put_byte(pb
, 0x00); // content package type
1556 put_be16(pb
, 0x00); // channel handle
1557 put_be16(pb
, frame
); // continuity count
1558 if (mxf
->essence_container_count
> 1)
1559 put_buffer(pb
, multiple_desc_ul
, 16);
1561 MXFStreamContext
*sc
= s
->streams
[0]->priv_data
;
1562 put_buffer(pb
, mxf_essence_container_uls
[sc
->index
].container_ul
, 16);
1566 put_be64(pb
, 0); // creation date/time stamp
1568 put_byte(pb
, 0x81); // SMPTE 12M time code
1569 time_code
= ff_framenum_to_12m_time_code(frame
, mxf
->timecode_drop_frame
, mxf
->timecode_base
);
1570 put_be32(pb
, time_code
);
1571 put_be32(pb
, 0); // binary group data
1574 // write system metadata package set
1575 put_buffer(pb
, system_metadata_package_set_key
, 16);
1576 klv_encode_ber4_length(pb
, 35);
1577 put_byte(pb
, 0x83); // UMID
1579 mxf_write_umid(s
, 1);
1582 static void mxf_write_d10_video_packet(AVFormatContext
*s
, AVStream
*st
, AVPacket
*pkt
)
1584 MXFContext
*mxf
= s
->priv_data
;
1585 ByteIOContext
*pb
= s
->pb
;
1586 int packet_size
= (uint64_t)st
->codec
->bit_rate
*mxf
->time_base
.num
/
1587 (8*mxf
->time_base
.den
); // frame size
1590 packet_size
+= 16 + 4;
1591 packet_size
+= klv_fill_size(packet_size
);
1593 klv_encode_ber4_length(pb
, pkt
->size
);
1594 put_buffer(pb
, pkt
->data
, pkt
->size
);
1596 // ensure CBR muxing by padding to correct video frame size
1597 pad
= packet_size
- pkt
->size
- 16 - 4;
1599 put_buffer(s
->pb
, klv_fill_key
, 16);
1601 klv_encode_ber4_length(s
->pb
, pad
);
1604 assert(!(url_ftell(s
->pb
) & (KAG_SIZE
-1)));
1606 av_log(s
, AV_LOG_WARNING
, "cannot fill d-10 video packet\n");
1607 for (; pad
> 0; pad
--)
1612 static void mxf_write_d10_audio_packet(AVFormatContext
*s
, AVStream
*st
, AVPacket
*pkt
)
1614 MXFContext
*mxf
= s
->priv_data
;
1615 ByteIOContext
*pb
= s
->pb
;
1616 int frame_size
= pkt
->size
/ st
->codec
->block_align
;
1617 uint8_t *samples
= pkt
->data
;
1618 uint8_t *end
= pkt
->data
+ pkt
->size
;
1621 klv_encode_ber4_length(pb
, 4 + frame_size
*4*8);
1623 put_byte(pb
, (frame_size
== 1920 ? 0 : (mxf
->edit_units_count
-1) % 5 + 1));
1624 put_le16(pb
, frame_size
);
1625 put_byte(pb
, (1<<st
->codec
->channels
)-1);
1627 while (samples
< end
) {
1628 for (i
= 0; i
< st
->codec
->channels
; i
++) {
1630 if (st
->codec
->codec_id
== CODEC_ID_PCM_S24LE
) {
1631 sample
= AV_RL24(samples
)<< 4;
1634 sample
= AV_RL16(samples
)<<12;
1637 put_le32(pb
, sample
| i
);
1644 static int mxf_write_packet(AVFormatContext
*s
, AVPacket
*pkt
)
1646 MXFContext
*mxf
= s
->priv_data
;
1647 ByteIOContext
*pb
= s
->pb
;
1648 AVStream
*st
= s
->streams
[pkt
->stream_index
];
1649 MXFStreamContext
*sc
= st
->priv_data
;
1652 if (!mxf
->edit_unit_byte_count
&& !(mxf
->edit_units_count
% EDIT_UNITS_PER_BODY
)) {
1653 mxf
->index_entries
= av_realloc(mxf
->index_entries
,
1654 (mxf
->edit_units_count
+ EDIT_UNITS_PER_BODY
)*sizeof(*mxf
->index_entries
));
1655 if (!mxf
->index_entries
) {
1656 av_log(s
, AV_LOG_ERROR
, "could not allocate index entries\n");
1661 if (st
->codec
->codec_id
== CODEC_ID_MPEG2VIDEO
) {
1662 if (!mxf_parse_mpeg2_frame(s
, st
, pkt
, &flags
)) {
1663 av_log(s
, AV_LOG_ERROR
, "could not get mpeg2 profile and level\n");
1668 if (!mxf
->header_written
) {
1669 if (mxf
->edit_unit_byte_count
) {
1670 mxf_write_partition(s
, 1, 2, header_open_partition_key
, 1);
1671 mxf_write_klv_fill(s
);
1672 mxf_write_index_table_segment(s
);
1674 mxf_write_partition(s
, 0, 0, header_open_partition_key
, 1);
1676 mxf
->header_written
= 1;
1679 if (st
->index
== 0) {
1680 if (!mxf
->edit_unit_byte_count
&&
1681 (!mxf
->edit_units_count
|| mxf
->edit_units_count
> EDIT_UNITS_PER_BODY
) &&
1682 !(flags
& 0x33)) { // I frame, Gop start
1683 mxf_write_klv_fill(s
);
1684 mxf_write_partition(s
, 1, 2, body_partition_key
, 0);
1686 mxf_write_klv_fill(s
);
1687 mxf_write_index_table_segment(s
);
1690 mxf_write_klv_fill(s
);
1691 mxf_write_system_item(s
);
1693 if (!mxf
->edit_unit_byte_count
) {
1694 mxf
->index_entries
[mxf
->edit_units_count
].offset
= mxf
->body_offset
;
1695 mxf
->index_entries
[mxf
->edit_units_count
].flags
= flags
;
1696 mxf
->body_offset
+= KAG_SIZE
; // size of system element
1698 mxf
->edit_units_count
++;
1699 } else if (!mxf
->edit_unit_byte_count
&& st
->index
== 1) {
1700 mxf
->index_entries
[mxf
->edit_units_count
-1].slice_offset
=
1701 mxf
->body_offset
- mxf
->index_entries
[mxf
->edit_units_count
-1].offset
;
1704 mxf_write_klv_fill(s
);
1705 put_buffer(pb
, sc
->track_essence_element_key
, 16); // write key
1706 if (s
->oformat
== &mxf_d10_muxer
) {
1707 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
)
1708 mxf_write_d10_video_packet(s
, st
, pkt
);
1710 mxf_write_d10_audio_packet(s
, st
, pkt
);
1712 klv_encode_ber4_length(pb
, pkt
->size
); // write length
1713 put_buffer(pb
, pkt
->data
, pkt
->size
);
1714 mxf
->body_offset
+= 16+4+pkt
->size
+ klv_fill_size(16+4+pkt
->size
);
1717 put_flush_packet(pb
);
1722 static void mxf_write_random_index_pack(AVFormatContext
*s
)
1724 MXFContext
*mxf
= s
->priv_data
;
1725 ByteIOContext
*pb
= s
->pb
;
1726 uint64_t pos
= url_ftell(pb
);
1729 put_buffer(pb
, random_index_pack_key
, 16);
1730 klv_encode_ber_length(pb
, 28 + 12*mxf
->body_partitions_count
);
1732 if (mxf
->edit_unit_byte_count
)
1733 put_be32(pb
, 1); // BodySID of header partition
1736 put_be64(pb
, 0); // offset of header partition
1738 for (i
= 0; i
< mxf
->body_partitions_count
; i
++) {
1739 put_be32(pb
, 1); // BodySID
1740 put_be64(pb
, mxf
->body_partition_offset
[i
]);
1743 put_be32(pb
, 0); // BodySID of footer partition
1744 put_be64(pb
, mxf
->footer_partition_offset
);
1746 put_be32(pb
, url_ftell(pb
) - pos
+ 4);
1749 static int mxf_write_footer(AVFormatContext
*s
)
1751 MXFContext
*mxf
= s
->priv_data
;
1752 ByteIOContext
*pb
= s
->pb
;
1754 mxf
->duration
= mxf
->last_indexed_edit_unit
+ mxf
->edit_units_count
;
1756 mxf_write_klv_fill(s
);
1757 mxf
->footer_partition_offset
= url_ftell(pb
);
1758 if (mxf
->edit_unit_byte_count
) { // no need to repeat index
1759 mxf_write_partition(s
, 0, 0, footer_partition_key
, 0);
1761 mxf_write_partition(s
, 0, 2, footer_partition_key
, 0);
1763 mxf_write_klv_fill(s
);
1764 mxf_write_index_table_segment(s
);
1767 mxf_write_klv_fill(s
);
1768 mxf_write_random_index_pack(s
);
1770 if (!url_is_streamed(s
->pb
)) {
1771 url_fseek(pb
, 0, SEEK_SET
);
1772 if (mxf
->edit_unit_byte_count
) {
1773 mxf_write_partition(s
, 1, 2, header_closed_partition_key
, 1);
1774 mxf_write_klv_fill(s
);
1775 mxf_write_index_table_segment(s
);
1777 mxf_write_partition(s
, 0, 0, header_closed_partition_key
, 1);
1781 put_flush_packet(pb
);
1783 ff_audio_interleave_close(s
);
1785 av_freep(&mxf
->index_entries
);
1786 av_freep(&mxf
->body_partition_offset
);
1787 av_freep(&mxf
->timecode_track
->priv_data
);
1788 av_freep(&mxf
->timecode_track
);
1795 static int mxf_interleave_get_packet(AVFormatContext
*s
, AVPacket
*out
, AVPacket
*pkt
, int flush
)
1798 int stream_count
= 0;
1799 int streams
[MAX_STREAMS
];
1801 memset(streams
, 0, sizeof(streams
));
1802 pktl
= s
->packet_buffer
;
1804 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
1805 if (!streams
[pktl
->pkt
.stream_index
])
1807 streams
[pktl
->pkt
.stream_index
]++;
1811 if (stream_count
&& (s
->nb_streams
== stream_count
|| flush
)) {
1812 pktl
= s
->packet_buffer
;
1813 if (s
->nb_streams
!= stream_count
) {
1814 AVPacketList
*last
= NULL
;
1815 // find last packet in edit unit
1817 if (!stream_count
|| pktl
->pkt
.stream_index
== 0)
1823 // purge packet queue
1825 AVPacketList
*next
= pktl
->next
;
1826 av_free_packet(&pktl
->pkt
);
1833 s
->packet_buffer
= NULL
;
1836 pktl
= s
->packet_buffer
;
1840 //av_log(s, AV_LOG_DEBUG, "out st:%d dts:%lld\n", (*out).stream_index, (*out).dts);
1841 s
->packet_buffer
= pktl
->next
;
1846 av_init_packet(out
);
1851 static int mxf_compare_timestamps(AVFormatContext
*s
, AVPacket
*next
, AVPacket
*pkt
)
1853 MXFStreamContext
*sc
= s
->streams
[pkt
->stream_index
]->priv_data
;
1854 MXFStreamContext
*sc2
= s
->streams
[next
->stream_index
]->priv_data
;
1856 return next
->dts
> pkt
->dts
||
1857 (next
->dts
== pkt
->dts
&& sc
->order
< sc2
->order
);
1860 static int mxf_interleave(AVFormatContext
*s
, AVPacket
*out
, AVPacket
*pkt
, int flush
)
1862 return ff_audio_rechunk_interleave(s
, out
, pkt
, flush
,
1863 mxf_interleave_get_packet
, mxf_compare_timestamps
);
1866 AVOutputFormat mxf_muxer
= {
1868 NULL_IF_CONFIG_SMALL("Material eXchange Format"),
1873 CODEC_ID_MPEG2VIDEO
,
1882 AVOutputFormat mxf_d10_muxer
= {
1884 NULL_IF_CONFIG_SMALL("Material eXchange Format, D-10 Mapping"),
1889 CODEC_ID_MPEG2VIDEO
,