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