FFmpeg
mxfenc.c
Go to the documentation of this file.
1 /*
2  * MXF muxer
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>
5  *
6  * This file is part of FFmpeg.
7  *
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.
12  *
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.
17  *
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
21  */
22 
23 /*
24  * signal_standard, color_siting, store_user_comments, sample rate and klv_fill_key version
25  * fixes sponsored by NOA GmbH
26  */
27 
28 /*
29  * References
30  * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
31  * SMPTE 377M MXF File Format Specifications
32  * SMPTE 379M MXF Generic Container
33  * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
34  * SMPTE 422M Mapping JPEG 2000 Codestreams into the MXF Generic Container
35  * SMPTE RP210: SMPTE Metadata Dictionary
36  * SMPTE RP224: Registry of SMPTE Universal Labels
37  */
38 
39 #include <inttypes.h>
40 #include <math.h>
41 #include <time.h>
42 
43 #include "libavutil/opt.h"
44 #include "libavutil/random_seed.h"
45 #include "libavutil/timecode.h"
46 #include "libavutil/avassert.h"
47 #include "libavutil/pixdesc.h"
49 #include "libavcodec/bytestream.h"
50 #include "libavcodec/dnxhddata.h"
51 #include "libavcodec/dv_profile.h"
52 #include "libavcodec/h264_ps.h"
53 #include "libavcodec/golomb.h"
54 #include "libavcodec/internal.h"
55 #include "audiointerleave.h"
56 #include "avformat.h"
57 #include "avio_internal.h"
58 #include "internal.h"
59 #include "avc.h"
60 #include "mxf.h"
61 #include "config.h"
62 
65 
66 #define EDIT_UNITS_PER_BODY 250
67 #define KAG_SIZE 512
68 
69 typedef struct MXFLocalTagPair {
70  int local_tag;
73 
74 typedef struct MXFIndexEntry {
76  uint64_t offset;
77  unsigned slice_offset; ///< offset of audio slice
78  uint16_t temporal_ref;
80 
81 typedef struct MXFStreamContext {
84  int index; ///< index in mxf_essence_container_uls table
85  const UID *codec_ul;
86  const UID *container_ul;
87  int order; ///< interleaving order if dts are equal
88  int interlaced; ///< whether picture is interlaced
89  int field_dominance; ///< tff=1, bff=2
96  AVRational aspect_ratio; ///< display aspect ratio
97  int closed_gop; ///< gop is closed, used in mpeg-2 frame parsing
100  int frame_size; ///< frame size in bytes
101  int seq_closed_gop; ///< all gops in sequence are closed, used in mpeg-2 descriptor
102  int max_gop; ///< maximum gop size, used by mpeg-2 descriptor
103  int b_picture_count; ///< maximum number of consecutive b pictures, used in mpeg-2 descriptor
104  int low_delay; ///< low delay, used in mpeg-2 descriptor
107 
108 typedef struct MXFContainerEssenceEntry {
112  void (*write_desc)(AVFormatContext *, AVStream *);
114 
115 typedef struct MXFPackage {
116  char *name;
118  int instance;
119  struct MXFPackage *ref;
120 } MXFPackage;
121 
122 enum ULIndex {
134 };
135 
136 static const struct {
137  enum AVCodecID id;
139 } mxf_essence_mappings[] = {
142  { AV_CODEC_ID_PCM_S16LE, INDEX_AES3 },
148  { AV_CODEC_ID_NONE }
149 };
150 
151 static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st);
152 static void mxf_write_aes3_desc(AVFormatContext *s, AVStream *st);
154 static void mxf_write_h264_desc(AVFormatContext *s, AVStream *st);
155 static void mxf_write_cdci_desc(AVFormatContext *s, AVStream *st);
158 
160  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x60,0x01 },
161  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x15,0x01,0x05,0x00 },
162  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x00,0x00,0x00 },
164  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x03,0x00 },
165  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x16,0x01,0x03,0x00 },
166  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
168  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x01,0x00 },
169  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x16,0x01,0x01,0x00 },
170  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
172  // D-10 Video
173  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 },
174  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x05,0x01,0x01,0x00 },
175  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x01 },
177  // D-10 Audio
178  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 },
179  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x06,0x01,0x10,0x00 },
180  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
182  // DV
183  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x7F,0x01 },
184  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x18,0x01,0x01,0x00 },
185  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x00,0x00,0x00 },
187  // DNxHD
188  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x11,0x01,0x00 },
189  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x15,0x01,0x05,0x00 },
190  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x71,0x01,0x00,0x00 },
192  // JPEG2000
193  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 },
194  { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01,0x15,0x01,0x08,0x00 },
195  { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 },
197  // H.264
198  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x0D,0x01,0x03,0x01,0x02,0x10,0x60,0x01 },
199  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x15,0x01,0x05,0x00 },
200  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x00,0x00,0x00 },
202  // S436M ANC
203  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x0D,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 },
204  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x17,0x01,0x02,0x00 },
205  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x01,0x5C,0x00 },
207  // ProRes
208  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x1c,0x01,0x00 },
209  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01,0x15,0x01,0x17,0x00 },
210  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x03,0x00 },
212  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
213  { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
214  { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
215  NULL },
216 };
217 
218 static const UID mxf_d10_codec_uls[] = {
219  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x01 }, // D-10 625/50 PAL 50mb/s
220  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x02 }, // D-10 525/50 NTSC 50mb/s
221  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x03 }, // D-10 625/50 PAL 40mb/s
222  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x04 }, // D-10 525/50 NTSC 40mb/s
223  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x05 }, // D-10 625/50 PAL 30mb/s
224  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x06 }, // D-10 525/50 NTSC 30mb/s
225 };
226 
227 static const UID mxf_d10_container_uls[] = {
228  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, // D-10 625/50 PAL 50mb/s
229  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x02,0x01 }, // D-10 525/50 NTSC 50mb/s
230  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x03,0x01 }, // D-10 625/50 PAL 40mb/s
231  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x04,0x01 }, // D-10 525/50 NTSC 40mb/s
232  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x05,0x01 }, // D-10 625/50 PAL 30mb/s
233  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x06,0x01 }, // D-10 525/50 NTSC 30mb/s
234 };
235 
236 typedef struct MXFContext {
244  uint64_t timestamp; ///< timestamp, as year(16),month(8),day(8),hour(8),minutes(8),msec/4(8)
245  uint8_t slice_count; ///< index slice count minus 1 (1 if no audio, 0 otherwise)
249  int last_key_index; ///< index of last key frame
250  uint64_t duration;
251  AVTimecode tc; ///< timecode context
253  int timecode_base; ///< rounded time code base (25 or 30)
254  int edit_unit_byte_count; ///< fixed edit unit byte count
255  int content_package_rate; ///< content package rate in system element, see SMPTE 326M
256  uint64_t body_offset;
257  uint32_t instance_number;
258  uint8_t umid[16]; ///< unique material identifier
264  int track_instance_count; // used to generate MXFTrack uuids
265  int cbr_index; ///< use a constant bitrate index
266 } MXFContext;
267 
268 static const uint8_t uuid_base[] = { 0xAD,0xAB,0x44,0x24,0x2f,0x25,0x4d,0xc7,0x92,0xff,0x29,0xbd };
269 static const uint8_t umid_ul[] = { 0x06,0x0A,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x01,0x0D,0x00,0x13 };
270 
271 /**
272  * complete key for operation pattern, partitions, and primer pack
273  */
274 static const uint8_t op1a_ul[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x01,0x09,0x00 };
275 static const uint8_t opatom_ul[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x02,0x01,0x10,0x03,0x00,0x00 };
276 static const uint8_t footer_partition_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }; // ClosedComplete
277 static const uint8_t primer_pack_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x05,0x01,0x00 };
278 static const uint8_t index_table_segment_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 };
279 static const uint8_t random_index_pack_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x11,0x01,0x00 };
280 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
281 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
282 static const uint8_t klv_fill_key[] = { 0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x01,0x02,0x10,0x01,0x00,0x00,0x00 };
283 static const uint8_t body_partition_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }; // ClosedComplete
284 
285 /**
286  * partial key for header metadata
287  */
288 static const uint8_t header_metadata_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01 };
289 static const uint8_t multiple_desc_ul[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x0D,0x01,0x03,0x01,0x02,0x7F,0x01,0x00 };
290 
291 /**
292  * SMPTE RP210 http://www.smpte-ra.org/mdd/index.html
293  * https://smpte-ra.org/sites/default/files/Labels.xml
294  */
296  // preface set
297  { 0x3C0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x15,0x02,0x00,0x00,0x00,0x00}}, /* Instance UID */
298  { 0x3B02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x04,0x00,0x00}}, /* Last Modified Date */
299  { 0x3B05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x01,0x02,0x01,0x05,0x00,0x00,0x00}}, /* Version */
300  { 0x3B07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x01,0x02,0x01,0x04,0x00,0x00,0x00}}, /* Object Model Version */
301  { 0x3B06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x04,0x00,0x00}}, /* Identifications reference */
302  { 0x3B03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x01,0x00,0x00}}, /* Content Storage reference */
303  { 0x3B09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x03,0x00,0x00,0x00,0x00}}, /* Operational Pattern UL */
304  { 0x3B0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x10,0x02,0x01,0x00,0x00}}, /* Essence Containers UL batch */
305  { 0x3B0B, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x10,0x02,0x02,0x00,0x00}}, /* DM Schemes UL batch */
306  // Identification
307  { 0x3C09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x01,0x00,0x00,0x00}}, /* This Generation UID */
308  { 0x3C01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x02,0x01,0x00,0x00}}, /* Company Name */
309  { 0x3C02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x03,0x01,0x00,0x00}}, /* Product Name */
310  { 0x3C03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x04,0x00,0x00,0x00}}, /* Product Version */
311  { 0x3C04, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x05,0x01,0x00,0x00}}, /* Version String */
312  { 0x3C05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x07,0x00,0x00,0x00}}, /* Product ID */
313  { 0x3C06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x03,0x00,0x00}}, /* Modification Date */
314  { 0x3C07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x0A,0x00,0x00,0x00}}, /* Toolkit Version */
315  { 0x3C08, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x06,0x01,0x00,0x00}}, /* Platform */
316  // Content Storage
317  { 0x1901, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x05,0x01,0x00,0x00}}, /* Package strong reference batch */
318  { 0x1902, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x05,0x02,0x00,0x00}}, /* Package strong reference batch */
319  // Essence Container Data
320  { 0x2701, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x06,0x01,0x00,0x00,0x00}}, /* Linked Package UID */
321  { 0x3F07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x01,0x03,0x04,0x04,0x00,0x00,0x00,0x00}}, /* BodySID */
322  // Package
323  { 0x4401, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x15,0x10,0x00,0x00,0x00,0x00}}, /* Package UID */
324  { 0x4405, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x01,0x03,0x00,0x00}}, /* Package Creation Date */
325  { 0x4404, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x05,0x00,0x00}}, /* Package Modified Date */
326  { 0x4402, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x03,0x03,0x02,0x01,0x00,0x00,0x00}}, /* Package Name */
327  { 0x4403, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x05,0x00,0x00}}, /* Tracks Strong reference array */
328  { 0x4701, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x03,0x00,0x00}}, /* Descriptor */
329  // Track
330  { 0x4801, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x01,0x07,0x01,0x01,0x00,0x00,0x00,0x00}}, /* Track ID */
331  { 0x4804, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x01,0x04,0x01,0x03,0x00,0x00,0x00,0x00}}, /* Track Number */
332  { 0x4B01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x30,0x04,0x05,0x00,0x00,0x00,0x00}}, /* Edit Rate */
333  { 0x4B02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x03,0x01,0x03,0x00,0x00}}, /* Origin */
334  { 0x4803, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x04,0x00,0x00}}, /* Sequence reference */
335  // Sequence
336  { 0x0201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x07,0x01,0x00,0x00,0x00,0x00,0x00}}, /* Data Definition UL */
337  { 0x0202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x02,0x01,0x01,0x03,0x00,0x00}}, /* Duration */
338  { 0x1001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x09,0x00,0x00}}, /* Structural Components reference array */
339  // Source Clip
340  { 0x1201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x03,0x01,0x04,0x00,0x00}}, /* Start position */
341  { 0x1101, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x03,0x01,0x00,0x00,0x00}}, /* SourcePackageID */
342  { 0x1102, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x03,0x02,0x00,0x00,0x00}}, /* SourceTrackID */
343  // Timecode Component
344  { 0x1501, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x03,0x01,0x05,0x00,0x00}}, /* Start Time Code */
345  { 0x1502, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x04,0x01,0x01,0x02,0x06,0x00,0x00}}, /* Rounded Time Code Base */
346  { 0x1503, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x04,0x01,0x01,0x05,0x00,0x00,0x00}}, /* Drop Frame */
347  // File Descriptor
348  { 0x3F01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x06,0x01,0x01,0x04,0x06,0x0B,0x00,0x00}}, /* Sub Descriptors reference array */
349  { 0x3006, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x06,0x01,0x01,0x03,0x05,0x00,0x00,0x00}}, /* Linked Track ID */
350  { 0x3001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x06,0x01,0x01,0x00,0x00,0x00,0x00}}, /* SampleRate */
351  { 0x3002, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x06,0x01,0x02,0x00,0x00,0x00,0x00}}, /* ContainerDuration */
352  { 0x3004, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x01,0x02,0x00,0x00}}, /* Essence Container */
353  // Generic Picture Essence Descriptor
354  { 0x320C, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x03,0x01,0x04,0x00,0x00,0x00}}, /* Frame Layout */
355  { 0x320D, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x03,0x02,0x05,0x00,0x00,0x00}}, /* Video Line Map */
356  { 0x3203, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x02,0x02,0x00,0x00,0x00}}, /* Stored Width */
357  { 0x3202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x02,0x01,0x00,0x00,0x00}}, /* Stored Height */
358  { 0x3216, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x03,0x02,0x08,0x00,0x00,0x00}}, /* Stored F2 Offset */
359  { 0x3205, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x08,0x00,0x00,0x00}}, /* Sampled Width */
360  { 0x3204, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x07,0x00,0x00,0x00}}, /* Sampled Height */
361  { 0x3206, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x09,0x00,0x00,0x00}}, /* Sampled X Offset */
362  { 0x3207, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0A,0x00,0x00,0x00}}, /* Sampled Y Offset */
363  { 0x3209, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0C,0x00,0x00,0x00}}, /* Display Width */
364  { 0x3208, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0B,0x00,0x00,0x00}}, /* Display Height */
365  { 0x320A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0D,0x00,0x00,0x00}}, /* Display X offset */
366  { 0x320B, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0E,0x00,0x00,0x00}}, /* Presentation Y offset */
367  { 0x3217, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x03,0x02,0x07,0x00,0x00,0x00}}, /* Display F2 offset */
368  { 0x320E, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x01,0x01,0x01,0x00,0x00,0x00}}, /* Aspect Ratio */
369  { 0x3210, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x02,0x01,0x01,0x01,0x02,0x00}}, /* Transfer characteristic */
370  { 0x3213, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x18,0x01,0x02,0x00,0x00,0x00,0x00}}, /* Image Start Offset */
371  { 0x3214, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x18,0x01,0x03,0x00,0x00,0x00,0x00}}, /* Image End Offset */
372  { 0x3201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x06,0x01,0x00,0x00,0x00,0x00}}, /* Picture Essence Coding */
373  { 0x3212, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x03,0x01,0x06,0x00,0x00,0x00}}, /* Field Dominance (Opt) */
374  { 0x3215, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x05,0x01,0x13,0x00,0x00,0x00,0x00}}, /* Signal Standard */
375  // CDCI Picture Essence Descriptor
376  { 0x3301, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x05,0x03,0x0A,0x00,0x00,0x00}}, /* Component Depth */
377  { 0x3302, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x05,0x00,0x00,0x00}}, /* Horizontal Subsampling */
378  { 0x3308, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x05,0x01,0x10,0x00,0x00,0x00}}, /* Vertical Subsampling */
379  { 0x3303, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x06,0x00,0x00,0x00}}, /* Color Siting */
380  { 0x3307, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x18,0x01,0x04,0x00,0x00,0x00,0x00}}, /* Padding Bits */
381  { 0x3304, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x03,0x03,0x00,0x00,0x00}}, /* Black Ref level */
382  { 0x3305, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x03,0x04,0x00,0x00,0x00}}, /* White Ref level */
383  { 0x3306, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x05,0x03,0x05,0x00,0x00,0x00}}, /* Color Range */
384  // Generic Sound Essence Descriptor
385  { 0x3D02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x02,0x03,0x01,0x04,0x00,0x00,0x00}}, /* Locked/Unlocked */
386  { 0x3D03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x01,0x01,0x01,0x00,0x00}}, /* Audio sampling rate */
387  { 0x3D04, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x02,0x01,0x01,0x03,0x00,0x00,0x00}}, /* Audio Ref Level */
388  { 0x3D07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x01,0x01,0x04,0x00,0x00,0x00}}, /* ChannelCount */
389  { 0x3D01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x02,0x03,0x03,0x04,0x00,0x00,0x00}}, /* Quantization bits */
390  { 0x3D06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x02,0x04,0x02,0x00,0x00,0x00,0x00}}, /* Sound Essence Compression */
391  // Index Table Segment
392  { 0x3F0B, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x05,0x30,0x04,0x06,0x00,0x00,0x00,0x00}}, /* Index Edit Rate */
393  { 0x3F0C, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x07,0x02,0x01,0x03,0x01,0x0A,0x00,0x00}}, /* Index Start Position */
394  { 0x3F0D, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x07,0x02,0x02,0x01,0x01,0x02,0x00,0x00}}, /* Index Duration */
395  { 0x3F05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x06,0x02,0x01,0x00,0x00,0x00,0x00}}, /* Edit Unit Byte Count */
396  { 0x3F06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x01,0x03,0x04,0x05,0x00,0x00,0x00,0x00}}, /* IndexSID */
397  { 0x3F08, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x04,0x04,0x01,0x01,0x00,0x00,0x00}}, /* Slice Count */
398  { 0x3F09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x04,0x04,0x01,0x06,0x00,0x00,0x00}}, /* Delta Entry Array */
399  { 0x3F0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x04,0x04,0x02,0x05,0x00,0x00,0x00}}, /* Index Entry Array */
400  // MPEG video Descriptor
401  { 0x8000, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x0B,0x00,0x00}}, /* BitRate */
402  { 0x8003, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x05,0x00,0x00}}, /* LowDelay */
403  { 0x8004, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x06,0x00,0x00}}, /* ClosedGOP */
404  { 0x8006, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x08,0x00,0x00}}, /* MaxGOP */
405  { 0x8007, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x0A,0x00,0x00}}, /* ProfileAndLevel */
406  { 0x8008, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x09,0x00,0x00}}, /* BPictureCount */
407  // Wave Audio Essence Descriptor
408  { 0x3D09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x03,0x05,0x00,0x00,0x00}}, /* Average Bytes Per Second */
409  { 0x3D0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x02,0x01,0x00,0x00,0x00}}, /* Block Align */
410 };
411 
413  { 0x8100, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x04,0x06,0x10,0x00,0x00}}, /* SubDescriptors */
414  { 0x8200, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x0E,0x04,0x01,0x06,0x06,0x01,0x0E,0x00,0x00}}, /* AVC Decoding Delay */
415  { 0x8201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x0E,0x04,0x01,0x06,0x06,0x01,0x0A,0x00,0x00}}, /* AVC Profile */
416  { 0x8202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x0E,0x04,0x01,0x06,0x06,0x01,0x0D,0x00,0x00}}, /* AVC Level */
417 };
418 
420  { 0x4406, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x02,0x01,0x02,0x0C,0x00,0x00,0x00}}, /* User Comments */
421  { 0x5001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x02,0x01,0x02,0x09,0x01,0x00,0x00}}, /* Name */
422  { 0x5003, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x02,0x01,0x02,0x0A,0x01,0x00,0x00}}, /* Value */
423 };
424 
426 {
427  avio_write(pb, uuid_base, 12);
428  avio_wb16(pb, type);
429  avio_wb16(pb, value);
430 }
431 
432 static void mxf_write_umid(AVFormatContext *s, int type)
433 {
434  MXFContext *mxf = s->priv_data;
435  avio_write(s->pb, umid_ul, 13);
436  avio_wb24(s->pb, mxf->instance_number);
437  avio_write(s->pb, mxf->umid, 15);
438  avio_w8(s->pb, type);
439 }
440 
441 static void mxf_write_refs_count(AVIOContext *pb, int ref_count)
442 {
443  avio_wb32(pb, ref_count);
444  avio_wb32(pb, 16);
445 }
446 
447 static int klv_ber_length(uint64_t len)
448 {
449  if (len < 128)
450  return 1;
451  else
452  return (av_log2(len) >> 3) + 2;
453 }
454 
455 static int klv_encode_ber_length(AVIOContext *pb, uint64_t len)
456 {
457  // Determine the best BER size
458  int size = klv_ber_length(len);
459  if (size == 1) {
460  //short form
461  avio_w8(pb, len);
462  return 1;
463  }
464 
465  size --;
466  // long form
467  avio_w8(pb, 0x80 + size);
468  while(size) {
469  size--;
470  avio_w8(pb, len >> 8 * size & 0xff);
471  }
472  return 0;
473 }
474 
476 {
477  avio_w8(pb, 0x80 + 3);
478  avio_wb24(pb, len);
479 }
480 
481 static void klv_encode_ber9_length(AVIOContext *pb, uint64_t len)
482 {
483  avio_w8(pb, 0x80 + 8);
484  avio_wb64(pb, len);
485 }
486 
487 /*
488  * Get essence container ul index
489  */
491 {
492  int i;
493  for (i = 0; mxf_essence_mappings[i].id; i++)
494  if (mxf_essence_mappings[i].id == id)
495  return mxf_essence_mappings[i].index;
496  return -1;
497 }
498 
499 static void mxf_write_local_tags(AVIOContext *pb, const MXFLocalTagPair *local_tags, int count)
500 {
501  int i;
502  for (i = 0; i < count; i++) {
503  avio_wb16(pb, local_tags[i].local_tag);
504  avio_write(pb, local_tags[i].uid, 16);
505  }
506 }
507 
509 {
510  MXFContext *mxf = s->priv_data;
511  AVIOContext *pb = s->pb;
512  int local_tag_number, i = 0;
513  int avc_tags_count = 0;
514 
515  local_tag_number = FF_ARRAY_ELEMS(mxf_local_tag_batch);
516  local_tag_number += mxf->store_user_comments * FF_ARRAY_ELEMS(mxf_user_comments_local_tag);
517 
518  for (i = 0; i < s->nb_streams; i++) {
519  MXFStreamContext *sc = s->streams[i]->priv_data;
520  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_H264 && !sc->avc_intra) {
521  avc_tags_count = FF_ARRAY_ELEMS(mxf_avc_subdescriptor_local_tags);
522  local_tag_number += avc_tags_count;
523  }
524  }
525 
526  avio_write(pb, primer_pack_key, 16);
527  klv_encode_ber_length(pb, local_tag_number * 18 + 8);
528 
529  avio_wb32(pb, local_tag_number); // local_tag num
530  avio_wb32(pb, 18); // item size, always 18 according to the specs
531 
532  for (i = 0; i < FF_ARRAY_ELEMS(mxf_local_tag_batch); i++) {
533  avio_wb16(pb, mxf_local_tag_batch[i].local_tag);
534  avio_write(pb, mxf_local_tag_batch[i].uid, 16);
535  }
536  if (mxf->store_user_comments)
537  for (i = 0; i < FF_ARRAY_ELEMS(mxf_user_comments_local_tag); i++) {
538  avio_wb16(pb, mxf_user_comments_local_tag[i].local_tag);
539  avio_write(pb, mxf_user_comments_local_tag[i].uid, 16);
540  }
541  if (avc_tags_count > 0)
542  mxf_write_local_tags(pb, mxf_avc_subdescriptor_local_tags, avc_tags_count);
543 }
544 
545 static void mxf_write_local_tag(AVIOContext *pb, int size, int tag)
546 {
547  avio_wb16(pb, tag);
548  avio_wb16(pb, size);
549 }
550 
551 static void mxf_write_metadata_key(AVIOContext *pb, unsigned int value)
552 {
554  avio_wb24(pb, value);
555 }
556 
558 {
560  while (uls->uid[0]) {
561  if (type == uls->id)
562  break;
563  uls++;
564  }
565  return uls;
566 }
567 
568 //one EC -> one descriptor. N ECs -> MultipleDescriptor + N descriptors
569 #define DESCRIPTOR_COUNT(essence_container_count) \
570  (essence_container_count > 1 ? essence_container_count + 1 : essence_container_count)
571 
573 {
574  MXFContext *c = s->priv_data;
575  AVIOContext *pb = s->pb;
576  int i;
577 
579  av_log(s,AV_LOG_DEBUG, "essence container count:%d\n", c->essence_container_count);
580  for (i = 0; i < s->nb_streams; i++) {
581  MXFStreamContext *sc = s->streams[i]->priv_data;
582  // check first track of essence container type and only write it once
583  if (sc->track_essence_element_key[15] != 0)
584  continue;
585  avio_write(pb, *sc->container_ul, 16);
586  if (c->essence_container_count == 1)
587  break;
588  }
589 
590  if (c->essence_container_count > 1)
591  avio_write(pb, multiple_desc_ul, 16);
592 }
593 
595 {
596  MXFContext *mxf = s->priv_data;
597  AVIOContext *pb = s->pb;
598 
599  mxf_write_metadata_key(pb, 0x012f00);
600  PRINT_KEY(s, "preface key", pb->buf_ptr - 16);
602 
603  // write preface set uid
604  mxf_write_local_tag(pb, 16, 0x3C0A);
605  mxf_write_uuid(pb, Preface, 0);
606  PRINT_KEY(s, "preface uid", pb->buf_ptr - 16);
607 
608  // last modified date
609  mxf_write_local_tag(pb, 8, 0x3B02);
610  avio_wb64(pb, mxf->timestamp);
611 
612  // write version
613  mxf_write_local_tag(pb, 2, 0x3B05);
614  avio_wb16(pb, 259); // v1.3
615 
616  // Object Model Version
617  mxf_write_local_tag(pb, 4, 0x3B07);
618  avio_wb32(pb, 1);
619 
620  // write identification_refs
621  mxf_write_local_tag(pb, 16 + 8, 0x3B06);
622  mxf_write_refs_count(pb, 1);
624 
625  // write content_storage_refs
626  mxf_write_local_tag(pb, 16, 0x3B03);
628 
629  // operational pattern
630  mxf_write_local_tag(pb, 16, 0x3B09);
631  if (s->oformat == &ff_mxf_opatom_muxer)
632  avio_write(pb, opatom_ul, 16);
633  else
634  avio_write(pb, op1a_ul, 16);
635 
636  // write essence_container_refs
637  mxf_write_local_tag(pb, 8 + 16LL * DESCRIPTOR_COUNT(mxf->essence_container_count), 0x3B0A);
639 
640  // write dm_scheme_refs
641  mxf_write_local_tag(pb, 8, 0x3B0B);
642  avio_wb64(pb, 0);
643 }
644 
645 /*
646  * Returns the length of the UTF-16 string, in 16-bit characters, that would result
647  * from decoding the utf-8 string.
648  */
649 static uint64_t mxf_utf16len(const char *utf8_str)
650 {
651  const uint8_t *q = utf8_str;
652  uint64_t size = 0;
653  while (*q) {
654  uint32_t ch;
655  GET_UTF8(ch, *q++, goto invalid;)
656  if (ch < 0x10000)
657  size++;
658  else
659  size += 2;
660  continue;
661 invalid:
662  av_log(NULL, AV_LOG_ERROR, "Invalid UTF8 sequence in mxf_utf16len\n\n");
663  }
664  size += 1;
665  return size;
666 }
667 
668 /*
669  * Returns the calculated length a local tag containing an utf-8 string as utf-16
670  */
671 static int mxf_utf16_local_tag_length(const char *utf8_str)
672 {
673  uint64_t size;
674 
675  if (!utf8_str)
676  return 0;
677 
678  size = mxf_utf16len(utf8_str);
679  if (size >= UINT16_MAX/2) {
680  av_log(NULL, AV_LOG_ERROR, "utf16 local tag size %"PRIx64" invalid (too large), ignoring\n", size);
681  return 0;
682  }
683 
684  return 4 + size * 2;
685 }
686 
687 /*
688  * Write a local tag containing an utf-8 string as utf-16
689  */
690 static void mxf_write_local_tag_utf16(AVIOContext *pb, int tag, const char *value)
691 {
692  uint64_t size = mxf_utf16len(value);
693 
694  if (size >= UINT16_MAX/2) {
695  av_log(NULL, AV_LOG_ERROR, "utf16 local tag size %"PRIx64" invalid (too large), ignoring\n", size);
696  return;
697  }
698 
699  mxf_write_local_tag(pb, size*2, tag);
700  avio_put_str16be(pb, value);
701 }
702 
704  AVIOContext *pb = s->pb;
705 
706  if (s->flags & AVFMT_FLAG_BITEXACT) {
707  avio_wb16(pb, 0); // major
708  avio_wb16(pb, 0); // minor
709  avio_wb16(pb, 0); // tertiary
710  } else {
711  avio_wb16(pb, LIBAVFORMAT_VERSION_MAJOR); // major
712  avio_wb16(pb, LIBAVFORMAT_VERSION_MINOR); // minor
713  avio_wb16(pb, LIBAVFORMAT_VERSION_MICRO); // tertiary
714  }
715  avio_wb16(pb, 0); // patch
716  avio_wb16(pb, 0); // release
717 }
718 
720 {
721  MXFContext *mxf = s->priv_data;
722  AVIOContext *pb = s->pb;
723  const char *company = "FFmpeg";
724  const char *product = s->oformat != &ff_mxf_opatom_muxer ? "OP1a Muxer" : "OPAtom Muxer";
725  const char *version;
726  int length;
727 
728  mxf_write_metadata_key(pb, 0x013000);
729  PRINT_KEY(s, "identification key", pb->buf_ptr - 16);
730 
731  version = s->flags & AVFMT_FLAG_BITEXACT ?
733  length = 100 +mxf_utf16_local_tag_length(company) +
734  mxf_utf16_local_tag_length(product) +
736  klv_encode_ber_length(pb, length);
737 
738  // write uid
739  mxf_write_local_tag(pb, 16, 0x3C0A);
741  PRINT_KEY(s, "identification uid", pb->buf_ptr - 16);
742 
743  // write generation uid
744  mxf_write_local_tag(pb, 16, 0x3C09);
746  mxf_write_local_tag_utf16(pb, 0x3C01, company); // Company Name
747  mxf_write_local_tag_utf16(pb, 0x3C02, product); // Product Name
748 
749  mxf_write_local_tag(pb, 10, 0x3C03); // Product Version
750  store_version(s);
751 
752  mxf_write_local_tag_utf16(pb, 0x3C04, version); // Version String
753 
754  // write product uid
755  mxf_write_local_tag(pb, 16, 0x3C05);
757 
758  // modification date
759  mxf_write_local_tag(pb, 8, 0x3C06);
760  avio_wb64(pb, mxf->timestamp);
761 
762  mxf_write_local_tag(pb, 10, 0x3C07); // Toolkit Version
763  store_version(s);
764 }
765 
766 static void mxf_write_content_storage(AVFormatContext *s, MXFPackage *packages, int package_count)
767 {
768  AVIOContext *pb = s->pb;
769  int i;
770 
771  mxf_write_metadata_key(pb, 0x011800);
772  PRINT_KEY(s, "content storage key", pb->buf_ptr - 16);
773  klv_encode_ber_length(pb, 60 + (16 * package_count));
774 
775  // write uid
776  mxf_write_local_tag(pb, 16, 0x3C0A);
778  PRINT_KEY(s, "content storage uid", pb->buf_ptr - 16);
779 
780  // write package reference
781  mxf_write_local_tag(pb, 16 * package_count + 8, 0x1901);
782  mxf_write_refs_count(pb, package_count);
783  for (i = 0; i < package_count; i++) {
784  mxf_write_uuid(pb, packages[i].type, packages[i].instance);
785  }
786 
787  // write essence container data
788  mxf_write_local_tag(pb, 8 + 16, 0x1902);
789  mxf_write_refs_count(pb, 1);
791 }
792 
793 static void mxf_write_track(AVFormatContext *s, AVStream *st, MXFPackage *package)
794 {
795  MXFContext *mxf = s->priv_data;
796  AVIOContext *pb = s->pb;
797  MXFStreamContext *sc = st->priv_data;
798 
799  mxf_write_metadata_key(pb, 0x013b00);
800  PRINT_KEY(s, "track key", pb->buf_ptr - 16);
801  klv_encode_ber_length(pb, 80);
802 
803  // write track uid
804  mxf_write_local_tag(pb, 16, 0x3C0A);
806  PRINT_KEY(s, "track uid", pb->buf_ptr - 16);
807 
808  // write track id
809  mxf_write_local_tag(pb, 4, 0x4801);
810  avio_wb32(pb, st->index+2);
811 
812  // write track number
813  mxf_write_local_tag(pb, 4, 0x4804);
814  if (package->type == MaterialPackage)
815  avio_wb32(pb, 0); // track number of material package is 0
816  else
817  avio_write(pb, sc->track_essence_element_key + 12, 4);
818 
819  // write edit rate
820  mxf_write_local_tag(pb, 8, 0x4B01);
821 
822  if (st == mxf->timecode_track && s->oformat == &ff_mxf_opatom_muxer) {
823  avio_wb32(pb, mxf->tc.rate.num);
824  avio_wb32(pb, mxf->tc.rate.den);
825  } else {
826  avio_wb32(pb, mxf->time_base.den);
827  avio_wb32(pb, mxf->time_base.num);
828  }
829 
830  // write origin
831  mxf_write_local_tag(pb, 8, 0x4B02);
832  avio_wb64(pb, 0);
833 
834  // write sequence refs
835  mxf_write_local_tag(pb, 16, 0x4803);
837 }
838 
839 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 };
840 
842 {
843  MXFContext *mxf = s->priv_data;
844  AVIOContext *pb = s->pb;
845 
846  // find data define uls
847  mxf_write_local_tag(pb, 16, 0x0201);
848  if (st == mxf->timecode_track)
850  else {
851  const MXFCodecUL *data_def_ul = mxf_get_data_definition_ul(st->codecpar->codec_type);
852  avio_write(pb, data_def_ul->uid, 16);
853  }
854 
855  // write duration
856  mxf_write_local_tag(pb, 8, 0x0202);
857 
858  if (st != mxf->timecode_track && s->oformat == &ff_mxf_opatom_muxer && st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
859  avio_wb64(pb, mxf->body_offset / mxf->edit_unit_byte_count);
860  } else {
861  avio_wb64(pb, mxf->duration);
862  }
863 }
864 
866 {
867  MXFContext *mxf = s->priv_data;
868  AVIOContext *pb = s->pb;
869  enum MXFMetadataSetType component;
870 
871  mxf_write_metadata_key(pb, 0x010f00);
872  PRINT_KEY(s, "sequence key", pb->buf_ptr - 16);
873  klv_encode_ber_length(pb, 80);
874 
875  mxf_write_local_tag(pb, 16, 0x3C0A);
877 
878  PRINT_KEY(s, "sequence uid", pb->buf_ptr - 16);
880 
881  // write structural component
882  mxf_write_local_tag(pb, 16 + 8, 0x1001);
883  mxf_write_refs_count(pb, 1);
884  if (st == mxf->timecode_track)
885  component = TimecodeComponent;
886  else
887  component = SourceClip;
888 
889  mxf_write_uuid(pb, component, mxf->track_instance_count);
890 }
891 
893 {
894  MXFContext *mxf = s->priv_data;
895  AVIOContext *pb = s->pb;
896 
897  mxf_write_metadata_key(pb, 0x011400);
898  klv_encode_ber_length(pb, 75);
899 
900  // UID
901  mxf_write_local_tag(pb, 16, 0x3C0A);
903 
905 
906  // Start Time Code
907  mxf_write_local_tag(pb, 8, 0x1501);
908  avio_wb64(pb, mxf->tc.start);
909 
910  // Rounded Time Code Base
911  mxf_write_local_tag(pb, 2, 0x1502);
912  avio_wb16(pb, mxf->timecode_base);
913 
914  // Drop Frame
915  mxf_write_local_tag(pb, 1, 0x1503);
916  avio_w8(pb, !!(mxf->tc.flags & AV_TIMECODE_FLAG_DROPFRAME));
917 }
918 
920 {
921  MXFContext *mxf = s->priv_data;
922  AVIOContext *pb = s->pb;
923  int i;
924 
925  mxf_write_metadata_key(pb, 0x011100);
926  PRINT_KEY(s, "sturctural component key", pb->buf_ptr - 16);
927  klv_encode_ber_length(pb, 108);
928 
929  // write uid
930  mxf_write_local_tag(pb, 16, 0x3C0A);
932 
933  PRINT_KEY(s, "structural component uid", pb->buf_ptr - 16);
935 
936  // write start_position
937  mxf_write_local_tag(pb, 8, 0x1201);
938  avio_wb64(pb, 0);
939 
940  // write source package uid, end of the reference
941  mxf_write_local_tag(pb, 32, 0x1101);
942  if (!package->ref) {
943  for (i = 0; i < 4; i++)
944  avio_wb64(pb, 0);
945  } else
946  mxf_write_umid(s, package->ref->instance);
947 
948  // write source track id
949  mxf_write_local_tag(pb, 4, 0x1102);
950  if (package->type == SourcePackage && !package->ref)
951  avio_wb32(pb, 0);
952  else
953  avio_wb32(pb, st->index+2);
954 }
955 
957 {
958  AVIOContext *pb = s->pb;
959 
960  mxf_write_metadata_key(pb, 0x012e00);
961  PRINT_KEY(s, "tape descriptor key", pb->buf_ptr - 16);
962  klv_encode_ber_length(pb, 20);
963  mxf_write_local_tag(pb, 16, 0x3C0A);
965  PRINT_KEY(s, "tape_desc uid", pb->buf_ptr - 16);
966 }
967 
968 
970 {
971  MXFContext *mxf = s->priv_data;
972  AVIOContext *pb = s->pb;
973  const uint8_t *ul;
974  int i;
975 
976  mxf_write_metadata_key(pb, 0x014400);
977  PRINT_KEY(s, "multiple descriptor key", pb->buf_ptr - 16);
978  klv_encode_ber_length(pb, 64 + 16LL * s->nb_streams);
979 
980  mxf_write_local_tag(pb, 16, 0x3C0A);
982  PRINT_KEY(s, "multi_desc uid", pb->buf_ptr - 16);
983 
984  // write sample rate
985  mxf_write_local_tag(pb, 8, 0x3001);
986  avio_wb32(pb, mxf->time_base.den);
987  avio_wb32(pb, mxf->time_base.num);
988 
989  // write essence container ul
990  mxf_write_local_tag(pb, 16, 0x3004);
991  if (mxf->essence_container_count > 1)
992  ul = multiple_desc_ul;
993  else {
994  MXFStreamContext *sc = s->streams[0]->priv_data;
995  ul = *sc->container_ul;
996  }
997  avio_write(pb, ul, 16);
998 
999  // write sub descriptor refs
1000  mxf_write_local_tag(pb, s->nb_streams * 16 + 8, 0x3F01);
1002  for (i = 0; i < s->nb_streams; i++)
1003  mxf_write_uuid(pb, SubDescriptor, i);
1004 }
1005 
1007 {
1008  MXFContext *mxf = s->priv_data;
1009  MXFStreamContext *sc = st->priv_data;
1010  AVIOContext *pb = s->pb;
1011  int64_t pos;
1012 
1013  avio_write(pb, key, 16);
1014  klv_encode_ber4_length(pb, 0);
1015  pos = avio_tell(pb);
1016 
1017  mxf_write_local_tag(pb, 16, 0x3C0A);
1019 
1020  mxf_write_local_tag(pb, 4, 0x3006);
1021  avio_wb32(pb, st->index+2);
1022 
1023  mxf_write_local_tag(pb, 8, 0x3001);
1024  if (s->oformat == &ff_mxf_d10_muxer) {
1025  avio_wb32(pb, mxf->time_base.den);
1026  avio_wb32(pb, mxf->time_base.num);
1027  } else {
1028  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE ||
1030  avio_wb32(pb, st->codecpar->sample_rate);
1031  avio_wb32(pb, 1);
1032  } else {
1033  avio_wb32(pb, mxf->time_base.den);
1034  avio_wb32(pb, mxf->time_base.num);
1035  }
1036  }
1037 
1038  mxf_write_local_tag(pb, 16, 0x3004);
1039  avio_write(pb, *sc->container_ul, 16);
1040 
1041  return pos;
1042 }
1043 
1044 static const UID mxf_s436m_anc_descriptor_key = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5c,0x00 };
1045 static const UID mxf_mpegvideo_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 };
1046 static const UID mxf_wav_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 };
1047 static const UID mxf_aes3_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 };
1048 static const UID mxf_cdci_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x28,0x00 };
1049 static const UID mxf_generic_sound_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x42,0x00 };
1050 
1051 static const UID mxf_avc_subdescriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6E,0x00 };
1052 
1054 {
1055  switch (trc){
1056  case AVCOL_TRC_GAMMA28 :
1057  case AVCOL_TRC_GAMMA22 :
1058  memcpy(ul, ((UID){0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x01,0x01,0x01,0x01,0x00,0x00}), 16);
1059  return 0;
1060  case AVCOL_TRC_BT709 :
1061  case AVCOL_TRC_SMPTE170M :
1062  memcpy(ul, ((UID){0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x01,0x01,0x01,0x02,0x00,0x00}), 16);
1063  return 0;
1064  case AVCOL_TRC_SMPTE240M :
1065  memcpy(ul, ((UID){0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x01,0x01,0x01,0x03,0x00,0x00}), 16);
1066  return 0;
1067  case AVCOL_TRC_BT1361_ECG:
1068  memcpy(ul, ((UID){0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x06,0x04,0x01,0x01,0x01,0x01,0x05,0x00,0x00}), 16);
1069  return 0;
1070  case AVCOL_TRC_LINEAR :
1071  memcpy(ul, ((UID){0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x06,0x04,0x01,0x01,0x01,0x01,0x06,0x00,0x00}), 16);
1072  return 0;
1073  case AVCOL_TRC_SMPTE428 :
1074  memcpy(ul, ((UID){0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x08,0x04,0x01,0x01,0x01,0x01,0x07,0x00,0x00}), 16);
1075  return 0;
1076  default:
1077  return -1;
1078  }
1079 }
1080 
1081 static int64_t mxf_write_cdci_common(AVFormatContext *s, AVStream *st, const UID key)
1082 {
1083  MXFStreamContext *sc = st->priv_data;
1084  AVIOContext *pb = s->pb;
1085  int stored_width = 0;
1086  int stored_height = (st->codecpar->height+15)/16*16;
1087  int display_height;
1088  int f1, f2;
1089  UID transfer_ul = {0};
1090  int64_t pos = mxf_write_generic_desc(s, st, key);
1091 
1092  get_trc(transfer_ul, st->codecpar->color_trc);
1093 
1094  if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO) {
1095  if (st->codecpar->height == 1080)
1096  stored_width = 1920;
1097  else if (st->codecpar->height == 720)
1098  stored_width = 1280;
1099  }
1100  if (!stored_width)
1101  stored_width = (st->codecpar->width+15)/16*16;
1102 
1103  mxf_write_local_tag(pb, 4, 0x3203);
1104  avio_wb32(pb, stored_width);
1105 
1106  mxf_write_local_tag(pb, 4, 0x3202);
1107  avio_wb32(pb, stored_height>>sc->interlaced);
1108 
1109  if (s->oformat == &ff_mxf_d10_muxer) {
1110  //Stored F2 Offset
1111  mxf_write_local_tag(pb, 4, 0x3216);
1112  avio_wb32(pb, 0);
1113 
1114  //Image Start Offset
1115  mxf_write_local_tag(pb, 4, 0x3213);
1116  avio_wb32(pb, 0);
1117 
1118  //Image End Offset
1119  mxf_write_local_tag(pb, 4, 0x3214);
1120  avio_wb32(pb, 0);
1121  }
1122 
1123  //Sampled width
1124  mxf_write_local_tag(pb, 4, 0x3205);
1125  avio_wb32(pb, stored_width);
1126 
1127  //Samples height
1128  mxf_write_local_tag(pb, 4, 0x3204);
1129  avio_wb32(pb, st->codecpar->height>>sc->interlaced);
1130 
1131  //Sampled X Offset
1132  mxf_write_local_tag(pb, 4, 0x3206);
1133  avio_wb32(pb, 0);
1134 
1135  //Sampled Y Offset
1136  mxf_write_local_tag(pb, 4, 0x3207);
1137  avio_wb32(pb, 0);
1138 
1139  mxf_write_local_tag(pb, 4, 0x3209);
1140  avio_wb32(pb, stored_width);
1141 
1142  if (st->codecpar->height == 608) // PAL + VBI
1143  display_height = 576;
1144  else if (st->codecpar->height == 512) // NTSC + VBI
1145  display_height = 486;
1146  else
1147  display_height = st->codecpar->height;
1148 
1149  mxf_write_local_tag(pb, 4, 0x3208);
1150  avio_wb32(pb, display_height>>sc->interlaced);
1151 
1152  // display X offset
1153  mxf_write_local_tag(pb, 4, 0x320A);
1154  avio_wb32(pb, 0);
1155 
1156  // display Y offset
1157  mxf_write_local_tag(pb, 4, 0x320B);
1158  avio_wb32(pb, (st->codecpar->height - display_height)>>sc->interlaced);
1159 
1160  if (sc->interlaced) {
1161  //Display F2 Offset
1162  mxf_write_local_tag(pb, 4, 0x3217);
1163  avio_wb32(pb, -((st->codecpar->height - display_height)&1));
1164  }
1165 
1166  // component depth
1167  mxf_write_local_tag(pb, 4, 0x3301);
1168  avio_wb32(pb, sc->component_depth);
1169 
1170  // horizontal subsampling
1171  mxf_write_local_tag(pb, 4, 0x3302);
1172  avio_wb32(pb, sc->h_chroma_sub_sample);
1173 
1174  // vertical subsampling
1175  mxf_write_local_tag(pb, 4, 0x3308);
1176  avio_wb32(pb, sc->v_chroma_sub_sample);
1177 
1178  // color siting
1179  mxf_write_local_tag(pb, 1, 0x3303);
1180  avio_w8(pb, sc->color_siting);
1181 
1182  // Padding Bits
1183  mxf_write_local_tag(pb, 2, 0x3307);
1184  avio_wb16(pb, 0);
1185 
1187  int black = 0,
1188  white = (1<<sc->component_depth) - 1,
1189  color = (1<<sc->component_depth) - 1;
1190  if (st->codecpar->color_range == AVCOL_RANGE_MPEG) {
1191  black = 1 << (sc->component_depth - 4);
1192  white = 235 << (sc->component_depth - 8);
1193  color = (14 << (sc->component_depth - 4)) + 1;
1194  }
1195  mxf_write_local_tag(pb, 4, 0x3304);
1196  avio_wb32(pb, black);
1197  mxf_write_local_tag(pb, 4, 0x3305);
1198  avio_wb32(pb, white);
1199  mxf_write_local_tag(pb, 4, 0x3306);
1200  avio_wb32(pb, color);
1201  }
1202 
1203  if (sc->signal_standard) {
1204  mxf_write_local_tag(pb, 1, 0x3215);
1205  avio_w8(pb, sc->signal_standard);
1206  }
1207 
1208  // frame layout
1209  mxf_write_local_tag(pb, 1, 0x320C);
1210  avio_w8(pb, sc->interlaced);
1211 
1212  // video line map
1213  switch (st->codecpar->height) {
1214  case 576: f1 = 23; f2 = st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO ? 335 : 336; break;
1215  case 608: f1 = 7; f2 = 320; break;
1216  case 480: f1 = 20; f2 = st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO ? 285 : 283; break;
1217  case 512: f1 = 7; f2 = 270; break;
1218  case 720: f1 = 26; f2 = 0; break; // progressive
1219  case 1080: f1 = 21; f2 = 584; break;
1220  default: f1 = 0; f2 = 0; break;
1221  }
1222 
1223  if (!sc->interlaced && f2) {
1224  f2 = 0;
1225  f1 *= 2;
1226  }
1227 
1228 
1229  mxf_write_local_tag(pb, 16, 0x320D);
1230  avio_wb32(pb, 2);
1231  avio_wb32(pb, 4);
1232  avio_wb32(pb, f1);
1233  avio_wb32(pb, f2);
1234 
1235  mxf_write_local_tag(pb, 8, 0x320E);
1236  avio_wb32(pb, sc->aspect_ratio.num);
1237  avio_wb32(pb, sc->aspect_ratio.den);
1238 
1239  //Transfer characteristic
1240  if (transfer_ul[0]) {
1241  mxf_write_local_tag(pb, 16, 0x3210);
1242  avio_write(pb, transfer_ul, 16);
1243  };
1244 
1245  mxf_write_local_tag(pb, 16, 0x3201);
1246  avio_write(pb, *sc->codec_ul, 16);
1247 
1248  if (sc->interlaced && sc->field_dominance) {
1249  mxf_write_local_tag(pb, 1, 0x3212);
1250  avio_w8(pb, sc->field_dominance);
1251  }
1252 
1253  if (st->codecpar->codec_id == AV_CODEC_ID_H264 && !sc->avc_intra) {
1254  // write avc sub descriptor ref
1255  mxf_write_local_tag(pb, 8 + 16, 0x8100);
1256  mxf_write_refs_count(pb, 1);
1258  }
1259 
1260  return pos;
1261 }
1262 
1263 static void mxf_update_klv_size(AVIOContext *pb, int64_t pos)
1264 {
1265  int64_t cur_pos = avio_tell(pb);
1266  int size = cur_pos - pos;
1267  avio_seek(pb, pos - 4, SEEK_SET);
1268  klv_encode_ber4_length(pb, size);
1269  avio_seek(pb, cur_pos, SEEK_SET);
1270 }
1271 
1273 {
1274  AVIOContext *pb = s->pb;
1275  int64_t pos;
1276 
1278  klv_encode_ber4_length(pb, 0);
1279  pos = avio_tell(pb);
1280 
1281  mxf_write_local_tag(pb, 16, 0x3C0A);
1283 
1284  mxf_write_local_tag(pb, 1, 0x8200);
1285  avio_w8(pb, 0xFF); // AVC Decoding Delay, unknown
1286 
1287  mxf_write_local_tag(pb, 1, 0x8201);
1288  avio_w8(pb, st->codecpar->profile); // AVC Profile
1289 
1290  mxf_write_local_tag(pb, 1, 0x8202);
1291  avio_w8(pb, st->codecpar->level); // AVC Level
1292 
1293  mxf_update_klv_size(s->pb, pos);
1294 }
1295 
1297 {
1298  int64_t pos = mxf_write_cdci_common(s, st, mxf_cdci_descriptor_key);
1299  mxf_update_klv_size(s->pb, pos);
1300 
1301  if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
1302  mxf_write_avc_subdesc(s, st);
1303  }
1304 }
1305 
1307 {
1308  MXFStreamContext *sc = st->priv_data;
1309  if (sc->avc_intra) {
1310  mxf_write_mpegvideo_desc(s, st);
1311  } else {
1312  int64_t pos = mxf_write_cdci_common(s, st, mxf_cdci_descriptor_key);
1313  mxf_update_klv_size(s->pb, pos);
1314  mxf_write_avc_subdesc(s, st);
1315  }
1316 }
1317 
1319 {
1321  mxf_update_klv_size(s->pb, pos);
1322 }
1323 
1325 {
1326  AVIOContext *pb = s->pb;
1327  MXFStreamContext *sc = st->priv_data;
1328  int profile_and_level = (st->codecpar->profile<<4) | st->codecpar->level;
1330 
1331  if (st->codecpar->codec_id != AV_CODEC_ID_H264) {
1332  // bit rate
1333  mxf_write_local_tag(pb, 4, 0x8000);
1334  avio_wb32(pb, sc->video_bit_rate);
1335 
1336  // profile and level
1337  mxf_write_local_tag(pb, 1, 0x8007);
1338  if (!st->codecpar->profile)
1339  profile_and_level |= 0x80; // escape bit
1340  avio_w8(pb, profile_and_level);
1341 
1342  // low delay
1343  mxf_write_local_tag(pb, 1, 0x8003);
1344  avio_w8(pb, sc->low_delay);
1345 
1346  // closed gop
1347  mxf_write_local_tag(pb, 1, 0x8004);
1348  avio_w8(pb, sc->seq_closed_gop);
1349 
1350  // max gop
1351  mxf_write_local_tag(pb, 2, 0x8006);
1352  avio_wb16(pb, sc->max_gop);
1353 
1354  // b picture count
1355  mxf_write_local_tag(pb, 2, 0x8008);
1356  avio_wb16(pb, sc->b_picture_count);
1357  }
1358 
1359  mxf_update_klv_size(pb, pos);
1360 }
1361 
1363 {
1364  AVIOContext *pb = s->pb;
1365  MXFContext *mxf = s->priv_data;
1366  int show_warnings = !mxf->footer_partition_offset;
1367  int64_t pos = mxf_write_generic_desc(s, st, key);
1368 
1369  if (s->oformat == &ff_mxf_opatom_muxer) {
1370  mxf_write_local_tag(pb, 8, 0x3002);
1371  avio_wb64(pb, mxf->body_offset / mxf->edit_unit_byte_count);
1372  }
1373 
1374  // audio locked
1375  mxf_write_local_tag(pb, 1, 0x3D02);
1376  avio_w8(pb, 1);
1377 
1378  // write audio sampling rate
1379  mxf_write_local_tag(pb, 8, 0x3D03);
1380  avio_wb32(pb, st->codecpar->sample_rate);
1381  avio_wb32(pb, 1);
1382 
1383  if (s->oformat == &ff_mxf_d10_muxer) {
1384  mxf_write_local_tag(pb, 1, 0x3D04);
1385  avio_w8(pb, 0);
1386  }
1387 
1388  mxf_write_local_tag(pb, 4, 0x3D07);
1389  if (mxf->channel_count == -1) {
1390  if (show_warnings && (s->oformat == &ff_mxf_d10_muxer) && (st->codecpar->channels != 4) && (st->codecpar->channels != 8))
1391  av_log(s, AV_LOG_WARNING, "the number of audio channels shall be 4 or 8 : the output will not comply to MXF D-10 specs, use -d10_channelcount to fix this\n");
1392  avio_wb32(pb, st->codecpar->channels);
1393  } else if (s->oformat == &ff_mxf_d10_muxer) {
1394  if (show_warnings && (mxf->channel_count < st->codecpar->channels))
1395  av_log(s, AV_LOG_WARNING, "d10_channelcount < actual number of audio channels : some channels will be discarded\n");
1396  if (show_warnings && (mxf->channel_count != 4) && (mxf->channel_count != 8))
1397  av_log(s, AV_LOG_WARNING, "d10_channelcount shall be set to 4 or 8 : the output will not comply to MXF D-10 specs\n");
1398  avio_wb32(pb, mxf->channel_count);
1399  } else {
1400  avio_wb32(pb, st->codecpar->channels);
1401  }
1402 
1403  mxf_write_local_tag(pb, 4, 0x3D01);
1405 
1406  return pos;
1407 }
1408 
1409 static int64_t mxf_write_wav_common(AVFormatContext *s, AVStream *st, const UID key)
1410 {
1411  AVIOContext *pb = s->pb;
1412  int64_t pos = mxf_write_generic_sound_common(s, st, key);
1413 
1414  mxf_write_local_tag(pb, 2, 0x3D0A);
1415  avio_wb16(pb, st->codecpar->block_align);
1416 
1417  // avg bytes per sec
1418  mxf_write_local_tag(pb, 4, 0x3D09);
1420 
1421  return pos;
1422 }
1423 
1425 {
1426  int64_t pos = mxf_write_wav_common(s, st, mxf_wav_descriptor_key);
1427  mxf_update_klv_size(s->pb, pos);
1428 }
1429 
1431 {
1432  int64_t pos = mxf_write_wav_common(s, st, mxf_aes3_descriptor_key);
1433  mxf_update_klv_size(s->pb, pos);
1434 }
1435 
1437 {
1439  mxf_update_klv_size(s->pb, pos);
1440 }
1441 
1442 static const uint8_t mxf_indirect_value_utf16le[] = { 0x4c,0x00,0x02,0x10,0x01,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
1443 
1444 static int mxf_write_tagged_value(AVFormatContext *s, const char* name, const char* value)
1445 {
1446  MXFContext *mxf = s->priv_data;
1447  AVIOContext *pb = s->pb;
1448  int name_size = mxf_utf16_local_tag_length(name);
1449  int indirect_value_size = 13 + mxf_utf16_local_tag_length(value);
1450 
1451  if (!name_size || indirect_value_size == 13)
1452  return 1;
1453 
1454  mxf_write_metadata_key(pb, 0x013f00);
1455  klv_encode_ber_length(pb, 24 + name_size + indirect_value_size);
1456 
1457  // write instance UID
1458  mxf_write_local_tag(pb, 16, 0x3C0A);
1460 
1461  // write name
1462  mxf_write_local_tag_utf16(pb, 0x5001, name); // Name
1463 
1464  // write indirect value
1465  mxf_write_local_tag(pb, indirect_value_size, 0x5003);
1467  avio_put_str16le(pb, value);
1468 
1469  mxf->tagged_value_count++;
1470  return 0;
1471 }
1472 
1474 {
1475  MXFContext *mxf = s->priv_data;
1476  AVDictionaryEntry *t = NULL;
1477  int count = 0;
1478 
1479  while ((t = av_dict_get(m, "comment_", t, AV_DICT_IGNORE_SUFFIX))) {
1480  if (mxf->tagged_value_count >= UINT16_MAX) {
1481  av_log(s, AV_LOG_ERROR, "too many tagged values, ignoring remaining\n");
1482  return count;
1483  }
1484 
1485  if (mxf_write_tagged_value(s, t->key + 8, t->value) == 0)
1486  count++;
1487  }
1488  return count;
1489 }
1490 
1492 {
1493  MXFContext *mxf = s->priv_data;
1494  AVIOContext *pb = s->pb;
1495  int i, track_count = s->nb_streams+1;
1496  int name_size = mxf_utf16_local_tag_length(package->name);
1497  int user_comment_count = 0;
1498 
1499  if (package->type == MaterialPackage) {
1500  if (mxf->store_user_comments)
1501  user_comment_count = mxf_write_user_comments(s, s->metadata);
1502  mxf_write_metadata_key(pb, 0x013600);
1503  PRINT_KEY(s, "Material Package key", pb->buf_ptr - 16);
1504  klv_encode_ber_length(pb, 92 + name_size + (16*track_count) + (16*user_comment_count) + 12LL*mxf->store_user_comments);
1505  } else {
1506  mxf_write_metadata_key(pb, 0x013700);
1507  PRINT_KEY(s, "Source Package key", pb->buf_ptr - 16);
1508  klv_encode_ber_length(pb, 112 + name_size + (16*track_count) + 12LL*mxf->store_user_comments); // 20 bytes length for descriptor reference
1509  }
1510 
1511  // write uid
1512  mxf_write_local_tag(pb, 16, 0x3C0A);
1513  mxf_write_uuid(pb, package->type, package->instance);
1514  av_log(s, AV_LOG_DEBUG, "package type:%d\n", package->type);
1515  PRINT_KEY(s, "package uid", pb->buf_ptr - 16);
1516 
1517  // write package umid
1518  mxf_write_local_tag(pb, 32, 0x4401);
1519  mxf_write_umid(s, package->instance);
1520  PRINT_KEY(s, "package umid second part", pb->buf_ptr - 16);
1521 
1522  // package name
1523  if (name_size)
1524  mxf_write_local_tag_utf16(pb, 0x4402, package->name);
1525 
1526  // package creation date
1527  mxf_write_local_tag(pb, 8, 0x4405);
1528  avio_wb64(pb, mxf->timestamp);
1529 
1530  // package modified date
1531  mxf_write_local_tag(pb, 8, 0x4404);
1532  avio_wb64(pb, mxf->timestamp);
1533 
1534  // write track refs
1535  mxf_write_local_tag(pb, track_count*16 + 8, 0x4403);
1536  mxf_write_refs_count(pb, track_count);
1537  // these are the uuids of the tracks the will be written in mxf_write_track
1538  for (i = 0; i < track_count; i++)
1539  mxf_write_uuid(pb, Track, mxf->track_instance_count + i);
1540 
1541  // write user comment refs
1542  if (mxf->store_user_comments) {
1543  mxf_write_local_tag(pb, user_comment_count*16 + 8, 0x4406);
1544  mxf_write_refs_count(pb, user_comment_count);
1545  for (i = 0; i < user_comment_count; i++)
1546  mxf_write_uuid(pb, TaggedValue, mxf->tagged_value_count - user_comment_count + i);
1547  }
1548 
1549  // write multiple descriptor reference
1550  if (package->type == SourcePackage && package->instance == 1) {
1551  mxf_write_local_tag(pb, 16, 0x4701);
1552  if (s->nb_streams > 1) {
1555  } else
1556  mxf_write_uuid(pb, SubDescriptor, 0);
1557  } else if (package->type == SourcePackage && package->instance == 2) {
1558  mxf_write_local_tag(pb, 16, 0x4701);
1561  }
1562 
1563  /*
1564  * for every 1 track in a package there is 1 sequence and 1 component.
1565  * all 3 of these elements share the same instance number for generating
1566  * there instance uuids. mxf->track_instance_count stores this value.
1567  * mxf->track_instance_count is incremented after a group of all 3 of
1568  * these elements are written.
1569  */
1570 
1571  // write timecode track
1572  mxf_write_track(s, mxf->timecode_track, package);
1573  mxf_write_sequence(s, mxf->timecode_track, package);
1574  mxf_write_timecode_component(s, mxf->timecode_track, package);
1575  mxf->track_instance_count++;
1576 
1577  for (i = 0; i < s->nb_streams; i++) {
1578  AVStream *st = s->streams[i];
1579  mxf_write_track(s, st, package);
1580  mxf_write_sequence(s, st, package);
1581  mxf_write_structural_component(s, st, package);
1582  mxf->track_instance_count++;
1583 
1584  if (package->type == SourcePackage && package->instance == 1) {
1585  MXFStreamContext *sc = st->priv_data;
1586  mxf_essence_container_uls[sc->index].write_desc(s, st);
1587  }
1588  }
1589 }
1590 
1592 {
1593  AVIOContext *pb = s->pb;
1594 
1595  mxf_write_metadata_key(pb, 0x012300);
1596  klv_encode_ber_length(pb, 72);
1597 
1598  mxf_write_local_tag(pb, 16, 0x3C0A); // Instance UID
1600 
1601  mxf_write_local_tag(pb, 32, 0x2701); // Linked Package UID
1602  mxf_write_umid(s, 1);
1603 
1604  mxf_write_local_tag(pb, 4, 0x3F07); // BodySID
1605  avio_wb32(pb, 1);
1606 
1607  mxf_write_local_tag(pb, 4, 0x3F06); // IndexSID
1608  avio_wb32(pb, 2);
1609 
1610  return 0;
1611 }
1612 
1614 {
1615  MXFContext *mxf = s->priv_data;
1616  AVDictionaryEntry *entry = NULL;
1617  AVStream *st = NULL;
1618  int i;
1619  MXFPackage packages[3] = {{0}};
1620  int package_count = 2;
1621  packages[0].type = MaterialPackage;
1622  packages[1].type = SourcePackage;
1623  packages[1].instance = 1;
1624  packages[0].ref = &packages[1];
1625 
1626 
1627  if (entry = av_dict_get(s->metadata, "material_package_name", NULL, 0))
1628  packages[0].name = entry->value;
1629 
1630  if (entry = av_dict_get(s->metadata, "file_package_name", NULL, 0)) {
1631  packages[1].name = entry->value;
1632  } else {
1633  /* check if any of the streams contain a file_package_name */
1634  for (i = 0; i < s->nb_streams; i++) {
1635  st = s->streams[i];
1636  if (entry = av_dict_get(st->metadata, "file_package_name", NULL, 0)) {
1637  packages[1].name = entry->value;
1638  break;
1639  }
1640  }
1641  }
1642 
1643  entry = av_dict_get(s->metadata, "reel_name", NULL, 0);
1644  if (entry) {
1645  packages[2].name = entry->value;
1646  packages[2].type = SourcePackage;
1647  packages[2].instance = 2;
1648  packages[1].ref = &packages[2];
1649  package_count = 3;
1650  }
1651 
1652  mxf_write_preface(s);
1654  mxf_write_content_storage(s, packages, package_count);
1655  mxf->track_instance_count = 0;
1656  for (i = 0; i < package_count; i++)
1657  mxf_write_package(s, &packages[i]);
1659  return 0;
1660 }
1661 
1662 static unsigned klv_fill_size(uint64_t size)
1663 {
1664  unsigned pad = KAG_SIZE - (size & (KAG_SIZE-1));
1665  if (pad < 20) // smallest fill item possible
1666  return pad + KAG_SIZE;
1667  else
1668  return pad & (KAG_SIZE-1);
1669 }
1670 
1672 {
1673  MXFContext *mxf = s->priv_data;
1674  AVIOContext *pb = s->pb;
1675  int i, j, temporal_reordering = 0;
1676  int key_index = mxf->last_key_index;
1677  int prev_non_b_picture = 0;
1678  int audio_frame_size = 0;
1679  int64_t pos;
1680 
1681  av_log(s, AV_LOG_DEBUG, "edit units count %d\n", mxf->edit_units_count);
1682 
1683  if (!mxf->edit_units_count && !mxf->edit_unit_byte_count)
1684  return;
1685 
1687 
1688  klv_encode_ber4_length(pb, 0);
1689  pos = avio_tell(pb);
1690 
1691  // instance id
1692  mxf_write_local_tag(pb, 16, 0x3C0A);
1694 
1695  // index edit rate
1696  mxf_write_local_tag(pb, 8, 0x3F0B);
1697  avio_wb32(pb, mxf->time_base.den);
1698  avio_wb32(pb, mxf->time_base.num);
1699 
1700  // index start position
1701  mxf_write_local_tag(pb, 8, 0x3F0C);
1703 
1704  // index duration
1705  mxf_write_local_tag(pb, 8, 0x3F0D);
1706  if (mxf->edit_unit_byte_count)
1707  avio_wb64(pb, 0); // index table covers whole container
1708  else
1709  avio_wb64(pb, mxf->edit_units_count);
1710 
1711  // edit unit byte count
1712  mxf_write_local_tag(pb, 4, 0x3F05);
1713  avio_wb32(pb, mxf->edit_unit_byte_count);
1714 
1715  // index sid
1716  mxf_write_local_tag(pb, 4, 0x3F06);
1717  avio_wb32(pb, 2);
1718 
1719  // body sid
1720  mxf_write_local_tag(pb, 4, 0x3F07);
1721  avio_wb32(pb, 1);
1722 
1723  // real slice count - 1
1724  mxf_write_local_tag(pb, 1, 0x3F08);
1725  avio_w8(pb, !mxf->edit_unit_byte_count); // only one slice for CBR
1726 
1727  // delta entry array
1728  mxf_write_local_tag(pb, 8 + (s->nb_streams+1)*6, 0x3F09);
1729  avio_wb32(pb, s->nb_streams+1); // num of entries
1730  avio_wb32(pb, 6); // size of one entry
1731  // write system item delta entry
1732  avio_w8(pb, 0);
1733  avio_w8(pb, 0); // slice entry
1734  avio_wb32(pb, 0); // element delta
1735  // write each stream delta entry
1736  for (i = 0; i < s->nb_streams; i++) {
1737  AVStream *st = s->streams[i];
1738  MXFStreamContext *sc = st->priv_data;
1739  avio_w8(pb, sc->temporal_reordering);
1740  if (sc->temporal_reordering)
1741  temporal_reordering = 1;
1742  if (mxf->edit_unit_byte_count) {
1743  avio_w8(pb, 0); // slice number
1744  avio_wb32(pb, sc->slice_offset);
1745  } else if (i == 0) { // video track
1746  avio_w8(pb, 0); // slice number
1747  avio_wb32(pb, KAG_SIZE); // system item size including klv fill
1748  } else { // audio or data track
1749  if (!audio_frame_size) {
1750  audio_frame_size = sc->aic.samples[0]*sc->aic.sample_size;
1751  audio_frame_size += klv_fill_size(audio_frame_size);
1752  }
1753  avio_w8(pb, 1);
1754  avio_wb32(pb, (i-1)*audio_frame_size); // element delta
1755  }
1756  }
1757 
1758  if (!mxf->edit_unit_byte_count) {
1759  MXFStreamContext *sc = s->streams[0]->priv_data;
1760  mxf_write_local_tag(pb, 8 + mxf->edit_units_count*15, 0x3F0A);
1761  avio_wb32(pb, mxf->edit_units_count); // num of entries
1762  avio_wb32(pb, 15); // size of one entry
1763 
1764  for (i = 0; i < mxf->edit_units_count; i++) {
1765  int temporal_offset = 0;
1766 
1767  if (!(mxf->index_entries[i].flags & 0x33)) { // I-frame
1768  sc->max_gop = FFMAX(sc->max_gop, i - mxf->last_key_index);
1769  mxf->last_key_index = key_index;
1770  key_index = i;
1771  }
1772 
1773  if (temporal_reordering) {
1774  int pic_num_in_gop = i - key_index;
1775  if (pic_num_in_gop != mxf->index_entries[i].temporal_ref) {
1776  for (j = key_index; j < mxf->edit_units_count; j++) {
1777  if (pic_num_in_gop == mxf->index_entries[j].temporal_ref)
1778  break;
1779  }
1780  if (j == mxf->edit_units_count)
1781  av_log(s, AV_LOG_WARNING, "missing frames\n");
1782  temporal_offset = j - key_index - pic_num_in_gop;
1783  }
1784  }
1785  avio_w8(pb, temporal_offset);
1786 
1787  if ((mxf->index_entries[i].flags & 0x30) == 0x30) { // back and forward prediction
1788  sc->b_picture_count = FFMAX(sc->b_picture_count, i - prev_non_b_picture);
1789  avio_w8(pb, mxf->last_key_index - i);
1790  } else {
1791  avio_w8(pb, key_index - i); // key frame offset
1792  if ((mxf->index_entries[i].flags & 0x20) == 0x20) // only forward
1793  mxf->last_key_index = key_index;
1794  prev_non_b_picture = i;
1795  }
1796 
1797  if (!(mxf->index_entries[i].flags & 0x33) && // I-frame
1798  mxf->index_entries[i].flags & 0x40 && !temporal_offset)
1799  mxf->index_entries[i].flags |= 0x80; // random access
1800  avio_w8(pb, mxf->index_entries[i].flags);
1801  // stream offset
1802  avio_wb64(pb, mxf->index_entries[i].offset);
1803  if (s->nb_streams > 1)
1804  avio_wb32(pb, mxf->index_entries[i].slice_offset);
1805  else
1806  avio_wb32(pb, 0);
1807  }
1808 
1809  mxf->last_key_index = key_index - mxf->edit_units_count;
1811  mxf->edit_units_count = 0;
1812  }
1813 
1814  mxf_update_klv_size(pb, pos);
1815 }
1816 
1818 {
1819  unsigned pad = klv_fill_size(avio_tell(s->pb));
1820  if (pad) {
1821  avio_write(s->pb, klv_fill_key, 16);
1822  pad -= 16 + 4;
1823  klv_encode_ber4_length(s->pb, pad);
1824  ffio_fill(s->pb, 0, pad);
1825  av_assert1(!(avio_tell(s->pb) & (KAG_SIZE-1)));
1826  }
1827 }
1828 
1829 static int mxf_write_partition(AVFormatContext *s, int bodysid,
1830  int indexsid,
1831  const uint8_t *key, int write_metadata)
1832 {
1833  MXFContext *mxf = s->priv_data;
1834  AVIOContext *pb = s->pb;
1835  int64_t header_byte_count_offset;
1836  unsigned index_byte_count = 0;
1837  uint64_t partition_offset = avio_tell(pb);
1838  int err;
1839 
1840  if (!mxf->edit_unit_byte_count && mxf->edit_units_count)
1841  index_byte_count = 85 + 12+(s->nb_streams+1)*6 +
1842  12+mxf->edit_units_count*15;
1843  else if (mxf->edit_unit_byte_count && indexsid)
1844  index_byte_count = 80;
1845 
1846  if (index_byte_count) {
1847  index_byte_count += 16 + 4; // add encoded ber4 length
1848  index_byte_count += klv_fill_size(index_byte_count);
1849  }
1850 
1851  if (key && !memcmp(key, body_partition_key, 16)) {
1853  sizeof(*mxf->body_partition_offset))) < 0) {
1854  mxf->body_partitions_count = 0;
1855  return err;
1856  }
1857  mxf->body_partition_offset[mxf->body_partitions_count++] = partition_offset;
1858  }
1859 
1860  // write klv
1861  if (key)
1862  avio_write(pb, key, 16);
1863  else
1864  avio_write(pb, body_partition_key, 16);
1865 
1867 
1868  // write partition value
1869  avio_wb16(pb, 1); // majorVersion
1870  avio_wb16(pb, 3); // minorVersion
1871  avio_wb32(pb, KAG_SIZE); // KAGSize
1872 
1873  avio_wb64(pb, partition_offset); // ThisPartition
1874 
1875  if (key && !memcmp(key, body_partition_key, 16) && mxf->body_partitions_count > 1)
1876  avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-2]); // PreviousPartition
1877  else if (key && !memcmp(key, footer_partition_key, 16) && mxf->body_partitions_count)
1878  avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-1]); // PreviousPartition
1879  else
1880  avio_wb64(pb, 0);
1881 
1882  avio_wb64(pb, mxf->footer_partition_offset); // footerPartition
1883 
1884  // set offset
1885  header_byte_count_offset = avio_tell(pb);
1886  avio_wb64(pb, 0); // headerByteCount, update later
1887 
1888  // indexTable
1889  avio_wb64(pb, index_byte_count); // indexByteCount
1890  avio_wb32(pb, index_byte_count ? indexsid : 0); // indexSID
1891 
1892  // BodyOffset
1893  if (bodysid && mxf->edit_units_count && mxf->body_partitions_count && s->oformat != &ff_mxf_opatom_muxer)
1894  avio_wb64(pb, mxf->body_offset);
1895  else
1896  avio_wb64(pb, 0);
1897 
1898  avio_wb32(pb, bodysid); // bodySID
1899 
1900  // operational pattern
1901  if (s->oformat == &ff_mxf_opatom_muxer)
1902  avio_write(pb, opatom_ul, 16);
1903  else
1904  avio_write(pb, op1a_ul, 16);
1905 
1906  // essence container
1908 
1909  if (write_metadata) {
1910  // mark the start of the headermetadata and calculate metadata size
1911  int64_t pos, start;
1912  unsigned header_byte_count;
1913 
1914  mxf_write_klv_fill(s);
1915  start = avio_tell(s->pb);
1917  mxf_write_klv_fill(s);
1919  pos = avio_tell(s->pb);
1920  header_byte_count = pos - start + klv_fill_size(pos);
1921 
1922  // update header_byte_count
1923  avio_seek(pb, header_byte_count_offset, SEEK_SET);
1924  avio_wb64(pb, header_byte_count);
1925  avio_seek(pb, pos, SEEK_SET);
1926  }
1927 
1928  if(key)
1930 
1931  return 0;
1932 }
1933 
1934 static const struct {
1935  int profile;
1937 } mxf_prores_codec_uls[] = {
1938  { FF_PROFILE_PRORES_PROXY, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x01,0x00 } },
1939  { FF_PROFILE_PRORES_LT, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x02,0x00 } },
1940  { FF_PROFILE_PRORES_STANDARD, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x03,0x00 } },
1941  { FF_PROFILE_PRORES_HQ, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x04,0x00 } },
1942  { FF_PROFILE_PRORES_4444, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x05,0x00 } },
1943  { FF_PROFILE_PRORES_XQ, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x06,0x00 } },
1944 };
1945 
1947 {
1948  MXFContext *mxf = s->priv_data;
1949  MXFStreamContext *sc = st->priv_data;
1950  int i, profile;
1951 
1952  if (mxf->header_written)
1953  return 1;
1954 
1955  sc->codec_ul = NULL;
1956  profile = st->codecpar->profile;
1957  for (i = 0; i < FF_ARRAY_ELEMS(mxf_prores_codec_uls); i++) {
1958  if (profile == mxf_prores_codec_uls[i].profile) {
1959  sc->codec_ul = &mxf_prores_codec_uls[i].codec_ul;
1960  break;
1961  }
1962  }
1963  if (!sc->codec_ul)
1964  return 0;
1965 
1966  sc->frame_size = pkt->size;
1967 
1968  return 1;
1969 }
1970 
1971 static const struct {
1972  int cid;
1973  UID codec_ul;
1974 } mxf_dnxhd_codec_uls[] = {
1975  { 1235, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x01,0x00,0x00 } }, // 1080p 10bit HIGH
1976  { 1237, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x03,0x00,0x00 } }, // 1080p 8bit MED
1977  { 1238, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x04,0x00,0x00 } }, // 1080p 8bit HIGH
1978  { 1241, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x07,0x00,0x00 } }, // 1080i 10bit HIGH
1979  { 1242, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x08,0x00,0x00 } }, // 1080i 8bit MED
1980  { 1243, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x09,0x00,0x00 } }, // 1080i 8bit HIGH
1981  { 1244, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x0a,0x00,0x00 } }, // 1080i 8bit TR
1982  { 1250, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x10,0x00,0x00 } }, // 720p 10bit
1983  { 1251, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x11,0x00,0x00 } }, // 720p 8bit HIGH
1984  { 1252, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x12,0x00,0x00 } }, // 720p 8bit MED
1985  { 1253, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x13,0x00,0x00 } }, // 720p 8bit LOW
1986  { 1256, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x16,0x00,0x00 } }, // 1080p 10bit 444
1987  { 1258, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x18,0x00,0x00 } }, // 720p 8bit TR
1988  { 1259, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x19,0x00,0x00 } }, // 1080p 8bit TR
1989  { 1260, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x1a,0x00,0x00 } }, // 1080i 8bit TR MBAFF
1990  { 1270, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x24,0x00,0x00 } }, // DNXHR 444
1991  { 1271, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x25,0x00,0x00 } }, // DNXHR HQX
1992  { 1272, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x26,0x00,0x00 } }, // DNXHR HQ
1993  { 1273, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x27,0x00,0x00 } }, // DNXHR SQ
1994  { 1274, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x28,0x00,0x00 } }, // DNXHR LB
1995 };
1996 
1998 {
1999  MXFContext *mxf = s->priv_data;
2000  MXFStreamContext *sc = st->priv_data;
2001  int i, cid, frame_size = 0;
2002 
2003  if (mxf->header_written)
2004  return 1;
2005 
2006  if (pkt->size < 43)
2007  return 0;
2008 
2009  sc->codec_ul = NULL;
2010  cid = AV_RB32(pkt->data + 0x28);
2011  for (i = 0; i < FF_ARRAY_ELEMS(mxf_dnxhd_codec_uls); i++) {
2012  if (cid == mxf_dnxhd_codec_uls[i].cid) {
2013  sc->codec_ul = &mxf_dnxhd_codec_uls[i].codec_ul;
2014  break;
2015  }
2016  }
2017  if (!sc->codec_ul)
2018  return 0;
2019 
2020  sc->component_depth = 0;
2021  switch (pkt->data[0x21] >> 5) {
2022  case 1: sc->component_depth = 8; break;
2023  case 2: sc->component_depth = 10; break;
2024  case 3: sc->component_depth = 12; break;
2025  }
2026  if (!sc->component_depth)
2027  return 0;
2028 
2029  if ((frame_size = avpriv_dnxhd_get_frame_size(cid)) == DNXHD_VARIABLE) {
2030  frame_size = avpriv_dnxhd_get_hr_frame_size(cid, st->codecpar->width, st->codecpar->height);
2031  }
2032  if (frame_size < 0)
2033  return 0;
2034 
2035  if ((sc->interlaced = avpriv_dnxhd_get_interlaced(cid)) < 0)
2036  return 0;
2037 
2038  if (cid >= 1270) { // RI raster
2040  st->codecpar->width, st->codecpar->height,
2041  INT_MAX);
2042  } else {
2043  sc->aspect_ratio = (AVRational){ 16, 9 };
2044  }
2045 
2046  sc->frame_size = pkt->size;
2047 
2048  return 1;
2049 }
2050 
2051 static const struct {
2053  const UID codec_ul;
2054 } mxf_dv_uls[] = {
2055  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x01,0x01 }, // IEC DV25 525/60
2056  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x01,0x01,0x00 } },
2057  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x02,0x01 }, // IEC DV25 626/50
2058  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x01,0x02,0x00 } },
2059  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x40,0x01 }, // DV25 525/60
2060  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x01,0x00 }, },
2061  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, // DV25 625/50
2062  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x02,0x00 }, },
2063  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x50,0x01 }, // DV50 525/60
2064  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x03,0x00 }, },
2065  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x51,0x01 }, // DV50 625/50
2066  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x04,0x00 }, },
2067  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x60,0x01 }, // DV100 1080/60
2068  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x05,0x00 }, },
2069  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x61,0x01 }, // DV100 1080/50
2070  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x06,0x00 }, },
2071  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x62,0x01 }, // DV100 720/60
2072  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x07,0x00 }, },
2073  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x63,0x01 }, // DV100 720/50
2074  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x08,0x00 }, },
2075 };
2076 
2078 {
2079  MXFContext *mxf = s->priv_data;
2080  MXFStreamContext *sc = st->priv_data;
2081  uint8_t *vs_pack, *vsc_pack;
2082  int apt, ul_index, stype, pal;
2083 
2084  if (mxf->header_written)
2085  return 1;
2086 
2087  // Check for minimal frame size
2088  if (pkt->size < 120000)
2089  return -1;
2090 
2091  apt = pkt->data[4] & 0x7;
2092  vs_pack = pkt->data + 80*5 + 48;
2093  vsc_pack = pkt->data + 80*5 + 53;
2094  stype = vs_pack[3] & 0x1f;
2095  pal = (vs_pack[3] >> 5) & 0x1;
2096 
2097  if ((vsc_pack[2] & 0x07) == 0x02) {
2098  sc->aspect_ratio = (AVRational){ 16, 9 };
2099  } else {
2100  sc->aspect_ratio = (AVRational){ 4, 3 };
2101  }
2102 
2103  sc->interlaced = (vsc_pack[3] >> 4) & 0x01;
2104  // TODO: fix dv encoder to set proper FF/FS value in VSC pack
2105  // and set field dominance accordingly
2106  // av_log(s, AV_LOG_DEBUG, "DV vsc pack ff/ss = %x\n", vsc_pack[2] >> 6);
2107 
2108  switch (stype) {
2109  case 0x18: // DV100 720p
2110  ul_index = 8+pal;
2111  if (sc->interlaced) {
2112  av_log(s, AV_LOG_ERROR, "source marked as interlaced but codec profile is progressive\n");
2113  sc->interlaced = 0;
2114  }
2115  break;
2116  case 0x14: // DV100 1080i
2117  ul_index = 6+pal;
2118  break;
2119  case 0x04: // DV50
2120  ul_index = 4+pal;
2121  break;
2122  default: // DV25
2123  if (!apt) { // IEC
2124  ul_index = 0+pal;
2125  } else {
2126  ul_index = 2+pal;
2127  }
2128  }
2129 
2130  sc->container_ul = &mxf_dv_uls[ul_index].container_ul;
2131  sc->codec_ul = &mxf_dv_uls[ul_index].codec_ul;
2132 
2133  sc->frame_size = pkt->size;
2134 
2135  return 1;
2136 }
2137 
2138 static const struct {
2141  int profile;
2143  int intra_only; // 1 or 0 when there are separate UIDs for Long GOP and Intra, -1 when Intra/LGOP detection can be ignored
2144 } mxf_h264_codec_uls[] = {
2145  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x11,0x01 }, 0, 66, 0, -1 }, // AVC Baseline
2146  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x20,0x01 }, 0, 77, 0, -1 }, // AVC Main
2147  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x30,0x01 }, 0, 88, 0, -1 }, // AVC Extended
2148  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x40,0x01 }, 0, 100, 0, -1 }, // AVC High
2149  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x50,0x01 }, 0, 110, 0, 0 }, // AVC High 10
2150  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x60,0x01 }, 0, 122, 0, 0 }, // AVC High 422
2151  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x70,0x01 }, 0, 244, 0, 0 }, // AVC High 444
2152  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x20,0x01 }, 0, 110, 0, 1 }, // AVC High 10 Intra
2153  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 232960, 110, 1, 1 }, // AVC High 10 Intra RP2027 Class 50 1080/59.94i
2154  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 281088, 110, 1, 1 }, // AVC High 10 Intra RP2027 Class 50 1080/50i
2155  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 232960, 110, 0, 1 }, // AVC High 10 Intra RP2027 Class 50 1080/29.97p
2156  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 281088, 110, 0, 1 }, // AVC High 10 Intra RP2027 Class 50 1080/25p
2157  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x08 }, 116736, 110, 0, 1 }, // AVC High 10 Intra RP2027 Class 50 720/59.94p
2158  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x09 }, 140800, 110, 0, 1 }, // AVC High 10 Intra RP2027 Class 50 720/50p
2159  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x30,0x01 }, 0, 122, 0, 1 }, // AVC High 422 Intra
2160  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x31,0x01 }, 472576, 122, 1, 1 }, // AVC High 422 Intra RP2027 Class 100 1080/59.94i
2161  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x31,0x02 }, 568832, 122, 1, 1 }, // AVC High 422 Intra RP2027 Class 100 1080/50i
2162  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x31,0x03 }, 472576, 122, 0, 1 }, // AVC High 422 Intra RP2027 Class 100 1080/29.97p
2163  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x31,0x04 }, 568832, 122, 0, 1 }, // AVC High 422 Intra RP2027 Class 100 1080/25p
2164  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x31,0x08 }, 236544, 122, 0, 1 }, // AVC High 422 Intra RP2027 Class 100 720/59.94p
2165  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x31,0x09 }, 284672, 122, 0, 1 }, // AVC High 422 Intra RP2027 Class 100 720/50p
2166  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x01,0x32,0x40,0x01 }, 0, 244, 0, 1 }, // AVC High 444 Intra
2167  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x01,0x32,0x50,0x01 }, 0, 44, 0, -1 }, // AVC CAVLC 444
2168 };
2169 
2171  AVPacket *pkt, MXFIndexEntry *e)
2172 {
2173  MXFContext *mxf = s->priv_data;
2174  MXFStreamContext *sc = st->priv_data;
2176  GetBitContext gb;
2177  const uint8_t *buf = pkt->data;
2178  const uint8_t *buf_end = pkt->data + pkt->size;
2179  const uint8_t *nal_end;
2180  uint32_t state = -1;
2181  int extra_size = 512; // support AVC Intra files without SPS/PPS header
2182  int i, frame_size, slice_type, intra_only = 0;
2183 
2184  for (;;) {
2185  buf = avpriv_find_start_code(buf, buf_end, &state);
2186  if (buf >= buf_end)
2187  break;
2188 
2189  switch (state & 0x1f) {
2190  case H264_NAL_SPS:
2191  e->flags |= 0x40;
2192 
2193  if (mxf->header_written)
2194  break;
2195 
2196  nal_end = ff_avc_find_startcode(buf, buf_end);
2197  sps = ff_avc_decode_sps(buf, nal_end - buf);
2198  if (!sps) {
2199  av_log(s, AV_LOG_ERROR, "error parsing sps\n");
2200  return 0;
2201  }
2202 
2203  sc->aspect_ratio.num = st->codecpar->width * sps->sar.num;
2204  sc->aspect_ratio.den = st->codecpar->height * sps->sar.den;
2206  sc->aspect_ratio.num, sc->aspect_ratio.den, 1024*1024);
2207  intra_only = (sps->constraint_set_flags >> 3) & 1;
2208  sc->interlaced = !sps->frame_mbs_only_flag;
2209  sc->component_depth = sps->bit_depth_luma;
2210 
2211  buf = nal_end;
2212  break;
2213  case H264_NAL_PPS:
2214  if (e->flags & 0x40) { // sequence header present
2215  e->flags |= 0x80; // random access
2216  extra_size = 0;
2217  }
2218  break;
2219  case H264_NAL_IDR_SLICE:
2220  e->flags |= 0x04; // IDR Picture
2221  buf = buf_end;
2222  break;
2223  case H264_NAL_SLICE:
2224  init_get_bits8(&gb, buf, buf_end - buf);
2225  get_ue_golomb_long(&gb); // skip first_mb_in_slice
2226  slice_type = get_ue_golomb_31(&gb);
2227  switch (slice_type % 5) {
2228  case 0:
2229  e->flags |= 0x20; // P Picture
2230  e->flags |= 0x06; // P Picture
2231  break;
2232  case 1:
2233  e->flags |= 0x30; // B Picture
2234  e->flags |= 0x03; // non-referenced B Picture
2235  break;
2236  }
2237  buf = buf_end;
2238  break;
2239  default:
2240  break;
2241  }
2242  }
2243 
2244  if (mxf->header_written)
2245  return 1;
2246 
2247  if (!sps)
2248  sc->interlaced = st->codecpar->field_order != AV_FIELD_PROGRESSIVE ? 1 : 0;
2249  sc->codec_ul = NULL;
2250  frame_size = pkt->size + extra_size;
2251 
2252  for (i = 0; i < FF_ARRAY_ELEMS(mxf_h264_codec_uls); i++) {
2253  if (frame_size == mxf_h264_codec_uls[i].frame_size && sc->interlaced == mxf_h264_codec_uls[i].interlaced) {
2254  sc->codec_ul = &mxf_h264_codec_uls[i].uid;
2255  sc->component_depth = 10; // AVC Intra is always 10 Bit
2256  sc->aspect_ratio = (AVRational){ 16, 9 }; // 16:9 is mandatory for broadcast HD
2257  st->codecpar->profile = mxf_h264_codec_uls[i].profile;
2258  sc->avc_intra = 1;
2259  mxf->cbr_index = 1;
2260  sc->frame_size = pkt->size;
2261  if (sc->interlaced)
2262  sc->field_dominance = 1; // top field first is mandatory for AVC Intra
2263  break;
2264  } else if (sps && mxf_h264_codec_uls[i].frame_size == 0 &&
2265  mxf_h264_codec_uls[i].profile == sps->profile_idc &&
2266  (mxf_h264_codec_uls[i].intra_only < 0 ||
2267  mxf_h264_codec_uls[i].intra_only == intra_only)) {
2268  sc->codec_ul = &mxf_h264_codec_uls[i].uid;
2269  st->codecpar->profile = sps->profile_idc;
2270  st->codecpar->level = sps->level_idc;
2271  // continue to check for avc intra
2272  }
2273  }
2274 
2275  av_free(sps);
2276 
2277  if (!sc->codec_ul) {
2278  av_log(s, AV_LOG_ERROR, "h264 profile not supported\n");
2279  return 0;
2280  }
2281 
2282  return 1;
2283 }
2284 
2285 static const UID mxf_mpeg2_codec_uls[] = {
2286  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x10,0x00 }, // MP-ML I-Frame
2287  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x11,0x00 }, // MP-ML Long GOP
2288  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x02,0x00 }, // 422P-ML I-Frame
2289  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x03,0x00 }, // 422P-ML Long GOP
2290  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x02,0x00 }, // MP-HL I-Frame
2291  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x03,0x00 }, // MP-HL Long GOP
2292  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x02,0x00 }, // 422P-HL I-Frame
2293  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x03,0x00 }, // 422P-HL Long GOP
2294  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x05,0x02,0x00 }, // MP@H-14 I-Frame
2295  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x05,0x03,0x00 }, // MP@H-14 Long GOP
2296 };
2297 
2299 {
2300  int long_gop = 1;
2301 
2302  if (par->profile == 4) { // Main
2303  if (par->level == 8) // Main
2304  return &mxf_mpeg2_codec_uls[0+long_gop];
2305  else if (par->level == 4) // High
2306  return &mxf_mpeg2_codec_uls[4+long_gop];
2307  else if (par->level == 6) // High 14
2308  return &mxf_mpeg2_codec_uls[8+long_gop];
2309  } else if (par->profile == 0) { // 422
2310  if (par->level == 5) // Main
2311  return &mxf_mpeg2_codec_uls[2+long_gop];
2312  else if (par->level == 2) // High
2313  return &mxf_mpeg2_codec_uls[6+long_gop];
2314  }
2315  return NULL;
2316 }
2317 
2319  AVPacket *pkt, MXFIndexEntry *e)
2320 {
2321  MXFStreamContext *sc = st->priv_data;
2322  uint32_t c = -1;
2323  int i;
2324 
2325  for(i = 0; i < pkt->size - 4; i++) {
2326  c = (c<<8) + pkt->data[i];
2327  if (c == 0x1b5) {
2328  if ((pkt->data[i+1] & 0xf0) == 0x10) { // seq ext
2329  st->codecpar->profile = pkt->data[i+1] & 0x07;
2330  st->codecpar->level = pkt->data[i+2] >> 4;
2331  sc->low_delay = pkt->data[i+6] >> 7;
2332  } else if (i + 5 < pkt->size && (pkt->data[i+1] & 0xf0) == 0x80) { // pict coding ext
2333  sc->interlaced = !(pkt->data[i+5] & 0x80); // progressive frame
2334  if (sc->interlaced)
2335  sc->field_dominance = 1 + !(pkt->data[i+4] & 0x80); // top field first
2336  break;
2337  }
2338  } else if (c == 0x1b8) { // gop
2339  if (pkt->data[i+4]>>6 & 0x01) { // closed
2340  if (sc->seq_closed_gop == -1)
2341  sc->seq_closed_gop = 1;
2342  sc->closed_gop = 1;
2343  if (e->flags & 0x40) // sequence header present
2344  e->flags |= 0x80; // random access
2345  } else {
2346  sc->seq_closed_gop = 0;
2347  sc->closed_gop = 0;
2348  }
2349  } else if (c == 0x1b3) { // seq
2350  e->flags |= 0x40;
2351  switch ((pkt->data[i+4]>>4) & 0xf) {
2352  case 2: sc->aspect_ratio = (AVRational){ 4, 3}; break;
2353  case 3: sc->aspect_ratio = (AVRational){ 16, 9}; break;
2354  case 4: sc->aspect_ratio = (AVRational){221,100}; break;
2355  default:
2357  st->codecpar->width, st->codecpar->height, 1024*1024);
2358  }
2359  } else if (c == 0x100) { // pic
2360  int pict_type = (pkt->data[i+2]>>3) & 0x07;
2361  e->temporal_ref = (pkt->data[i+1]<<2) | (pkt->data[i+2]>>6);
2362  if (pict_type == 2) { // P-frame
2363  e->flags |= 0x22;
2364  sc->closed_gop = 0; // reset closed GOP, don't matter anymore
2365  } else if (pict_type == 3) { // B-frame
2366  if (sc->closed_gop)
2367  e->flags |= 0x13; // only backward prediction
2368  else
2369  e->flags |= 0x33;
2370  sc->temporal_reordering = -1;
2371  } else if (!pict_type) {
2372  av_log(s, AV_LOG_ERROR, "error parsing mpeg2 frame\n");
2373  return 0;
2374  }
2375  }
2376  }
2377  if (s->oformat != &ff_mxf_d10_muxer)
2379  return !!sc->codec_ul;
2380 }
2381 
2382 static uint64_t mxf_parse_timestamp(int64_t timestamp64)
2383 {
2384  time_t timestamp = timestamp64 / 1000000;
2385  struct tm tmbuf;
2386  struct tm *time = gmtime_r(&timestamp, &tmbuf);
2387  if (!time)
2388  return 0;
2389  return (uint64_t)(time->tm_year+1900) << 48 |
2390  (uint64_t)(time->tm_mon+1) << 40 |
2391  (uint64_t) time->tm_mday << 32 |
2392  time->tm_hour << 24 |
2393  time->tm_min << 16 |
2394  time->tm_sec << 8 |
2395  (timestamp64 % 1000000) / 4000;
2396 }
2397 
2399 {
2400  MXFContext *mxf = s->priv_data;
2401  uint32_t seed = av_get_random_seed();
2402  uint64_t umid = seed + 0x5294713400000000LL;
2403 
2404  AV_WB64(mxf->umid , umid);
2405  AV_WB64(mxf->umid+8, umid>>8);
2406 
2407  mxf->instance_number = seed & 0xFFFFFF;
2408 }
2409 
2411 {
2412  MXFContext *mxf = s->priv_data;
2413  AVDictionaryEntry *tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
2414  if (!tcr)
2415  tcr = av_dict_get(st->metadata, "timecode", NULL, 0);
2416 
2417  if (tcr)
2418  return av_timecode_init_from_string(&mxf->tc, rate, tcr->value, s);
2419  else
2420  return av_timecode_init(&mxf->tc, rate, 0, 0, s);
2421 }
2422 
2424 {
2425  MXFContext *mxf = s->priv_data;
2426  int i, ret;
2427  uint8_t present[FF_ARRAY_ELEMS(mxf_essence_container_uls)] = {0};
2428  const MXFSamplesPerFrame *spf = NULL;
2429  int64_t timestamp = 0;
2430 
2431  if (!s->nb_streams)
2432  return -1;
2433 
2434  if (s->oformat == &ff_mxf_opatom_muxer && s->nb_streams !=1) {
2435  av_log(s, AV_LOG_ERROR, "there must be exactly one stream for mxf opatom\n");
2436  return -1;
2437  }
2438 
2439  if (!av_dict_get(s->metadata, "comment_", NULL, AV_DICT_IGNORE_SUFFIX))
2440  mxf->store_user_comments = 0;
2441 
2442  for (i = 0; i < s->nb_streams; i++) {
2443  AVStream *st = s->streams[i];
2444  MXFStreamContext *sc = av_mallocz(sizeof(*sc));
2445  if (!sc)
2446  return AVERROR(ENOMEM);
2447  st->priv_data = sc;
2448  sc->index = -1;
2449 
2450  if (((i == 0) ^ (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)) && s->oformat != &ff_mxf_opatom_muxer) {
2451  av_log(s, AV_LOG_ERROR, "there must be exactly one video stream and it must be the first one\n");
2452  return -1;
2453  }
2454 
2455  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2456  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(st->codecpar->format);
2457  // TODO: should be avg_frame_rate
2458  AVRational rate, tbc = st->time_base;
2459  // Default component depth to 8
2460  sc->component_depth = 8;
2461  sc->h_chroma_sub_sample = 2;
2462  sc->v_chroma_sub_sample = 2;
2463  sc->color_siting = 0xFF;
2464 
2467  av_make_q(st->codecpar->width, st->codecpar->height));
2468  }
2469 
2470  if (pix_desc) {
2471  sc->component_depth = pix_desc->comp[0].depth;
2472  sc->h_chroma_sub_sample = 1 << pix_desc->log2_chroma_w;
2473  sc->v_chroma_sub_sample = 1 << pix_desc->log2_chroma_h;
2474  }
2475  switch (ff_choose_chroma_location(s, st)) {
2476  case AVCHROMA_LOC_TOPLEFT: sc->color_siting = 0; break;
2477  case AVCHROMA_LOC_LEFT: sc->color_siting = 6; break;
2478  case AVCHROMA_LOC_TOP: sc->color_siting = 1; break;
2479  case AVCHROMA_LOC_CENTER: sc->color_siting = 3; break;
2480  }
2481 
2482  mxf->timecode_base = (tbc.den + tbc.num/2) / tbc.num;
2483  spf = ff_mxf_get_samples_per_frame(s, tbc);
2484  if (!spf) {
2485  av_log(s, AV_LOG_ERROR, "Unsupported video frame rate %d/%d\n",
2486  tbc.den, tbc.num);
2487  return AVERROR(EINVAL);
2488  }
2490  mxf->time_base = spf->time_base;
2491  rate = av_inv_q(mxf->time_base);
2492  avpriv_set_pts_info(st, 64, mxf->time_base.num, mxf->time_base.den);
2493  if((ret = mxf_init_timecode(s, st, rate)) < 0)
2494  return ret;
2495 
2497  sc->seq_closed_gop = -1; // unknown yet
2498  }
2499 
2500  sc->video_bit_rate = st->codecpar->bit_rate;
2501 
2502  if (s->oformat == &ff_mxf_d10_muxer ||
2505  mxf->cbr_index = 1;
2506 
2507  if (s->oformat == &ff_mxf_d10_muxer) {
2508  int ntsc = mxf->time_base.den != 25;
2509  int ul_index;
2510 
2512  av_log(s, AV_LOG_ERROR, "error MXF D-10 only support MPEG-2 Video\n");
2513  return AVERROR(EINVAL);
2514  }
2515  if ((sc->video_bit_rate == 50000000) && (mxf->time_base.den == 25)) {
2516  ul_index = 0;
2517  } else if ((sc->video_bit_rate == 49999840 || sc->video_bit_rate == 50000000) && ntsc) {
2518  ul_index = 1;
2519  } else if (sc->video_bit_rate == 40000000) {
2520  ul_index = 2+ntsc;
2521  } else if (sc->video_bit_rate == 30000000) {
2522  ul_index = 4+ntsc;
2523  } else {
2524  av_log(s, AV_LOG_ERROR, "error MXF D-10 only support 30/40/50 mbit/s\n");
2525  return -1;
2526  }
2527 
2528  sc->codec_ul = &mxf_d10_codec_uls[ul_index];
2529  sc->container_ul = &mxf_d10_container_uls[ul_index];
2530  sc->index = INDEX_D10_VIDEO;
2531  sc->signal_standard = 1;
2532  sc->color_siting = 0;
2533  sc->frame_size = (int64_t)sc->video_bit_rate *
2534  mxf->time_base.num / (8*mxf->time_base.den);
2535  }
2536  if (mxf->signal_standard >= 0)
2537  sc->signal_standard = mxf->signal_standard;
2538  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2539  if (st->codecpar->sample_rate != 48000) {
2540  av_log(s, AV_LOG_ERROR, "only 48khz is implemented\n");
2541  return -1;
2542  }
2543  avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
2544  if (s->oformat == &ff_mxf_d10_muxer) {
2545  if (st->index != 1) {
2546  av_log(s, AV_LOG_ERROR, "MXF D-10 only support one audio track\n");
2547  return -1;
2548  }
2549  if (st->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE &&
2551  av_log(s, AV_LOG_ERROR, "MXF D-10 only support 16 or 24 bits le audio\n");
2552  }
2553  sc->index = INDEX_D10_AUDIO;
2554  sc->container_ul = ((MXFStreamContext*)s->streams[0]->priv_data)->container_ul;
2555  sc->frame_size = 4 + 8 * spf[0].samples_per_frame[0] * 4;
2556  } else if (s->oformat == &ff_mxf_opatom_muxer) {
2557  AVRational tbc = av_inv_q(mxf->audio_edit_rate);
2558 
2559  if (st->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE &&
2561  av_log(s, AV_LOG_ERROR, "Only pcm_s16le and pcm_s24le audio codecs are implemented\n");
2562  return AVERROR_PATCHWELCOME;
2563  }
2564  if (st->codecpar->channels != 1) {
2565  av_log(s, AV_LOG_ERROR, "MXF OPAtom only supports single channel audio\n");
2566  return AVERROR(EINVAL);
2567  }
2568 
2569  spf = ff_mxf_get_samples_per_frame(s, tbc);
2570  if (!spf) {
2571  av_log(s, AV_LOG_ERROR, "Unsupported timecode frame rate %d/%d\n", tbc.den, tbc.num);
2572  return AVERROR(EINVAL);
2573  }
2574 
2575  mxf->time_base = st->time_base;
2576  if((ret = mxf_init_timecode(s, st, av_inv_q(spf->time_base))) < 0)
2577  return ret;
2578 
2579  mxf->timecode_base = (tbc.den + tbc.num/2) / tbc.num;
2581  sc->index = INDEX_WAV;
2582  } else {
2583  mxf->slice_count = 1;
2584  sc->frame_size = (st->codecpar->channels * spf[0].samples_per_frame[0] *
2586  }
2587  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2588  AVDictionaryEntry *e = av_dict_get(st->metadata, "data_type", NULL, 0);
2589  if (e && !strcmp(e->value, "vbi_vanc_smpte_436M")) {
2590  sc->index = INDEX_S436M;
2591  } else {
2592  av_log(s, AV_LOG_ERROR, "track %d: unsupported data type\n", i);
2593  return -1;
2594  }
2595  if (st->index != s->nb_streams - 1) {
2596  av_log(s, AV_LOG_ERROR, "data track must be placed last\n");
2597  return -1;
2598  }
2599  }
2600 
2601  if (sc->index == -1) {
2603  if (sc->index == -1) {
2604  av_log(s, AV_LOG_ERROR, "track %d: could not find essence container ul, "
2605  "codec not currently supported in container\n", i);
2606  return -1;
2607  }
2608  }
2609 
2610  if (!sc->codec_ul)
2611  sc->codec_ul = &mxf_essence_container_uls[sc->index].codec_ul;
2612  if (!sc->container_ul)
2613  sc->container_ul = &mxf_essence_container_uls[sc->index].container_ul;
2614 
2615  memcpy(sc->track_essence_element_key, mxf_essence_container_uls[sc->index].element_ul, 15);
2616  sc->track_essence_element_key[15] = present[sc->index];
2617  PRINT_KEY(s, "track essence element key", sc->track_essence_element_key);
2618 
2619  if (!present[sc->index])
2620  mxf->essence_container_count++;
2621  present[sc->index]++;
2622  }
2623 
2624  if (s->oformat == &ff_mxf_d10_muxer || s->oformat == &ff_mxf_opatom_muxer) {
2625  mxf->essence_container_count = 1;
2626  }
2627 
2628  if (!(s->flags & AVFMT_FLAG_BITEXACT))
2629  mxf_gen_umid(s);
2630 
2631  for (i = 0; i < s->nb_streams; i++) {
2632  MXFStreamContext *sc = s->streams[i]->priv_data;
2633  // update element count
2634  sc->track_essence_element_key[13] = present[sc->index];
2635  if (!memcmp(sc->track_essence_element_key, mxf_essence_container_uls[INDEX_DV].element_ul, 13)) // DV
2636  sc->order = (0x15 << 24) | AV_RB32(sc->track_essence_element_key+13);
2637  else
2638  sc->order = AV_RB32(sc->track_essence_element_key+12);
2639  }
2640 
2641  if (ff_parse_creation_time_metadata(s, &timestamp, 0) > 0)
2642  mxf->timestamp = mxf_parse_timestamp(timestamp);
2643  mxf->duration = -1;
2644 
2645  mxf->timecode_track = av_mallocz(sizeof(*mxf->timecode_track));
2646  if (!mxf->timecode_track)
2647  return AVERROR(ENOMEM);
2649  if (!mxf->timecode_track->priv_data)
2650  return AVERROR(ENOMEM);
2651  mxf->timecode_track->index = -1;
2652 
2653  if (!spf)
2654  spf = ff_mxf_get_samples_per_frame(s, (AVRational){ 1, 25 });
2655 
2656  if (ff_audio_interleave_init(s, spf->samples_per_frame, mxf->time_base) < 0)
2657  return -1;
2658 
2659  return 0;
2660 }
2661 
2662 static const uint8_t system_metadata_pack_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04,0x01,0x01,0x00 };
2663 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 };
2664 
2666 {
2667  MXFContext *mxf = s->priv_data;
2668  AVIOContext *pb = s->pb;
2669  unsigned frame;
2670  uint32_t time_code;
2671  int i, system_item_bitmap = 0x58; // UL, user date/time stamp, picture present
2672 
2673  frame = mxf->last_indexed_edit_unit + mxf->edit_units_count;
2674 
2675  // write system metadata pack
2677  klv_encode_ber4_length(pb, 57);
2678 
2679  for (i = 0; i < s->nb_streams; i++) {
2681  system_item_bitmap |= 0x4;
2682  else if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2683  system_item_bitmap |= 0x2;
2684  }
2685  avio_w8(pb, system_item_bitmap);
2686  avio_w8(pb, mxf->content_package_rate); // content package rate
2687  avio_w8(pb, 0x00); // content package type
2688  avio_wb16(pb, 0x00); // channel handle
2689  avio_wb16(pb, (mxf->tc.start + frame) & 0xFFFF); // continuity count, supposed to overflow
2690  if (mxf->essence_container_count > 1)
2691  avio_write(pb, multiple_desc_ul, 16);
2692  else {
2693  MXFStreamContext *sc = s->streams[0]->priv_data;
2694  avio_write(pb, *sc->container_ul, 16);
2695  }
2696  avio_w8(pb, 0);
2697  avio_wb64(pb, 0);
2698  avio_wb64(pb, 0); // creation date/time stamp
2699 
2700  avio_w8(pb, 0x81); // SMPTE 12M time code
2701  time_code = av_timecode_get_smpte_from_framenum(&mxf->tc, frame);
2702  avio_wb32(pb, time_code);
2703  avio_wb32(pb, 0); // binary group data
2704  avio_wb64(pb, 0);
2705 
2706  // write system metadata package set
2708  klv_encode_ber4_length(pb, 35);
2709  avio_w8(pb, 0x83); // UMID
2710  avio_wb16(pb, 0x20);
2711  mxf_write_umid(s, 1);
2712 }
2713 
2715 {
2716  MXFContext *mxf = s->priv_data;
2717  AVIOContext *pb = s->pb;
2718  int frame_size = pkt->size / st->codecpar->block_align;
2719  uint8_t *samples = pkt->data;
2720  uint8_t *end = pkt->data + pkt->size;
2721  int i;
2722 
2723  klv_encode_ber4_length(pb, 4 + frame_size*4*8);
2724 
2725  avio_w8(pb, (frame_size == 1920 ? 0 : (mxf->edit_units_count-1) % 5 + 1));
2726  avio_wl16(pb, frame_size);
2727  avio_w8(pb, (1<<st->codecpar->channels)-1);
2728 
2729  while (samples < end) {
2730  for (i = 0; i < st->codecpar->channels; i++) {
2731  uint32_t sample;
2732  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE) {
2733  sample = AV_RL24(samples)<< 4;
2734  samples += 3;
2735  } else {
2736  sample = AV_RL16(samples)<<12;
2737  samples += 2;
2738  }
2739  avio_wl32(pb, sample | i);
2740  }
2741  for (; i < 8; i++)
2742  avio_wl32(pb, i);
2743  }
2744 }
2745 
2747 {
2748  MXFContext *mxf = s->priv_data;
2749  AVIOContext *pb = s->pb;
2750  AVStream *st = s->streams[0];
2751  MXFStreamContext *sc = st->priv_data;
2752  const uint8_t *key = NULL;
2753 
2754  int err;
2755 
2756  if (!mxf->header_written)
2757  key = body_partition_key;
2758 
2759  if ((err = mxf_write_partition(s, 1, 0, key, 0)) < 0)
2760  return err;
2761  mxf_write_klv_fill(s);
2764  return 0;
2765 }
2766 
2768 {
2769  MXFContext *mxf = s->priv_data;
2770  AVIOContext *pb = s->pb;
2771 
2772  int err;
2773 
2774  if (!mxf->header_written) {
2775  if ((err = mxf_write_partition(s, 0, 0, header_open_partition_key, 1)) < 0)
2776  return err;
2777  mxf_write_klv_fill(s);
2778 
2779  if ((err = mxf_write_opatom_body_partition(s)) < 0)
2780  return err;
2781  mxf->header_written = 1;
2782  }
2783 
2784  if (!mxf->edit_unit_byte_count) {
2786  mxf->index_entries[mxf->edit_units_count].flags = ie->flags;
2788  }
2789  mxf->edit_units_count++;
2790  avio_write(pb, pkt->data, pkt->size);
2791  mxf->body_offset += pkt->size;
2792 
2793  return 0;
2794 }
2795 
2797 {
2798  MXFContext *mxf = s->priv_data;
2799  int i;
2800 
2801  if (s->oformat == &ff_mxf_opatom_muxer) {
2802  MXFStreamContext *sc = s->streams[0]->priv_data;
2803  mxf->edit_unit_byte_count = sc->frame_size;
2804  return;
2805  }
2806 
2807  mxf->edit_unit_byte_count = KAG_SIZE; // system element
2808  for (i = 0; i < s->nb_streams; i++) {
2809  AVStream *st = s->streams[i];
2810  MXFStreamContext *sc = st->priv_data;
2812  mxf->edit_unit_byte_count += 16 + 4 + sc->frame_size;
2814  }
2815 }
2816 
2818 {
2819  MXFContext *mxf = s->priv_data;
2820  AVIOContext *pb = s->pb;
2821  AVStream *st = s->streams[pkt->stream_index];
2822  MXFStreamContext *sc = st->priv_data;
2823  MXFIndexEntry ie = {0};
2824  int err;
2825 
2826  if (!mxf->cbr_index && !mxf->edit_unit_byte_count && !(mxf->edit_units_count % EDIT_UNITS_PER_BODY)) {
2827  if ((err = av_reallocp_array(&mxf->index_entries, mxf->edit_units_count
2828  + EDIT_UNITS_PER_BODY, sizeof(*mxf->index_entries))) < 0) {
2829  mxf->edit_units_count = 0;
2830  av_log(s, AV_LOG_ERROR, "could not allocate index entries\n");
2831  return err;
2832  }
2833  }
2834 
2836  if (!mxf_parse_mpeg2_frame(s, st, pkt, &ie)) {
2837  av_log(s, AV_LOG_ERROR, "could not get mpeg2 profile and level\n");
2838  return -1;
2839  }
2840  } else if (st->codecpar->codec_id == AV_CODEC_ID_DNXHD) {
2841  if (!mxf_parse_dnxhd_frame(s, st, pkt)) {
2842  av_log(s, AV_LOG_ERROR, "could not get dnxhd profile\n");
2843  return -1;
2844  }
2845  } else if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2846  if (!mxf_parse_prores_frame(s, st, pkt)) {
2847  av_log(s, AV_LOG_ERROR, "could not get prores profile\n");
2848  return -1;
2849  }
2850  } else if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO) {
2851  if (!mxf_parse_dv_frame(s, st, pkt)) {
2852  av_log(s, AV_LOG_ERROR, "could not get dv profile\n");
2853  return -1;
2854  }
2855  } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2856  if (!mxf_parse_h264_frame(s, st, pkt, &ie)) {
2857  av_log(s, AV_LOG_ERROR, "could not get h264 profile\n");
2858  return -1;
2859  }
2860  }
2861 
2862  if (mxf->cbr_index) {
2863  if (pkt->size != sc->frame_size && st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2864  av_log(s, AV_LOG_ERROR, "track %d: frame size does not match index unit size, %d != %d\n",
2865  st->index, pkt->size, sc->frame_size);
2866  return -1;
2867  }
2868  if (!mxf->header_written)
2870  }
2871 
2872  if (s->oformat == &ff_mxf_opatom_muxer)
2873  return mxf_write_opatom_packet(s, pkt, &ie);
2874 
2875  if (!mxf->header_written) {
2876  if (mxf->edit_unit_byte_count) {
2877  if ((err = mxf_write_partition(s, 1, 2, header_open_partition_key, 1)) < 0)
2878  return err;
2879  mxf_write_klv_fill(s);
2881  } else {
2882  if ((err = mxf_write_partition(s, 0, 0, header_open_partition_key, 1)) < 0)
2883  return err;
2884  }
2885  mxf->header_written = 1;
2886  }
2887 
2888  if (st->index == 0) {
2889  if (!mxf->edit_unit_byte_count &&
2891  !(ie.flags & 0x33)) { // I-frame, GOP start
2892  mxf_write_klv_fill(s);
2893  if ((err = mxf_write_partition(s, 1, 2, body_partition_key, 0)) < 0)
2894  return err;
2895  mxf_write_klv_fill(s);
2897  }
2898 
2899  mxf_write_klv_fill(s);
2901 
2902  if (!mxf->edit_unit_byte_count) {
2904  mxf->index_entries[mxf->edit_units_count].flags = ie.flags;
2906  mxf->body_offset += KAG_SIZE; // size of system element
2907  }
2908  mxf->edit_units_count++;
2909  } else if (!mxf->edit_unit_byte_count && st->index == 1) {
2910  if (!mxf->edit_units_count) {
2911  av_log(s, AV_LOG_ERROR, "No packets in first stream\n");
2912  return AVERROR_PATCHWELCOME;
2913  }
2915  mxf->body_offset - mxf->index_entries[mxf->edit_units_count-1].offset;
2916  }
2917 
2918  mxf_write_klv_fill(s);
2919  avio_write(pb, sc->track_essence_element_key, 16); // write key
2920  if (s->oformat == &ff_mxf_d10_muxer &&
2922  mxf_write_d10_audio_packet(s, st, pkt);
2923  } else {
2924  klv_encode_ber4_length(pb, pkt->size); // write length
2925  avio_write(pb, pkt->data, pkt->size);
2926  mxf->body_offset += 16+4+pkt->size + klv_fill_size(16+4+pkt->size);
2927  }
2928 
2929  return 0;
2930 }
2931 
2933 {
2934  MXFContext *mxf = s->priv_data;
2935  AVIOContext *pb = s->pb;
2936  uint64_t pos = avio_tell(pb);
2937  int i;
2938 
2940  klv_encode_ber_length(pb, 28 + 12LL*mxf->body_partitions_count);
2941 
2942  if (mxf->edit_unit_byte_count && s->oformat != &ff_mxf_opatom_muxer)
2943  avio_wb32(pb, 1); // BodySID of header partition
2944  else
2945  avio_wb32(pb, 0);
2946  avio_wb64(pb, 0); // offset of header partition
2947 
2948  for (i = 0; i < mxf->body_partitions_count; i++) {
2949  avio_wb32(pb, 1); // BodySID
2950  avio_wb64(pb, mxf->body_partition_offset[i]);
2951  }
2952 
2953  avio_wb32(pb, 0); // BodySID of footer partition
2955 
2956  avio_wb32(pb, avio_tell(pb) - pos + 4);
2957 }
2958 
2960 {
2961  MXFContext *mxf = s->priv_data;
2962  AVIOContext *pb = s->pb;
2963  int i, err;
2964 
2965  if (!mxf->header_written ||
2966  (s->oformat == &ff_mxf_opatom_muxer && !mxf->body_partition_offset)) {
2967  /* reason could be invalid options/not supported codec/out of memory */
2968  return AVERROR_UNKNOWN;
2969  }
2970 
2972 
2973  mxf_write_klv_fill(s);
2975  if (mxf->edit_unit_byte_count && s->oformat != &ff_mxf_opatom_muxer) { // no need to repeat index
2976  if ((err = mxf_write_partition(s, 0, 0, footer_partition_key, 0)) < 0)
2977  return err;
2978  } else {
2979  if ((err = mxf_write_partition(s, 0, 2, footer_partition_key, 0)) < 0)
2980  return err;
2981  mxf_write_klv_fill(s);
2983  }
2984 
2985  mxf_write_klv_fill(s);
2987 
2988  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
2989  if (s->oformat == &ff_mxf_opatom_muxer) {
2990  /* rewrite body partition to update lengths */
2991  avio_seek(pb, mxf->body_partition_offset[0], SEEK_SET);
2992  if ((err = mxf_write_opatom_body_partition(s)) < 0)
2993  return err;
2994  }
2995 
2996  avio_seek(pb, 0, SEEK_SET);
2997  if (mxf->edit_unit_byte_count && s->oformat != &ff_mxf_opatom_muxer) {
2998  if ((err = mxf_write_partition(s, 1, 2, header_closed_partition_key, 1)) < 0)
2999  return err;
3000  mxf_write_klv_fill(s);
3002  } else {
3003  if ((err = mxf_write_partition(s, 0, 0, header_closed_partition_key, 1)) < 0)
3004  return err;
3005  }
3006  // update footer partition offset
3007  for (i = 0; i < mxf->body_partitions_count; i++) {
3008  avio_seek(pb, mxf->body_partition_offset[i]+44, SEEK_SET);
3010  }
3011  }
3012 
3013  return 0;
3014 }
3015 
3017 {
3018  MXFContext *mxf = s->priv_data;
3019 
3021 
3022  av_freep(&mxf->index_entries);
3024  if (mxf->timecode_track) {
3026  av_freep(&mxf->timecode_track);
3027  }
3028 }
3029 
3031 {
3032  int i, stream_count = 0;
3033 
3034  for (i = 0; i < s->nb_streams; i++)
3035  stream_count += !!s->streams[i]->last_in_packet_buffer;
3036 
3037  if (stream_count && (s->nb_streams == stream_count || flush)) {
3038  AVPacketList *pktl = s->internal->packet_buffer;
3039  if (s->nb_streams != stream_count) {
3040  AVPacketList *last = NULL;
3041  // find last packet in edit unit
3042  while (pktl) {
3043  if (!stream_count || pktl->pkt.stream_index == 0)
3044  break;
3045  // update last packet in packet buffer
3046  if (s->streams[pktl->pkt.stream_index]->last_in_packet_buffer != pktl)
3047  s->streams[pktl->pkt.stream_index]->last_in_packet_buffer = pktl;
3048  last = pktl;
3049  pktl = pktl->next;
3050  stream_count--;
3051  }
3052  // purge packet queue
3053  while (pktl) {
3054  AVPacketList *next = pktl->next;
3055  av_packet_unref(&pktl->pkt);
3056  av_freep(&pktl);
3057  pktl = next;
3058  }
3059  if (last)
3060  last->next = NULL;
3061  else {
3062  s->internal->packet_buffer = NULL;
3064  goto out;
3065  }
3066  pktl = s->internal->packet_buffer;
3067  }
3068 
3069  *out = pktl->pkt;
3070  av_log(s, AV_LOG_TRACE, "out st:%d dts:%"PRId64"\n", (*out).stream_index, (*out).dts);
3071  s->internal->packet_buffer = pktl->next;
3072  if(s->streams[pktl->pkt.stream_index]->last_in_packet_buffer == pktl)
3074  if(!s->internal->packet_buffer)
3076  av_freep(&pktl);
3077  return 1;
3078  } else {
3079  out:
3080  av_init_packet(out);
3081  return 0;
3082  }
3083 }
3084 
3086  const AVPacket *pkt)
3087 {
3089  MXFStreamContext *sc2 = s->streams[next->stream_index]->priv_data;
3090 
3091  return next->dts > pkt->dts ||
3092  (next->dts == pkt->dts && sc->order < sc2->order);
3093 }
3094 
3096 {
3097  return ff_audio_rechunk_interleave(s, out, pkt, flush,
3099 }
3100 
3101 #define MXF_COMMON_OPTIONS \
3102  { "signal_standard", "Force/set Signal Standard",\
3103  offsetof(MXFContext, signal_standard), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3104  { "bt601", "ITU-R BT.601 and BT.656, also SMPTE 125M (525 and 625 line interlaced)",\
3105  0, AV_OPT_TYPE_CONST, {.i64 = 1}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3106  { "bt1358", "ITU-R BT.1358 and ITU-R BT.799-3, also SMPTE 293M (525 and 625 line progressive)",\
3107  0, AV_OPT_TYPE_CONST, {.i64 = 2}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3108  { "smpte347m", "SMPTE 347M (540 Mbps mappings)",\
3109  0, AV_OPT_TYPE_CONST, {.i64 = 3}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3110  { "smpte274m", "SMPTE 274M (1125 line)",\
3111  0, AV_OPT_TYPE_CONST, {.i64 = 4}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3112  { "smpte296m", "SMPTE 296M (750 line progressive)",\
3113  0, AV_OPT_TYPE_CONST, {.i64 = 5}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3114  { "smpte349m", "SMPTE 349M (1485 Mbps mappings)",\
3115  0, AV_OPT_TYPE_CONST, {.i64 = 6}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3116  { "smpte428", "SMPTE 428-1 DCDM",\
3117  0, AV_OPT_TYPE_CONST, {.i64 = 7}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},
3118 
3119 
3120 
3121 static const AVOption mxf_options[] = {
3123  { "store_user_comments", "",
3124  offsetof(MXFContext, store_user_comments), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
3125  { NULL },
3126 };
3127 
3128 static const AVClass mxf_muxer_class = {
3129  .class_name = "MXF muxer",
3130  .item_name = av_default_item_name,
3131  .option = mxf_options,
3132  .version = LIBAVUTIL_VERSION_INT,
3133 };
3134 
3135 static const AVOption d10_options[] = {
3136  { "d10_channelcount", "Force/set channelcount in generic sound essence descriptor",
3137  offsetof(MXFContext, channel_count), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 8, AV_OPT_FLAG_ENCODING_PARAM},
3139  { "store_user_comments", "",
3140  offsetof(MXFContext, store_user_comments), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
3141  { NULL },
3142 };
3143 
3145  .class_name = "MXF-D10 muxer",
3146  .item_name = av_default_item_name,
3147  .option = d10_options,
3148  .version = LIBAVUTIL_VERSION_INT,
3149 };
3150 
3151 static const AVOption opatom_options[] = {
3152  { "mxf_audio_edit_rate", "Audio edit rate for timecode",
3153  offsetof(MXFContext, audio_edit_rate), AV_OPT_TYPE_RATIONAL, {.dbl=25}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
3155  { "store_user_comments", "",
3156  offsetof(MXFContext, store_user_comments), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
3157  { NULL },
3158 };
3159 
3161  .class_name = "MXF-OPAtom muxer",
3162  .item_name = av_default_item_name,
3163  .option = opatom_options,
3164  .version = LIBAVUTIL_VERSION_INT,
3165 };
3166 
3168  .name = "mxf",
3169  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3170  .mime_type = "application/mxf",
3171  .extensions = "mxf",
3172  .priv_data_size = sizeof(MXFContext),
3173  .audio_codec = AV_CODEC_ID_PCM_S16LE,
3174  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
3178  .deinit = mxf_deinit,
3181  .priv_class = &mxf_muxer_class,
3182 };
3183 
3184 AVOutputFormat ff_mxf_d10_muxer = {
3185  .name = "mxf_d10",
3186  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format) D-10 Mapping"),
3187  .mime_type = "application/mxf",
3188  .priv_data_size = sizeof(MXFContext),
3189  .audio_codec = AV_CODEC_ID_PCM_S16LE,
3190  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
3194  .deinit = mxf_deinit,
3197  .priv_class = &mxf_d10_muxer_class,
3198 };
3199 
3200 AVOutputFormat ff_mxf_opatom_muxer = {
3201  .name = "mxf_opatom",
3202  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format) Operational Pattern Atom"),
3203  .mime_type = "application/mxf",
3204  .extensions = "mxf",
3205  .priv_data_size = sizeof(MXFContext),
3206  .audio_codec = AV_CODEC_ID_PCM_S16LE,
3207  .video_codec = AV_CODEC_ID_DNXHD,
3211  .deinit = mxf_deinit,
3214  .priv_class = &mxf_opatom_muxer_class,
3215 };
int cid
Definition: mxfenc.c:1972
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:690
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:466
uint32_t tagged_value_count
Definition: mxfenc.c:261
#define NULL
Definition: coverity.c:32
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:4068
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:472
MXFMetadataSetType
Definition: mxf.h:30
Bytestream IO Context.
Definition: avio.h:161
enum AVColorTransferCharacteristic color_trc
Definition: avcodec.h:4075
static int mxf_utf16_local_tag_length(const char *utf8_str)
Definition: mxfenc.c:671
static const struct @282 mxf_dnxhd_codec_uls[]
int component_depth
Definition: mxfenc.c:90
static const uint8_t header_closed_partition_key[]
Definition: mxfenc.c:281
#define GET_UTF8(val, GET_BYTE, ERROR)
Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
Definition: common.h:385
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:544
int signal_standard
Definition: mxfenc.c:92
const uint8_t * ff_avc_find_startcode(const uint8_t *p, const uint8_t *end)
Definition: avc.c:67
int avio_put_str16be(AVIOContext *s, const char *str)
Convert an UTF-8 string to UTF-16BE and write it.
AVOption.
Definition: opt.h:246
static void flush(AVCodecContext *avctx)
"Linear transfer characteristics"
Definition: pixfmt.h:477
static void mxf_write_index_table_segment(AVFormatContext *s)
Definition: mxfenc.c:1671
enum AVCodecID id
Definition: mxfenc.c:137
uint64_t body_offset
Definition: mxfenc.c:256
static void mxf_write_timecode_component(AVFormatContext *s, AVStream *st, MXFPackage *package)
Definition: mxfenc.c:892
#define PRINT_KEY(pc, s, x)
Definition: mxf.h:129
static const uint8_t klv_fill_key[]
Definition: mxfenc.c:282
static const UID mxf_mpegvideo_descriptor_key
Definition: mxfenc.c:1045
static const UID mxf_d10_codec_uls[]
Definition: mxfenc.c:218
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
unsigned char * buf_ptr
Current position in the buffer.
Definition: avio.h:228
static void klv_encode_ber9_length(AVIOContext *pb, uint64_t len)
Definition: mxfenc.c:481
void(* write_desc)(AVFormatContext *, AVStream *)
Definition: mxfenc.c:112
int index
index in mxf_essence_container_uls table
Definition: mxfenc.c:84
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4931
AVRational sample_aspect_ratio
Video only.
Definition: avcodec.h:4063
unsigned body_partitions_count
Definition: mxfenc.c:248
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3987
const int * samples
current samples per frame, pointer to samples_per_frame
int num
Numerator.
Definition: rational.h:59
static int mxf_init_timecode(AVFormatContext *s, AVStream *st, AVRational rate)
Definition: mxfenc.c:2410
int index
stream index in AVFormatContext
Definition: avformat.h:881
int size
Definition: avcodec.h:1495
Definition: mxf.h:34
static const UID mxf_cdci_descriptor_key
Definition: mxfenc.c:1048
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1810
int interlaced
whether picture is interlaced
Definition: mxfenc.c:88
int av_log2(unsigned v)
Definition: intmath.c:26
static const uint8_t body_partition_key[]
Definition: mxfenc.c:283
static int get_trc(UID ul, enum AVColorTransferCharacteristic trc)
Definition: mxfenc.c:1053
static int64_t mxf_write_generic_sound_common(AVFormatContext *s, AVStream *st, const UID key)
Definition: mxfenc.c:1362
AVOutputFormat ff_mxf_muxer
Definition: mxfenc.c:3167
static void mxf_update_klv_size(AVIOContext *pb, int64_t pos)
Definition: mxfenc.c:1263
#define FF_PROFILE_PRORES_LT
Definition: avcodec.h:3021
GLint GLenum type
Definition: opengl_enc.c:104
int avpriv_dnxhd_get_interlaced(int cid)
Definition: dnxhddata.c:1108
static void mxf_write_s436m_anc_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1318
void * priv_data
Definition: avformat.h:895
const char * key
int version
Definition: avisynth_c.h:858
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
static void mxf_write_sequence(AVFormatContext *s, AVStream *st, MXFPackage *package)
Definition: mxfenc.c:865
static AVPacket pkt
struct AVRational time_base
Definition: mxf.h:86
uint8_t level_idc
Definition: avc.h:42
static void mxf_write_uuid(AVIOContext *pb, enum MXFMetadataSetType type, int value)
Definition: mxfenc.c:425
static const struct @284 mxf_h264_codec_uls[]
#define sample
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
UID track_essence_element_key
Definition: mxfenc.c:83
static void mxf_write_common_fields(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:841
uint8_t bit_depth_luma
Definition: avc.h:45
#define FF_PROFILE_PRORES_XQ
Definition: avcodec.h:3025
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
int id
Definition: mxf.h:79
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3979
static const UID mxf_s436m_anc_descriptor_key
Definition: mxfenc.c:1044
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:468
static int mxf_write_header(AVFormatContext *s)
Definition: mxfenc.c:2423
static void klv_encode_ber4_length(AVIOContext *pb, int len)
Definition: mxfenc.c:475
static const uint8_t multiple_desc_ul[]
Definition: mxfenc.c:289
Format I/O context.
Definition: avformat.h:1357
int h_chroma_sub_sample
Definition: mxfenc.c:93
uint8_t UID[16]
Definition: mxf.h:28
int temporal_reordering
Definition: mxfenc.c:95
#define gmtime_r
Definition: time_internal.h:34
uint8_t slice_count
index slice count minus 1 (1 if no audio, 0 otherwise)
Definition: mxfenc.c:245
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define AV_WB64(p, v)
Definition: intreadwrite.h:433
static const UID mxf_generic_sound_descriptor_key
Definition: mxfenc.c:1049
const UID container_ul
Definition: mxfenc.c:2052
static int klv_encode_ber_length(AVIOContext *pb, uint64_t len)
Definition: mxfenc.c:455
static void mxf_write_klv_fill(AVFormatContext *s)
Definition: mxfenc.c:1817
static void mxf_write_refs_count(AVIOContext *pb, int ref_count)
Definition: mxfenc.c:441
int timecode_base
rounded time code base (25 or 30)
Definition: mxfenc.c:253
int av_timecode_init_from_string(AVTimecode *tc, AVRational rate, const char *str, void *log_ctx)
Parse timecode representation (hh:mm:ss[:;.
Definition: timecode.c:194
static void mxf_write_structural_component(AVFormatContext *s, AVStream *st, MXFPackage *package)
Definition: mxfenc.c:919
static int mxf_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mxfenc.c:2817
static void mxf_write_avc_subdesc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1272
static const struct @281 mxf_prores_codec_uls[]
AVOutputFormat ff_mxf_d10_muxer
Definition: mxfenc.c:3184
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:372
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
static unsigned klv_fill_size(uint64_t size)
Definition: mxfenc.c:1662
uint8_t
const MXFSamplesPerFrame * ff_mxf_get_samples_per_frame(AVFormatContext *s, AVRational time_base)
Definition: mxf.c:155
Opaque data information usually continuous.
Definition: avutil.h:203
int width
Video only.
Definition: avcodec.h:4053
AVOptions.
A point in the output bytestream where the underlying AVIOContext might flush the buffer depending on...
Definition: avio.h:146
static const UID mxf_mpeg2_codec_uls[]
Definition: mxfenc.c:2285
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
AVPacket pkt
Definition: avformat.h:2031
timecode is drop frame
Definition: timecode.h:36
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
int frame_size
frame size in bytes
Definition: mxfenc.c:100
also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:473
int ff_audio_interleave_init(AVFormatContext *s, const int *samples_per_frame, AVRational time_base)
#define LIBAVFORMAT_VERSION_MAJOR
Definition: version.h:34
static int64_t mxf_write_generic_desc(AVFormatContext *s, AVStream *st, const UID key)
Definition: mxfenc.c:1006
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:496
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1425
int avpriv_dnxhd_get_frame_size(int cid)
Definition: dnxhddata.c:1087
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1488
uint8_t * data
Definition: avcodec.h:1494
uint64_t duration
Definition: mxfenc.c:250
int start
timecode frame start (first base frame number)
Definition: timecode.h:42
uint32_t tag
Definition: movenc.c:1532
uint64_t offset
Definition: mxfenc.c:76
Definition: ismindex.c:69
int instance
Definition: mxfenc.c:118
ptrdiff_t size
Definition: opengl_enc.c:100
uint8_t flags
Definition: mxfenc.c:75
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
struct AVPacketList * packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:76
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush)
Interleave an AVPacket correctly so it can be muxed.
Definition: mux.c:1185
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1505
AVRational audio_edit_rate
Definition: mxfenc.c:262
unsigned slice_offset
offset of audio slice
Definition: mxfenc.c:77
enum ULIndex index
Definition: mxfenc.c:138
static const uint8_t index_table_segment_key[]
Definition: mxfenc.c:278
#define av_log(a,...)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:276
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:4016
int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx)
Init a timecode struct with the passed parameters.
Definition: timecode.c:184
int store_user_comments
Definition: mxfenc.c:263
AudioInterleaveContext aic
Definition: mxfenc.c:82
int local_tag
Definition: mxfenc.c:70
static const AVClass mxf_opatom_muxer_class
Definition: mxfenc.c:3160
H.264 parameter set handling.
static const uint8_t umid_ul[]
Definition: mxfenc.c:269
static void mxf_write_tape_descriptor(AVFormatContext *s)
Definition: mxfenc.c:956
int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
Parse creation_time in AVFormatContext metadata if exists and warn if the parsing fails...
Definition: utils.c:5697
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1597
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1536
ITU-R BT1361 Extended Colour Gamut.
Definition: pixfmt.h:481
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
static void mxf_write_system_item(AVFormatContext *s)
Definition: mxfenc.c:2665
#define EDIT_UNITS_PER_BODY
Definition: mxfenc.c:66
static const uint8_t header_metadata_key[]
partial key for header metadata
Definition: mxfenc.c:288
static const uint8_t mxf_indirect_value_utf16le[]
Definition: mxfenc.c:1442
int profile
Definition: mxfenc.c:1935
Definition: mxf.h:42
static int64_t mxf_write_wav_common(AVFormatContext *s, AVStream *st, const UID key)
Definition: mxfenc.c:1409
int v_chroma_sub_sample
Definition: mxfenc.c:94
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
static const uint8_t header_open_partition_key[]
Definition: mxfenc.c:280
static void mxf_write_preface(AVFormatContext *s)
Definition: mxfenc.c:594
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3983
int header_written
Definition: mxfenc.c:241
static void mxf_write_random_index_pack(AVFormatContext *s)
Definition: mxfenc.c:2932
static void mxf_write_cdci_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1296
simple assert() macros that are a bit more flexible than ISO C assert().
static int mxf_write_opatom_body_partition(AVFormatContext *s)
Definition: mxfenc.c:2746
GLsizei GLsizei * length
Definition: opengl_enc.c:114
int cbr_index
use a constant bitrate index
Definition: mxfenc.c:265
static void mxf_write_content_storage(AVFormatContext *s, MXFPackage *packages, int package_count)
Definition: mxfenc.c:766
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:87
static void mxf_write_metadata_key(AVIOContext *pb, unsigned int value)
Definition: mxfenc.c:551
GLsizei count
Definition: opengl_enc.c:108
#define MXF_COMMON_OPTIONS
Definition: mxfenc.c:3101
#define FFMAX(a, b)
Definition: common.h:94
int color_siting
Definition: mxfenc.c:91
#define LIBAVFORMAT_VERSION_MINOR
Definition: version.h:35
int order
interleaving order if dts are equal
Definition: mxfenc.c:87
static void mxf_write_d10_audio_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:2714
static const uint8_t primer_pack_key[]
Definition: mxfenc.c:277
static const uint8_t system_metadata_pack_key[]
Definition: mxfenc.c:2662
static int mxf_get_essence_container_ul_index(enum AVCodecID id)
Definition: mxfenc.c:490
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
Definition: mem.c:205
int intra_only
Definition: mxfenc.c:2143
static int klv_ber_length(uint64_t len)
Definition: mxfenc.c:447
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1413
int block_align
Audio only.
Definition: avcodec.h:4104
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
static int mxf_parse_h264_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt, MXFIndexEntry *e)
Definition: mxfenc.c:2170
static const UID mxf_wav_descriptor_key
Definition: mxfenc.c:1046
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
static struct @322 state
void ffio_fill(AVIOContext *s, int b, int count)
Definition: aviobuf.c:204
#define KAG_SIZE
Definition: mxfenc.c:67
static const uint8_t op1a_ul[]
complete key for operation pattern, partitions, and primer pack
Definition: mxfenc.c:274
uint8_t frame_mbs_only_flag
Definition: avc.h:47
uint8_t interlaced
Definition: mxfenc.c:2142
static int mxf_parse_dnxhd_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:1997
#define LIBAVFORMAT_VERSION_MICRO
Definition: version.h:36
#define FF_PROFILE_PRORES_STANDARD
Definition: avcodec.h:3022
uint64_t * body_partition_offset
Definition: mxfenc.c:247
struct MXFPackage * ref
Definition: mxfenc.c:119
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:546
static const AVOption mxf_options[]
Definition: mxfenc.c:3121
ULIndex
Definition: mxfenc.c:122
void avio_wb24(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:490
static const AVClass mxf_muxer_class
Definition: mxfenc.c:3128
const char * name
Definition: avformat.h:505
static int mxf_write_partition(AVFormatContext *s, int bodysid, int indexsid, const uint8_t *key, int write_metadata)
Definition: mxfenc.c:1829
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static void mxf_write_local_tag_utf16(AVIOContext *pb, int tag, const char *value)
Definition: mxfenc.c:690
#define s(width, name)
Definition: cbs_vp9.c:257
static int mxf_write_header_metadata_sets(AVFormatContext *s)
Definition: mxfenc.c:1613
uint8_t constraint_set_flags
Definition: avc.h:43
AVDictionary * metadata
Definition: avformat.h:944
AVStream * timecode_track
Definition: mxfenc.c:252
int slice_offset
Definition: mxfenc.c:99
static const UID mxf_aes3_descriptor_key
Definition: mxfenc.c:1047
enum AVColorRange color_range
Video only.
Definition: avcodec.h:4073
const MXFCodecUL ff_mxf_data_definition_uls[]
SMPTE RP224 http://www.smpte-ra.org/mdd/index.html.
Definition: mxf.c:28
static const uint8_t system_metadata_package_set_key[]
Definition: mxfenc.c:2663
int edit_unit_byte_count
fixed edit unit byte count
Definition: mxfenc.c:254
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
#define FF_ARRAY_ELEMS(a)
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1376
static uint64_t mxf_parse_timestamp(int64_t timestamp64)
Definition: mxfenc.c:2382
if(ret)
AVRational sar
Definition: avc.h:48
Stream structure.
Definition: avformat.h:880
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:105
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int content_package_rate
content package rate in system element, see SMPTE 326M
Definition: mxfenc.c:255
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:467
uint32_t instance_number
Definition: mxfenc.c:257
static int mxf_write_user_comments(AVFormatContext *s, const AVDictionary *m)
Definition: mxfenc.c:1473
#define FF_PROFILE_PRORES_4444
Definition: avcodec.h:3024
int b_picture_count
maximum number of consecutive b pictures, used in mpeg-2 descriptor
Definition: mxfenc.c:103
int signal_standard
Definition: mxfenc.c:260
also ITU-R BT1361
Definition: pixfmt.h:470
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
static void mxf_write_local_tag(AVIOContext *pb, int size, int tag)
Definition: mxfenc.c:545
static void mxf_write_aes3_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1430
int max_gop
maximum gop size, used by mpeg-2 descriptor
Definition: mxfenc.c:102
int frame_size
Definition: mxfenc.c:2140
int last_indexed_edit_unit
Definition: mxfenc.c:246
also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
Definition: pixfmt.h:475
static const AVClass mxf_d10_muxer_class
Definition: mxfenc.c:3144
static int mxf_parse_mpeg2_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt, MXFIndexEntry *e)
Definition: mxfenc.c:2318
uint8_t profile_idc
Definition: avc.h:41
const UID * codec_ul
Definition: mxfenc.c:85
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
Timecode helpers header.
AVIOContext * pb
I/O context.
Definition: avformat.h:1399
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:196
int samples_per_frame[6]
Definition: mxf.h:87
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
static void mxf_write_essence_container_refs(AVFormatContext *s)
Definition: mxfenc.c:572
static unsigned int seed
Definition: videogen.c:78
static const UID * mxf_get_mpeg2_codec_ul(AVCodecParameters *par)
Definition: mxfenc.c:2298
static void mxf_write_package(AVFormatContext *s, MXFPackage *package)
Definition: mxfenc.c:1491
AVRational rate
frame rate in rational form
Definition: timecode.h:44
int seq_closed_gop
all gops in sequence are closed, used in mpeg-2 descriptor
Definition: mxfenc.c:101
void * buf
Definition: avisynth_c.h:766
int closed_gop
gop is closed, used in mpeg-2 frame parsing
Definition: mxfenc.c:97
uint64_t timestamp
timestamp, as year(16),month(8),day(8),hour(8),minutes(8),msec/4(8)
Definition: mxfenc.c:244
int low_delay
low delay, used in mpeg-2 descriptor
Definition: mxfenc.c:104
#define AV_STRINGIFY(s)
Definition: macros.h:36
Describe the class of an AVClass context structure.
Definition: log.h:67
AVRational aspect_ratio
display aspect ratio
Definition: mxfenc.c:96
static const MXFLocalTagPair mxf_local_tag_batch[]
SMPTE RP210 http://www.smpte-ra.org/mdd/index.html https://smpte-ra.org/sites/default/files/Labels.xml.
Definition: mxfenc.c:295
int track_instance_count
Definition: mxfenc.c:264
Rational number (pair of numerator and denominator).
Definition: rational.h:58
static int64_t mxf_write_cdci_common(AVFormatContext *s, AVStream *st, const UID key)
Definition: mxfenc.c:1081
static const struct @280 mxf_essence_mappings[]
int sample_size
size of one sample all channels included
uint16_t temporal_ref
Definition: mxfenc.c:78
static uint64_t mxf_utf16len(const char *utf8_str)
Definition: mxfenc.c:649
static void mxf_write_primer_pack(AVFormatContext *s)
Definition: mxfenc.c:508
#define FF_PROFILE_PRORES_HQ
Definition: avcodec.h:3023
int avio_put_str16le(AVIOContext *s, const char *str)
Convert an UTF-8 string to UTF-16LE and write it.
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
SMPTE ST 428-1.
Definition: pixfmt.h:487
static void mxf_write_track(AVFormatContext *s, AVStream *st, MXFPackage *package)
Definition: mxfenc.c:793
MXFIndexEntry * index_entries
Definition: mxfenc.c:242
AVRational time_base
Definition: mxfenc.c:240
AVClass * av_class
Definition: mxfenc.c:237
Definition: mxf.h:76
int video_bit_rate
Definition: mxfenc.c:98
static const uint8_t uuid_base[]
Definition: mxfenc.c:268
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
int channel_count
Definition: mxfenc.c:259
static void mxf_write_h264_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1306
#define LIBAVFORMAT_VERSION
Definition: version.h:41
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:478
#define flags(name, subs,...)
Definition: cbs_av1.c:564
static const struct @283 mxf_dv_uls[]
static int mxf_parse_prores_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:1946
static const MXFContainerEssenceEntry mxf_essence_container_uls[]
Definition: mxfenc.c:159
enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:118
const UID * container_ul
Definition: mxfenc.c:86
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:522
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
static const MXFLocalTagPair mxf_user_comments_local_tag[]
Definition: mxfenc.c:419
static int mxf_interleave_get_packet(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
Definition: mxfenc.c:3030
int sample_rate
Audio only.
Definition: avcodec.h:4097
#define DNXHD_VARIABLE
Indicate that a CIDEntry value must be read in the bitstream.
Definition: dnxhddata.h:40
static const UID mxf_d10_container_uls[]
Definition: mxfenc.c:227
int64_t footer_partition_offset
Definition: mxfenc.c:238
static const uint8_t smpte_12m_timecode_track_data_ul[]
Definition: mxfenc.c:839
Main libavformat public API header.
static void mxf_write_identification(AVFormatContext *s)
Definition: mxfenc.c:719
void ff_audio_interleave_close(AVFormatContext *s)
Definition: mxf.h:37
H264SequenceParameterSet * ff_avc_decode_sps(const uint8_t *buf, int buf_size)
Definition: avc.c:335
common internal api header.
struct AVPacketList * next
Definition: avformat.h:2032
static const uint8_t footer_partition_key[]
Definition: mxfenc.c:276
static int mxf_write_essence_container_data(AVFormatContext *s)
Definition: mxfenc.c:1591
static void write_metadata(AVFormatContext *s, unsigned int ts)
Definition: flvenc.c:274
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: avcodec.h:4047
also ITU-R BT470BG
Definition: pixfmt.h:474
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
static const MXFCodecUL * mxf_get_data_definition_ul(int type)
Definition: mxfenc.c:557
int field_dominance
tff=1, bff=2
Definition: mxfenc.c:89
static const UID mxf_avc_subdescriptor_key
Definition: mxfenc.c:1051
static const AVOption d10_options[]
Definition: mxfenc.c:3135
static int mxf_compare_timestamps(AVFormatContext *s, const AVPacket *next, const AVPacket *pkt)
Definition: mxfenc.c:3085
UID codec_ul
Definition: mxfenc.c:1936
struct AVPacketList * packet_buffer_end
Definition: internal.h:77
#define av_free(p)
int last_key_index
index of last key frame
Definition: mxfenc.c:249
int ff_audio_rechunk_interleave(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush, int(*get_packet)(AVFormatContext *, AVPacket *, AVPacket *, int), int(*compare_ts)(AVFormatContext *, const AVPacket *, const AVPacket *))
Rechunk audio PCM packets per AudioInterleaveContext->samples_per_frame and interleave them correctly...
char * value
Definition: dict.h:87
int len
void * priv_data
Format private data.
Definition: avformat.h:1385
int ff_mxf_get_content_package_rate(AVRational time_base)
Definition: mxf.c:180
static void mxf_gen_umid(AVFormatContext *s)
Definition: mxfenc.c:2398
static void mxf_deinit(AVFormatContext *s)
Definition: mxfenc.c:3016
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:349
uint8_t umid[16]
unique material identifier
Definition: mxfenc.c:258
static void mxf_write_multi_descriptor(AVFormatContext *s)
Definition: mxfenc.c:969
static void mxf_compute_edit_unit_byte_count(AVFormatContext *s)
Definition: mxfenc.c:2796
static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1424
int channels
Audio only.
Definition: avcodec.h:4093
static void mxf_write_local_tags(AVIOContext *pb, const MXFLocalTagPair *local_tags, int count)
Definition: mxfenc.c:499
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1493
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:380
#define FF_PROFILE_PRORES_PROXY
Definition: avcodec.h:3020
FILE * out
Definition: movenc.c:54
Filter the word “frame” indicates either a video frame or a group of audio samples
#define av_freep(p)
static const AVOption opatom_options[]
Definition: mxfenc.c:3151
void INT64 start
Definition: avisynth_c.h:766
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
unsigned edit_units_count
Definition: mxfenc.c:243
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
Definition: random_seed.c:120
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:545
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1027
UID uid
Definition: mxf.h:77
int stream_index
Definition: avcodec.h:1496
static const uint8_t opatom_ul[]
Definition: mxfenc.c:275
#define DESCRIPTOR_COUNT(essence_container_count)
Definition: mxfenc.c:569
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:909
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
int depth
Number of bits in the component.
Definition: pixdesc.h:58
char * name
Definition: mxfdec.c:236
static int mxf_write_opatom_packet(AVFormatContext *s, AVPacket *pkt, MXFIndexEntry *ie)
Definition: mxfenc.c:2767
uint32_t flags
flags such as drop frame, +24 hours support, ...
Definition: timecode.h:43
exp golomb vlc stuff
static void mxf_write_mpegvideo_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1324
static void mxf_write_umid(AVFormatContext *s, int type)
Definition: mxfenc.c:432
This structure stores compressed data.
Definition: avcodec.h:1471
static int mxf_parse_dv_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:2077
int essence_container_count
Definition: mxfenc.c:239
static void store_version(AVFormatContext *s)
Definition: mxfenc.c:703
static int mxf_write_tagged_value(AVFormatContext *s, const char *name, const char *value)
Definition: mxfenc.c:1444
static const uint8_t random_index_pack_key[]
Definition: mxfenc.c:279
int avpriv_dnxhd_get_hr_frame_size(int cid, int w, int h)
Definition: dnxhddata.c:1095
static void mxf_write_generic_sound_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1436
enum MXFMetadataSetType type
Definition: mxfdec.c:229
static int mxf_interleave(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
Definition: mxfenc.c:3095
struct AVPacketList * last_in_packet_buffer
last packet in packet_buffer for this stream when muxing.
Definition: avformat.h:1104
AVTimecode tc
timecode context
Definition: mxfenc.c:251
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
static int mxf_write_footer(AVFormatContext *s)
Definition: mxfenc.c:2959
static const MXFLocalTagPair mxf_avc_subdescriptor_local_tags[]
Definition: mxfenc.c:412
const char * name
Definition: opengl_enc.c:102
uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum)
Convert frame number to SMPTE 12M binary representation.
Definition: timecode.c:55
AVOutputFormat ff_mxf_opatom_muxer
Definition: mxfenc.c:3200