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 ST2019-4 (2009 or later) Mapping VC-3 Coding Units into the MXF Generic Container
36  * SMPTE RP210: SMPTE Metadata Dictionary
37  * SMPTE RP224: Registry of SMPTE Universal Labels
38  */
39 
40 #include <inttypes.h>
41 #include <time.h>
42 
43 #include "libavutil/mem.h"
44 #include "libavutil/opt.h"
45 #include "libavutil/random_seed.h"
46 #include "libavutil/timecode.h"
47 #include "libavutil/avassert.h"
49 #include "libavutil/pixdesc.h"
51 #include "libavcodec/defs.h"
52 #include "libavcodec/bytestream.h"
53 #include "libavcodec/golomb.h"
54 #include "libavcodec/h264.h"
55 #include "libavcodec/jpeg2000.h"
57 #include "libavcodec/rangecoder.h"
58 #include "libavcodec/startcode.h"
59 #include "avformat.h"
60 #include "avio_internal.h"
61 #include "internal.h"
62 #include "avc.h"
63 #include "nal.h"
64 #include "mux.h"
65 #include "mxf.h"
66 #include "config.h"
67 #include "version.h"
68 
69 extern const FFOutputFormat ff_mxf_d10_muxer;
71 
72 #define IS_D10(s) ((s)->oformat == &ff_mxf_d10_muxer.p)
73 #define IS_OPATOM(s) ((s)->oformat == &ff_mxf_opatom_muxer.p)
74 
75 #define EDIT_UNITS_PER_BODY 250
76 #define KAG_SIZE 512
77 
78 typedef struct MXFIndexEntry {
79  uint64_t offset;
80  unsigned slice_offset; ///< offset of audio slice
81  uint16_t temporal_ref;
82  uint8_t flags;
84 
85 typedef struct j2k_info_t {
86  uint16_t j2k_cap; ///< j2k required decoder capabilities
87  uint16_t j2k_rsiz; ///< j2k required decoder capabilities (Rsiz)
88  uint32_t j2k_xsiz; ///< j2k width of the reference grid (Xsiz)
89  uint32_t j2k_ysiz; ///< j2k height of the reference grid (Ysiz)
90  uint32_t j2k_x0siz; ///< j2k horizontal offset from the origin of the reference grid to the left side of the image (X0siz)
91  uint32_t j2k_y0siz; ///< j2k vertical offset from the origin of the reference grid to the left side of the image (Y0siz)
92  uint32_t j2k_xtsiz; ///< j2k width of one reference tile with respect to the reference grid (XTsiz)
93  uint32_t j2k_ytsiz; ///< j2k height of one reference tile with respect to the reference grid (YTsiz)
94  uint32_t j2k_xt0siz; ///< j2k horizontal offset from the origin of the reference grid to the left side of the first tile (XT0siz)
95  uint32_t j2k_yt0siz; ///< j2k vertical offset from the origin of the reference grid to the left side of the first tile (YT0siz)
96  uint8_t j2k_comp_desc[12]; ///< j2k components descriptor (Ssiz(i), XRsiz(i), YRsiz(i))
97 } j2k_info_t;
98 
99 typedef struct MXFStreamContext {
100  int64_t pkt_cnt; ///< pkt counter for muxed packets
102  int index; ///< index in mxf_essence_container_uls table
103  const UID *codec_ul;
105  int order; ///< interleaving order if dts are equal
106  int interlaced; ///< whether picture is interlaced
107  int field_dominance; ///< tff=1, bff=2
114  AVRational aspect_ratio; ///< display aspect ratio
115  int closed_gop; ///< gop is closed, used in mpeg-2 frame parsing
118  int frame_size; ///< frame size in bytes
119  int seq_closed_gop; ///< all gops in sequence are closed, used in mpeg-2 descriptor
120  int max_gop; ///< maximum gop size, used by mpeg-2 descriptor
121  int b_picture_count; ///< maximum number of consecutive b pictures, used in mpeg-2 descriptor
122  int low_delay; ///< low delay, used in mpeg-2 descriptor
124  int micro_version; ///< format micro_version, used in ffv1 descriptor
127 
128 typedef struct MXFContainerEssenceEntry {
134 
135 typedef struct MXFPackage {
136  char *name;
138  int instance;
139  struct MXFPackage *ref;
140 } MXFPackage;
141 
142 enum ULIndex {
155 };
156 
157 static const struct {
158  enum AVCodecID id;
160 } mxf_essence_mappings[] = {
170  { AV_CODEC_ID_NONE }
171 };
172 
173 static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st);
174 static void mxf_write_aes3_desc(AVFormatContext *s, AVStream *st);
176 static void mxf_write_h264_desc(AVFormatContext *s, AVStream *st);
177 static void mxf_write_ffv1_desc(AVFormatContext *s, AVStream *st);
178 static void mxf_write_cdci_desc(AVFormatContext *s, AVStream *st);
181 
183  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x60,0x01 },
184  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x15,0x01,0x05,0x00 },
185  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x00,0x00,0x00 },
187  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x03,0x00 },
188  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x16,0x01,0x03,0x00 },
189  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
191  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x01,0x00 },
192  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x16,0x01,0x01,0x00 },
193  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
195  // D-10 Video
196  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 },
197  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x05,0x01,0x01,0x00 },
198  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x01 },
200  // D-10 Audio
201  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 },
202  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x06,0x01,0x10,0x00 },
203  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
205  // DV
206  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x7F,0x01 },
207  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x18,0x01,0x01,0x00 },
208  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x00,0x00,0x00 },
210  // DNxHD
211  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0A,0x0D,0x01,0x03,0x01,0x02,0x11,0x01,0x00 },
212  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x15,0x01,0x0C,0x00 },
213  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x71,0x01,0x00,0x00 },
215  // JPEG2000
216  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 },
217  { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01,0x15,0x01,0x08,0x00 },
218  { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 },
220  // H.264
221  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x0D,0x01,0x03,0x01,0x02,0x10,0x60,0x01 },
222  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x15,0x01,0x05,0x00 },
223  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x00,0x00,0x00 },
225  // S436M ANC
226  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x0D,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 },
227  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x17,0x01,0x02,0x00 },
228  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x01,0x5C,0x00 },
230  // ProRes
231  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x1c,0x01,0x00 },
232  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01,0x15,0x01,0x17,0x00 },
233  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x03,0x00 },
235  // FFV1
236  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x23,0x01,0x00 },
237  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01,0x15,0x01,0x1d,0x00 },
238  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x09,0x00,0x00 },
240  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
241  { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
242  { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
243  NULL },
244 };
245 
246 static const UID mxf_d10_codec_uls[] = {
247  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x01 }, // D-10 625/50 PAL 50mb/s
248  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x02 }, // D-10 525/50 NTSC 50mb/s
249  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x03 }, // D-10 625/50 PAL 40mb/s
250  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x04 }, // D-10 525/50 NTSC 40mb/s
251  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x05 }, // D-10 625/50 PAL 30mb/s
252  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x06 }, // D-10 525/50 NTSC 30mb/s
253 };
254 
255 static const UID mxf_d10_container_uls[] = {
256  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, // D-10 625/50 PAL 50mb/s
257  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x02,0x01 }, // D-10 525/50 NTSC 50mb/s
258  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x03,0x01 }, // D-10 625/50 PAL 40mb/s
259  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x04,0x01 }, // D-10 525/50 NTSC 40mb/s
260  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x05,0x01 }, // D-10 625/50 PAL 30mb/s
261  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x06,0x01 }, // D-10 525/50 NTSC 30mb/s
262 };
263 
264 
265 static const UID mxf_ffv1_codec_uls[] = {
266  { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0D,0x04,0x01,0x02,0x02,0x03,0x09,0x01,0x00 }, // FFV1 version 0
267  { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0D,0x04,0x01,0x02,0x02,0x03,0x09,0x02,0x00 }, // FFV1 version 1
268  { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0D,0x04,0x01,0x02,0x02,0x03,0x09,0x03,0x00 }, // FFV1 version 2 (was only experimental)
269  { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0D,0x04,0x01,0x02,0x02,0x03,0x09,0x04,0x00 }, // FFV1 version 3
270  { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0D,0x04,0x01,0x02,0x02,0x03,0x09,0x05,0x00 }, // FFV1 version 4
271 };
272 
273 static const uint8_t product_uid[] = { 0xAD,0xAB,0x44,0x24,0x2f,0x25,0x4d,0xc7,0x92,0xff,0x29,0xbd,0x00,0x0c,0x00,0x02};
274 static const uint8_t uuid_base[] = { 0xAD,0xAB,0x44,0x24,0x2f,0x25,0x4d,0xc7,0x92,0xff };
275 static const uint8_t umid_ul[] = { 0x06,0x0A,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x01,0x0D,0x00,0x13 };
276 
277 /**
278  * complete key for operation pattern, partitions, and primer pack
279  */
280 static const uint8_t op1a_ul[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x01,0x09,0x00 };
281 static const uint8_t opatom_ul[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x02,0x01,0x10,0x03,0x00,0x00 };
282 static const uint8_t footer_partition_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }; // ClosedComplete
283 static const uint8_t primer_pack_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x05,0x01,0x00 };
284 static const uint8_t index_table_segment_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 };
285 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
286 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
287 static const uint8_t klv_fill_key[] = { 0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x01,0x02,0x10,0x01,0x00,0x00,0x00 };
288 static const uint8_t body_partition_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }; // ClosedComplete
289 
290 /**
291  * partial key for header metadata
292  */
293 static const uint8_t header_metadata_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01 };
294 static const uint8_t multiple_desc_ul[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x0D,0x01,0x03,0x01,0x02,0x7F,0x01,0x00 };
295 
296 /**
297  * SMPTE RP210 http://www.smpte-ra.org/mdd/index.html
298  * https://smpte-ra.org/sites/default/files/Labels.xml
299  */
301  // preface set
302  { 0x3C0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x15,0x02,0x00,0x00,0x00,0x00}}, /* Instance UID */
303  { 0x3B02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x04,0x00,0x00}}, /* Last Modified Date */
304  { 0x3B05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x01,0x02,0x01,0x05,0x00,0x00,0x00}}, /* Version */
305  { 0x3B07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x01,0x02,0x01,0x04,0x00,0x00,0x00}}, /* Object Model Version */
306  { 0x3B06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x04,0x00,0x00}}, /* Identifications reference */
307  { 0x3B03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x01,0x00,0x00}}, /* Content Storage reference */
308  { 0x3B09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x03,0x00,0x00,0x00,0x00}}, /* Operational Pattern UL */
309  { 0x3B0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x10,0x02,0x01,0x00,0x00}}, /* Essence Containers UL batch */
310  { 0x3B0B, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x02,0x02,0x10,0x02,0x02,0x00,0x00}}, /* DM Schemes UL batch */
311  // Identification
312  { 0x3C09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x01,0x00,0x00,0x00}}, /* This Generation UID */
313  { 0x3C01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x02,0x01,0x00,0x00}}, /* Company Name */
314  { 0x3C02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x03,0x01,0x00,0x00}}, /* Product Name */
315  { 0x3C03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x04,0x00,0x00,0x00}}, /* Product Version */
316  { 0x3C04, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x05,0x01,0x00,0x00}}, /* Version String */
317  { 0x3C05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x07,0x00,0x00,0x00}}, /* Product ID */
318  { 0x3C06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x03,0x00,0x00}}, /* Modification Date */
319  { 0x3C07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x0A,0x00,0x00,0x00}}, /* Toolkit Version */
320  { 0x3C08, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x20,0x07,0x01,0x06,0x01,0x00,0x00}}, /* Platform */
321  // Content Storage
322  { 0x1901, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x05,0x01,0x00,0x00}}, /* Package strong reference batch */
323  { 0x1902, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x05,0x02,0x00,0x00}}, /* Package strong reference batch */
324  // Essence Container Data
325  { 0x2701, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x06,0x01,0x00,0x00,0x00}}, /* Linked Package UID */
326  { 0x3F07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x01,0x03,0x04,0x04,0x00,0x00,0x00,0x00}}, /* BodySID */
327  // Package
328  { 0x4401, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x01,0x15,0x10,0x00,0x00,0x00,0x00}}, /* Package UID */
329  { 0x4405, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x01,0x03,0x00,0x00}}, /* Package Creation Date */
330  { 0x4404, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x10,0x02,0x05,0x00,0x00}}, /* Package Modified Date */
331  { 0x4402, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x01,0x03,0x03,0x02,0x01,0x00,0x00,0x00}}, /* Package Name */
332  { 0x4403, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x05,0x00,0x00}}, /* Tracks Strong reference array */
333  { 0x4701, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x03,0x00,0x00}}, /* Descriptor */
334  // Track
335  { 0x4801, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x01,0x07,0x01,0x01,0x00,0x00,0x00,0x00}}, /* Track ID */
336  { 0x4804, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x01,0x04,0x01,0x03,0x00,0x00,0x00,0x00}}, /* Track Number */
337  { 0x4B01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x05,0x30,0x04,0x05,0x00,0x00,0x00,0x00}}, /* Edit Rate */
338  { 0x4B02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x03,0x01,0x03,0x00,0x00}}, /* Origin */
339  { 0x4803, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x02,0x04,0x00,0x00}}, /* Sequence reference */
340  // Sequence
341  { 0x0201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x07,0x01,0x00,0x00,0x00,0x00,0x00}}, /* Data Definition UL */
342  { 0x0202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x02,0x01,0x01,0x03,0x00,0x00}}, /* Duration */
343  { 0x1001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x06,0x09,0x00,0x00}}, /* Structural Components reference array */
344  // Source Clip
345  { 0x1201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x03,0x01,0x04,0x00,0x00}}, /* Start position */
346  { 0x1101, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x03,0x01,0x00,0x00,0x00}}, /* SourcePackageID */
347  { 0x1102, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x03,0x02,0x00,0x00,0x00}}, /* SourceTrackID */
348  // Timecode Component
349  { 0x1501, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x07,0x02,0x01,0x03,0x01,0x05,0x00,0x00}}, /* Start Time Code */
350  { 0x1502, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x04,0x01,0x01,0x02,0x06,0x00,0x00}}, /* Rounded Time Code Base */
351  { 0x1503, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x04,0x01,0x01,0x05,0x00,0x00,0x00}}, /* Drop Frame */
352  // File Descriptor
353  { 0x3F01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x06,0x01,0x01,0x04,0x06,0x0B,0x00,0x00}}, /* Sub Descriptors reference array */
354  { 0x3006, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x06,0x01,0x01,0x03,0x05,0x00,0x00,0x00}}, /* Linked Track ID */
355  { 0x3001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x06,0x01,0x01,0x00,0x00,0x00,0x00}}, /* SampleRate */
356  { 0x3002, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x06,0x01,0x02,0x00,0x00,0x00,0x00}}, /* ContainerDuration */
357  { 0x3004, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x06,0x01,0x01,0x04,0x01,0x02,0x00,0x00}}, /* Essence Container */
358  // Generic Picture Essence Descriptor
359  { 0x320C, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x03,0x01,0x04,0x00,0x00,0x00}}, /* Frame Layout */
360  { 0x320D, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x03,0x02,0x05,0x00,0x00,0x00}}, /* Video Line Map */
361  { 0x3203, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x02,0x02,0x00,0x00,0x00}}, /* Stored Width */
362  { 0x3202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x02,0x01,0x00,0x00,0x00}}, /* Stored Height */
363  { 0x3216, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x03,0x02,0x08,0x00,0x00,0x00}}, /* Stored F2 Offset */
364  { 0x3205, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x08,0x00,0x00,0x00}}, /* Sampled Width */
365  { 0x3204, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x07,0x00,0x00,0x00}}, /* Sampled Height */
366  { 0x3206, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x09,0x00,0x00,0x00}}, /* Sampled X Offset */
367  { 0x3207, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0A,0x00,0x00,0x00}}, /* Sampled Y Offset */
368  { 0x3209, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0C,0x00,0x00,0x00}}, /* Display Width */
369  { 0x3208, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0B,0x00,0x00,0x00}}, /* Display Height */
370  { 0x320A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0D,0x00,0x00,0x00}}, /* Display X offset */
371  { 0x320B, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x0E,0x00,0x00,0x00}}, /* Presentation Y offset */
372  { 0x3217, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x03,0x02,0x07,0x00,0x00,0x00}}, /* Display F2 offset */
373  { 0x320E, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x01,0x01,0x01,0x00,0x00,0x00}}, /* Aspect Ratio */
374  { 0x3210, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x02,0x01,0x01,0x01,0x02,0x00}}, /* Transfer characteristic */
375  { 0x321A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x02,0x01,0x01,0x03,0x01,0x00}}, /* Coding Equations (color space) */
376  { 0x3219, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x09,0x04,0x01,0x02,0x01,0x01,0x06,0x01,0x00}}, /* Color Primaries */
377  { 0x3213, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x18,0x01,0x02,0x00,0x00,0x00,0x00}}, /* Image Start Offset */
378  { 0x3214, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x18,0x01,0x03,0x00,0x00,0x00,0x00}}, /* Image End Offset */
379  { 0x3201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x06,0x01,0x00,0x00,0x00,0x00}}, /* Picture Essence Coding */
380  { 0x3212, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x03,0x01,0x06,0x00,0x00,0x00}}, /* Field Dominance (Opt) */
381  { 0x3215, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x05,0x01,0x13,0x00,0x00,0x00,0x00}}, /* Signal Standard */
382  // CDCI Picture Essence Descriptor
383  { 0x3301, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x05,0x03,0x0A,0x00,0x00,0x00}}, /* Component Depth */
384  { 0x3302, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x05,0x00,0x00,0x00}}, /* Horizontal Subsampling */
385  { 0x3308, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x05,0x01,0x10,0x00,0x00,0x00}}, /* Vertical Subsampling */
386  { 0x3303, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x01,0x06,0x00,0x00,0x00}}, /* Color Siting */
387  { 0x3307, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x18,0x01,0x04,0x00,0x00,0x00,0x00}}, /* Padding Bits */
388  { 0x3304, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x03,0x03,0x00,0x00,0x00}}, /* Black Ref level */
389  { 0x3305, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x01,0x05,0x03,0x04,0x00,0x00,0x00}}, /* White Ref level */
390  { 0x3306, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x01,0x05,0x03,0x05,0x00,0x00,0x00}}, /* Color Range */
391  // Generic Sound Essence Descriptor
392  { 0x3D02, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x02,0x03,0x01,0x04,0x00,0x00,0x00}}, /* Locked/Unlocked */
393  { 0x3D03, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x01,0x01,0x01,0x00,0x00}}, /* Audio sampling rate */
394  { 0x3D04, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x01,0x04,0x02,0x01,0x01,0x03,0x00,0x00,0x00}}, /* Audio Ref Level */
395  { 0x3D07, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x01,0x01,0x04,0x00,0x00,0x00}}, /* ChannelCount */
396  { 0x3D01, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x02,0x03,0x03,0x04,0x00,0x00,0x00}}, /* Quantization bits */
397  { 0x3D06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x04,0x02,0x04,0x02,0x00,0x00,0x00,0x00}}, /* Sound Essence Compression */
398  // Index Table Segment
399  { 0x3F0B, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x05,0x30,0x04,0x06,0x00,0x00,0x00,0x00}}, /* Index Edit Rate */
400  { 0x3F0C, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x07,0x02,0x01,0x03,0x01,0x0A,0x00,0x00}}, /* Index Start Position */
401  { 0x3F0D, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x07,0x02,0x02,0x01,0x01,0x02,0x00,0x00}}, /* Index Duration */
402  { 0x3F05, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x06,0x02,0x01,0x00,0x00,0x00,0x00}}, /* Edit Unit Byte Count */
403  { 0x3F06, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x01,0x03,0x04,0x05,0x00,0x00,0x00,0x00}}, /* IndexSID */
404  { 0x3F08, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x04,0x04,0x04,0x04,0x01,0x01,0x00,0x00,0x00}}, /* Slice Count */
405  { 0x3F09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x04,0x04,0x01,0x06,0x00,0x00,0x00}}, /* Delta Entry Array */
406  { 0x3F0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x04,0x04,0x02,0x05,0x00,0x00,0x00}}, /* Index Entry Array */
407  // MPEG video Descriptor
408  { 0x8000, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x0B,0x00,0x00}}, /* BitRate */
409  { 0x8003, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x05,0x00,0x00}}, /* LowDelay */
410  { 0x8004, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x06,0x00,0x00}}, /* ClosedGOP */
411  { 0x8006, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x08,0x00,0x00}}, /* MaxGOP */
412  { 0x8007, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x0A,0x00,0x00}}, /* ProfileAndLevel */
413  { 0x8008, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x09,0x00,0x00}}, /* BPictureCount */
414  // Wave Audio Essence Descriptor
415  { 0x3D09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x03,0x05,0x00,0x00,0x00}}, /* Average Bytes Per Second */
416  { 0x3D0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x02,0x01,0x00,0x00,0x00}}, /* Block Align */
417  // mxf_user_comments_local_tag
418  { 0x4406, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x02,0x01,0x02,0x0C,0x00,0x00,0x00}}, /* User Comments */
419  { 0x5001, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x02,0x01,0x02,0x09,0x01,0x00,0x00}}, /* Name */
420  { 0x5003, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x02,0x03,0x02,0x01,0x02,0x0A,0x01,0x00,0x00}}, /* Value */
421  // mxf_avc_subdescriptor_local_tags
422  { 0x8100, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x04,0x06,0x10,0x00,0x00}}, /* SubDescriptors */
423  { 0x8200, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x0E,0x04,0x01,0x06,0x06,0x01,0x0E,0x00,0x00}}, /* AVC Decoding Delay */
424  { 0x8201, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x0E,0x04,0x01,0x06,0x06,0x01,0x0A,0x00,0x00}}, /* AVC Profile */
425  { 0x8202, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x0E,0x04,0x01,0x06,0x06,0x01,0x0D,0x00,0x00}}, /* AVC Level */
426  // ff_mxf_mastering_display_local_tags
431  // FFV1
432  { 0xDFD9, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x0E,0x04,0x01,0x06,0x0C,0x06,0x00,0x00,0x00}}, /* FFV1 Micro-version */
433  { 0xDFDA, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x0E,0x04,0x01,0x06,0x0C,0x05,0x00,0x00,0x00}}, /* FFV1 Version */
434  { 0xDFDB, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x0E,0x04,0x01,0x06,0x0C,0x01,0x00,0x00,0x00}}, /* FFV1 Initialization Metadata */
435  // ff_mxf_jpeg2000_local_tags
436  { 0x8400, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x04,0x06,0x10,0x00,0x00}}, /* Sub Descriptors / Opt Ordered array of strong references to sub descriptor sets */
437  { 0x8401, {0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x01,0x00,0x00,0x00}}, /* Rsiz: An enumerated value that defines the decoder capabilities */
438  { 0x8402, {0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x02,0x00,0x00,0x00}}, /* Xsiz: Width of the reference grid */
439  { 0x8403, {0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x03,0x00,0x00,0x00}}, /* Ysiz: Height of the reference grid */
440  { 0x8404, {0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x04,0x00,0x00,0x00}}, /* X0siz: Horizontal offset from the origin of the reference grid to the left side of the image area */
441  { 0x8405, {0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x05,0x00,0x00,0x00}}, /* Y0siz: Vertical offset from the origin of the reference grid to the left side of the image area */
442  { 0x8406, {0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x06,0x00,0x00,0x00}}, /* XTsiz: Width of one reference tile with respect to the reference grid */
443  { 0x8407, {0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x07,0x00,0x00,0x00}}, /* YTsiz: Height of one reference tile with respect to the reference grid */
444  { 0x8408, {0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x08,0x00,0x00,0x00}}, /* XT0siz: Horizontal offset from the origin of the reference grid to the left side of the first tile */
445  { 0x8409, {0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x09,0x00,0x00,0x00}}, /* YT0siz: Vertical offset from the origin of the reference grid to the left side of the first tile */
446  { 0x840A, {0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x0A,0x00,0x00,0x00}}, /* Csiz: The number of components in the picture */
447  { 0x840B, {0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x0B,0x00,0x00,0x00}}, /* Ssizi, XRSizi, YRSizi: Array of picture components where each component comprises 3 bytes named Ssizi, XRSizi, YRSizi. The array of 3-byte groups is preceded by the array header comprising a 4-byte value of the number of components followed by a 4-byte value of 3. */
448  { 0x840C, {0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0a,0x04,0x01,0x06,0x03,0x0E,0x00,0x00,0x00}}, /* The nature and order of the image components in the compressed domain as carried in the J2C codestream. */
449 };
450 
451 #define MXF_NUM_TAGS FF_ARRAY_ELEMS(mxf_local_tag_batch)
452 
453 typedef struct MXFContext {
461  uint64_t timestamp; ///< timestamp, as year(16),month(8),day(8),hour(8),minutes(8),msec/4(8)
462  uint8_t slice_count; ///< index slice count minus 1 (1 if no audio, 0 otherwise)
466  int last_key_index; ///< index of last key frame
467  uint64_t duration;
468  AVTimecode tc; ///< timecode context
470  int timecode_base; ///< rounded time code base (25 or 30)
471  int edit_unit_byte_count; ///< fixed edit unit byte count
472  int content_package_rate; ///< content package rate in system element, see SMPTE 326M
473  uint64_t body_offset;
474  uint32_t instance_number;
475  uint8_t umid[16]; ///< unique material identifier
481  int track_instance_count; // used to generate MXFTrack uuids
482  int cbr_index; ///< use a constant bitrate index
483  uint8_t unused_tags[MXF_NUM_TAGS]; ///< local tags that we know will not be used
485 } MXFContext;
486 
488 {
489  avio_write(pb, uuid_base, 10);
490  avio_wb16(pb, type);
491  avio_wb32(pb, value);
492 }
493 
495 {
496  MXFContext *mxf = s->priv_data;
497  avio_write(s->pb, umid_ul, 13);
498  avio_wb24(s->pb, mxf->instance_number);
499  avio_write(s->pb, mxf->umid, 15);
500  avio_w8(s->pb, type);
501 }
502 
503 static void mxf_write_refs_count(AVIOContext *pb, int ref_count)
504 {
505  avio_wb32(pb, ref_count);
506  avio_wb32(pb, 16);
507 }
508 
509 static int klv_ber_length(uint64_t len)
510 {
511  if (len < 128)
512  return 1;
513  else
514  return (av_log2(len) >> 3) + 2;
515 }
516 
517 static int klv_encode_ber_length(AVIOContext *pb, uint64_t len)
518 {
519  // Determine the best BER size
520  int size = klv_ber_length(len);
521  if (size == 1) {
522  //short form
523  avio_w8(pb, len);
524  return 1;
525  }
526 
527  size --;
528  // long form
529  avio_w8(pb, 0x80 + size);
530  while(size) {
531  size--;
532  avio_w8(pb, len >> 8 * size & 0xff);
533  }
534  return 0;
535 }
536 
538 {
539  avio_w8(pb, 0x80 + 3);
540  avio_wb24(pb, len);
541 }
542 
543 static void klv_encode_ber9_length(AVIOContext *pb, uint64_t len)
544 {
545  avio_w8(pb, 0x80 + 8);
546  avio_wb64(pb, len);
547 }
548 
549 /*
550  * Get essence container ul index
551  */
553 {
554  int i;
555  for (i = 0; mxf_essence_mappings[i].id; i++)
556  if (mxf_essence_mappings[i].id == id)
557  return mxf_essence_mappings[i].index;
558  return -1;
559 }
560 
562 {
563  for (int i = 0; i < MXF_NUM_TAGS; i++) {
564  if (mxf_local_tag_batch[i].local_tag == tag) {
565  return &mxf_local_tag_batch[i];
566  }
567  }
568 
569  // this assert can only be hit during development
570  av_assert0(0 && "you forgot to add your new tag to mxf_local_tag_batch");
571  return NULL;
572 }
573 
574 static void mxf_mark_tag_unused(MXFContext *mxf, int tag)
575 {
577  mxf->unused_tags[pair - mxf_local_tag_batch] = 1;
578 }
579 
581 {
582  MXFContext *mxf = s->priv_data;
583  AVIOContext *pb = s->pb;
584  int local_tag_number = MXF_NUM_TAGS, i;
585  int will_have_avc_tags = 0, will_have_mastering_tags = 0, will_have_ffv1_tags = 0, will_have_jpeg2000_tags = 0;
586 
587  for (i = 0; i < s->nb_streams; i++) {
588  MXFStreamContext *sc = s->streams[i]->priv_data;
589  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_H264 && !sc->avc_intra) {
590  will_have_avc_tags = 1;
591  }
592  if (av_packet_side_data_get(s->streams[i]->codecpar->coded_side_data,
593  s->streams[i]->codecpar->nb_coded_side_data,
595  will_have_mastering_tags = 1;
596  }
597  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_FFV1) {
598  will_have_ffv1_tags = 1;
599  }
600  if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_JPEG2000){
601  will_have_jpeg2000_tags = 1;
602  }
603  }
604 
605  if (!mxf->store_user_comments) {
606  mxf_mark_tag_unused(mxf, 0x4406);
607  mxf_mark_tag_unused(mxf, 0x5001);
608  mxf_mark_tag_unused(mxf, 0x5003);
609  }
610 
611  if (!will_have_avc_tags && !will_have_ffv1_tags) {
612  mxf_mark_tag_unused(mxf, 0x8100);
613  }
614 
615  if (!will_have_avc_tags) {
616  mxf_mark_tag_unused(mxf, 0x8200);
617  mxf_mark_tag_unused(mxf, 0x8201);
618  mxf_mark_tag_unused(mxf, 0x8202);
619  }
620 
621  if (!will_have_mastering_tags) {
622  mxf_mark_tag_unused(mxf, 0x8301);
623  mxf_mark_tag_unused(mxf, 0x8302);
624  mxf_mark_tag_unused(mxf, 0x8303);
625  mxf_mark_tag_unused(mxf, 0x8304);
626  }
627 
628  if (!will_have_ffv1_tags) {
629  mxf_mark_tag_unused(mxf, 0xDFD9);
630  mxf_mark_tag_unused(mxf, 0xDFDA);
631  mxf_mark_tag_unused(mxf, 0xDFDB);
632  }
633 
634  if (!will_have_jpeg2000_tags) {
635  mxf_mark_tag_unused(mxf, 0x8400);
636  mxf_mark_tag_unused(mxf, 0x8401);
637  mxf_mark_tag_unused(mxf, 0x8402);
638  mxf_mark_tag_unused(mxf, 0x8403);
639  mxf_mark_tag_unused(mxf, 0x8404);
640  mxf_mark_tag_unused(mxf, 0x8405);
641  mxf_mark_tag_unused(mxf, 0x8406);
642  mxf_mark_tag_unused(mxf, 0x8407);
643  mxf_mark_tag_unused(mxf, 0x8408);
644  mxf_mark_tag_unused(mxf, 0x8409);
645  mxf_mark_tag_unused(mxf, 0x840A);
646  mxf_mark_tag_unused(mxf, 0x840B);
647  mxf_mark_tag_unused(mxf, 0x840C);
648  }
649 
650  for (i = 0; i < MXF_NUM_TAGS; i++) {
651  if (mxf->unused_tags[i]) {
652  local_tag_number--;
653  }
654  }
655 
656  avio_write(pb, primer_pack_key, 16);
657  klv_encode_ber_length(pb, local_tag_number * 18 + 8);
658 
659  avio_wb32(pb, local_tag_number); // local_tag num
660  avio_wb32(pb, 18); // item size, always 18 according to the specs
661 
662  for (i = 0; i < MXF_NUM_TAGS; i++) {
663  if (mxf->unused_tags[i] == 0) {
664  avio_wb16(pb, mxf_local_tag_batch[i].local_tag);
666  }
667  }
668 }
669 
671 {
672  MXFContext *mxf = s->priv_data;
673  AVIOContext *pb = s->pb;
675 
676  // make sure the tag was not declared unnecessary upfront
677  av_assert0(mxf->unused_tags[pair - mxf_local_tag_batch] == 0);
678 
679  avio_wb16(pb, tag);
680  avio_wb16(pb, size);
681 }
682 
683 static void mxf_write_metadata_key(AVIOContext *pb, unsigned int value)
684 {
686  avio_wb24(pb, value);
687 }
688 
689 static const MXFCodecUL *mxf_get_codec_ul_by_id(const MXFCodecUL *uls, int id)
690 {
691  while (uls->uid[0]) {
692  if (id == uls->id)
693  break;
694  uls++;
695  }
696  return uls;
697 }
698 
699 //one EC -> one descriptor. N ECs -> MultipleDescriptor + N descriptors
700 #define DESCRIPTOR_COUNT(essence_container_count) \
701  (essence_container_count > 1 ? essence_container_count + 1 : essence_container_count)
702 
704 {
705  MXFContext *c = s->priv_data;
706  AVIOContext *pb = s->pb;
707  int i;
708 
709  mxf_write_refs_count(pb, DESCRIPTOR_COUNT(c->essence_container_count));
710  av_log(s,AV_LOG_DEBUG, "essence container count:%d\n", c->essence_container_count);
711  for (i = 0; i < s->nb_streams; i++) {
712  MXFStreamContext *sc = s->streams[i]->priv_data;
713  // check first track of essence container type and only write it once
714  if (sc->track_essence_element_key[15] != 0)
715  continue;
716  avio_write(pb, *sc->container_ul, 16);
717  if (c->essence_container_count == 1)
718  break;
719  }
720 
721  if (c->essence_container_count > 1)
722  avio_write(pb, multiple_desc_ul, 16);
723 }
724 
726 {
727  MXFContext *mxf = s->priv_data;
728  AVIOContext *pb = s->pb;
729 
730  mxf_write_metadata_key(pb, 0x012f00);
731  PRINT_KEY(s, "preface key", pb->buf_ptr - 16);
733 
734  // write preface set uid
735  mxf_write_local_tag(s, 16, 0x3C0A);
736  mxf_write_uuid(pb, Preface, 0);
737  PRINT_KEY(s, "preface uid", pb->buf_ptr - 16);
738 
739  // last modified date
740  mxf_write_local_tag(s, 8, 0x3B02);
741  avio_wb64(pb, mxf->timestamp);
742 
743  // write version
744  mxf_write_local_tag(s, 2, 0x3B05);
745  avio_wb16(pb, 259); // v1.3
746 
747  // Object Model Version
748  mxf_write_local_tag(s, 4, 0x3B07);
749  avio_wb32(pb, 1);
750 
751  // write identification_refs
752  mxf_write_local_tag(s, 16 + 8, 0x3B06);
753  mxf_write_refs_count(pb, 1);
755 
756  // write content_storage_refs
757  mxf_write_local_tag(s, 16, 0x3B03);
759 
760  // operational pattern
761  mxf_write_local_tag(s, 16, 0x3B09);
762  if (IS_OPATOM(s))
763  avio_write(pb, opatom_ul, 16);
764  else
765  avio_write(pb, op1a_ul, 16);
766 
767  // write essence_container_refs
770 
771  // write dm_scheme_refs
772  mxf_write_local_tag(s, 8, 0x3B0B);
773  avio_wb64(pb, 0);
774 }
775 
776 /*
777  * Returns the length of the UTF-16 string, in 16-bit characters, that would result
778  * from decoding the utf-8 string.
779  */
780 static uint64_t mxf_utf16len(const char *utf8_str)
781 {
782  const uint8_t *q = utf8_str;
783  uint64_t size = 0;
784  while (*q) {
785  uint32_t ch;
786  GET_UTF8(ch, *q++, goto invalid;)
787  if (ch < 0x10000)
788  size++;
789  else
790  size += 2;
791  continue;
792 invalid:
793  av_log(NULL, AV_LOG_ERROR, "Invalid UTF8 sequence in mxf_utf16len\n\n");
794  }
795  size += 1;
796  return size;
797 }
798 
799 /*
800  * Returns the calculated length a local tag containing an utf-8 string as utf-16
801  */
802 static int mxf_utf16_local_tag_length(const char *utf8_str)
803 {
804  uint64_t size;
805 
806  if (!utf8_str)
807  return 0;
808 
809  size = mxf_utf16len(utf8_str);
810  if (size >= UINT16_MAX/2) {
811  av_log(NULL, AV_LOG_ERROR, "utf16 local tag size %"PRIx64" invalid (too large), ignoring\n", size);
812  return 0;
813  }
814 
815  return 4 + size * 2;
816 }
817 
818 /*
819  * Write a local tag containing an utf-8 string as utf-16
820  */
821 static void mxf_write_local_tag_utf16(AVFormatContext *s, int tag, const char *value)
822 {
823  AVIOContext *pb = s->pb;
824  uint64_t size = mxf_utf16len(value);
825 
826  if (size >= UINT16_MAX/2) {
827  av_log(NULL, AV_LOG_ERROR, "utf16 local tag size %"PRIx64" invalid (too large), ignoring\n", size);
828  return;
829  }
830 
832  avio_put_str16be(pb, value);
833 }
834 
836  AVIOContext *pb = s->pb;
837 
838  if (s->flags & AVFMT_FLAG_BITEXACT) {
839  avio_wb16(pb, 0); // major
840  avio_wb16(pb, 0); // minor
841  avio_wb16(pb, 0); // tertiary
842  } else {
843  avio_wb16(pb, LIBAVFORMAT_VERSION_MAJOR); // major
844  avio_wb16(pb, LIBAVFORMAT_VERSION_MINOR); // minor
845  avio_wb16(pb, LIBAVFORMAT_VERSION_MICRO); // tertiary
846  }
847  avio_wb16(pb, 0); // patch
848  avio_wb16(pb, 0); // release
849 }
850 
851 #define PLATFORM_IDENT "Lavf " AV_STRINGIFY((OS_NAME))
853 {
854  MXFContext *mxf = s->priv_data;
855  AVIOContext *pb = s->pb;
856  AVDictionaryEntry *com_entry = av_dict_get(s->metadata, "company_name", NULL, 0);
857  AVDictionaryEntry *product_entry = av_dict_get(s->metadata, "product_name", NULL, 0);
858  AVDictionaryEntry *version_entry = av_dict_get(s->metadata, "product_version", NULL, 0);
859  const char *company = com_entry ? com_entry->value : "FFmpeg";
860  const char *product = product_entry ? product_entry->value : !IS_OPATOM(s) ? "OP1a Muxer" : "OPAtom Muxer";
861  const char *platform = s->flags & AVFMT_FLAG_BITEXACT ? "Lavf" : PLATFORM_IDENT;
862  const char *version = version_entry ? version_entry->value :
863  s->flags & AVFMT_FLAG_BITEXACT ? "0.0.0" :
865  int length;
866 
867  mxf_write_metadata_key(pb, 0x013000);
868  PRINT_KEY(s, "identification key", pb->buf_ptr - 16);
869 
870  length = 100 +mxf_utf16_local_tag_length(company) +
871  mxf_utf16_local_tag_length(product) +
872  mxf_utf16_local_tag_length(platform) +
874  klv_encode_ber_length(pb, length);
875 
876  // write uid
877  mxf_write_local_tag(s, 16, 0x3C0A);
879  PRINT_KEY(s, "identification uid", pb->buf_ptr - 16);
880 
881  // write generation uid
882  mxf_write_local_tag(s, 16, 0x3C09);
884  mxf_write_local_tag_utf16(s, 0x3C01, company); // Company Name
885  mxf_write_local_tag_utf16(s, 0x3C02, product); // Product Name
886 
887  mxf_write_local_tag(s, 10, 0x3C03); // Product Version
888  store_version(s);
889 
890  mxf_write_local_tag_utf16(s, 0x3C04, version); // Version String
891  mxf_write_local_tag_utf16(s, 0x3C08, platform); // Platform
892 
893  // write product uid
894  mxf_write_local_tag(s, 16, 0x3C05);
895  avio_write(pb, product_uid, 16);
896 
897  // modification date
898  mxf_write_local_tag(s, 8, 0x3C06);
899  avio_wb64(pb, mxf->timestamp);
900 
901  mxf_write_local_tag(s, 10, 0x3C07); // Toolkit Version
902  store_version(s);
903 }
904 
905 static void mxf_write_content_storage(AVFormatContext *s, MXFPackage *packages, int package_count)
906 {
907  AVIOContext *pb = s->pb;
908  int i;
909 
910  mxf_write_metadata_key(pb, 0x011800);
911  PRINT_KEY(s, "content storage key", pb->buf_ptr - 16);
912  klv_encode_ber_length(pb, 60 + (16 * package_count));
913 
914  // write uid
915  mxf_write_local_tag(s, 16, 0x3C0A);
917  PRINT_KEY(s, "content storage uid", pb->buf_ptr - 16);
918 
919  // write package reference
920  mxf_write_local_tag(s, 16 * package_count + 8, 0x1901);
921  mxf_write_refs_count(pb, package_count);
922  for (i = 0; i < package_count; i++) {
923  mxf_write_uuid(pb, packages[i].type, packages[i].instance);
924  }
925 
926  // write essence container data
927  mxf_write_local_tag(s, 8 + 16, 0x1902);
928  mxf_write_refs_count(pb, 1);
930 }
931 
933 {
934  MXFContext *mxf = s->priv_data;
935  AVIOContext *pb = s->pb;
936  MXFStreamContext *sc = st->priv_data;
937 
938  mxf_write_metadata_key(pb, 0x013b00);
939  PRINT_KEY(s, "track key", pb->buf_ptr - 16);
940  klv_encode_ber_length(pb, 80);
941 
942  // write track uid
943  mxf_write_local_tag(s, 16, 0x3C0A);
945  PRINT_KEY(s, "track uid", pb->buf_ptr - 16);
946 
947  // write track id
948  mxf_write_local_tag(s, 4, 0x4801);
949  avio_wb32(pb, st->index+2);
950 
951  // write track number
952  mxf_write_local_tag(s, 4, 0x4804);
953  if (package->type == MaterialPackage)
954  avio_wb32(pb, 0); // track number of material package is 0
955  else
956  avio_write(pb, sc->track_essence_element_key + 12, 4);
957 
958  // write edit rate
959  mxf_write_local_tag(s, 8, 0x4B01);
960 
961  if (st == mxf->timecode_track && IS_OPATOM(s)) {
962  avio_wb32(pb, mxf->tc.rate.num);
963  avio_wb32(pb, mxf->tc.rate.den);
964  } else {
965  avio_wb32(pb, mxf->time_base.den);
966  avio_wb32(pb, mxf->time_base.num);
967  }
968 
969  // write origin
970  mxf_write_local_tag(s, 8, 0x4B02);
971  avio_wb64(pb, 0);
972 
973  // write sequence refs
974  mxf_write_local_tag(s, 16, 0x4803);
976 }
977 
978 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 };
979 
981 {
982  MXFContext *mxf = s->priv_data;
983  AVIOContext *pb = s->pb;
984 
985  // find data define uls
986  mxf_write_local_tag(s, 16, 0x0201);
987  if (st == mxf->timecode_track)
989  else {
991  avio_write(pb, data_def_ul->uid, 16);
992  }
993 
994  // write duration
995  mxf_write_local_tag(s, 8, 0x0202);
996 
997  if (st != mxf->timecode_track && IS_OPATOM(s) && st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
998  avio_wb64(pb, mxf->body_offset / mxf->edit_unit_byte_count);
999  } else {
1000  avio_wb64(pb, mxf->duration);
1001  }
1002 }
1003 
1005 {
1006  MXFContext *mxf = s->priv_data;
1007  AVIOContext *pb = s->pb;
1008  enum MXFMetadataSetType component;
1009 
1010  mxf_write_metadata_key(pb, 0x010f00);
1011  PRINT_KEY(s, "sequence key", pb->buf_ptr - 16);
1012  klv_encode_ber_length(pb, 80);
1013 
1014  mxf_write_local_tag(s, 16, 0x3C0A);
1016 
1017  PRINT_KEY(s, "sequence uid", pb->buf_ptr - 16);
1019 
1020  // write structural component
1021  mxf_write_local_tag(s, 16 + 8, 0x1001);
1022  mxf_write_refs_count(pb, 1);
1023  if (st == mxf->timecode_track)
1024  component = TimecodeComponent;
1025  else
1026  component = SourceClip;
1027 
1028  mxf_write_uuid(pb, component, mxf->track_instance_count);
1029 }
1030 
1032 {
1033  MXFContext *mxf = s->priv_data;
1034  AVIOContext *pb = s->pb;
1035 
1036  mxf_write_metadata_key(pb, 0x011400);
1037  klv_encode_ber_length(pb, 75);
1038 
1039  // UID
1040  mxf_write_local_tag(s, 16, 0x3C0A);
1042 
1044 
1045  // Start Time Code
1046  mxf_write_local_tag(s, 8, 0x1501);
1047  avio_wb64(pb, mxf->tc.start);
1048 
1049  // Rounded Time Code Base
1050  mxf_write_local_tag(s, 2, 0x1502);
1051  avio_wb16(pb, mxf->timecode_base);
1052 
1053  // Drop Frame
1054  mxf_write_local_tag(s, 1, 0x1503);
1055  avio_w8(pb, !!(mxf->tc.flags & AV_TIMECODE_FLAG_DROPFRAME));
1056 }
1057 
1059 {
1060  MXFContext *mxf = s->priv_data;
1061  AVIOContext *pb = s->pb;
1062 
1063  mxf_write_metadata_key(pb, 0x011100);
1064  PRINT_KEY(s, "sturctural component key", pb->buf_ptr - 16);
1065  klv_encode_ber_length(pb, 108);
1066 
1067  // write uid
1068  mxf_write_local_tag(s, 16, 0x3C0A);
1070 
1071  PRINT_KEY(s, "structural component uid", pb->buf_ptr - 16);
1073 
1074  // write start_position
1075  mxf_write_local_tag(s, 8, 0x1201);
1076  avio_wb64(pb, 0);
1077 
1078  // write source package uid, end of the reference
1079  mxf_write_local_tag(s, 32, 0x1101);
1080  if (!package->ref) {
1081  ffio_fill(pb, 0, 32);
1082  } else
1083  mxf_write_umid(s, package->ref->instance);
1084 
1085  // write source track id
1086  mxf_write_local_tag(s, 4, 0x1102);
1087  if (package->type == SourcePackage && !package->ref)
1088  avio_wb32(pb, 0);
1089  else
1090  avio_wb32(pb, st->index+2);
1091 }
1092 
1094 {
1095  AVIOContext *pb = s->pb;
1096 
1097  mxf_write_metadata_key(pb, 0x012e00);
1098  PRINT_KEY(s, "tape descriptor key", pb->buf_ptr - 16);
1099  klv_encode_ber_length(pb, 20);
1100  mxf_write_local_tag(s, 16, 0x3C0A);
1102  PRINT_KEY(s, "tape_desc uid", pb->buf_ptr - 16);
1103 }
1104 
1105 
1107 {
1108  MXFContext *mxf = s->priv_data;
1109  AVIOContext *pb = s->pb;
1110  const uint8_t *ul;
1111  int i;
1112 
1113  mxf_write_metadata_key(pb, 0x014400);
1114  PRINT_KEY(s, "multiple descriptor key", pb->buf_ptr - 16);
1115  klv_encode_ber_length(pb, 64 + 16LL * s->nb_streams);
1116 
1117  mxf_write_local_tag(s, 16, 0x3C0A);
1119  PRINT_KEY(s, "multi_desc uid", pb->buf_ptr - 16);
1120 
1121  // write sample rate
1122  mxf_write_local_tag(s, 8, 0x3001);
1123  avio_wb32(pb, mxf->time_base.den);
1124  avio_wb32(pb, mxf->time_base.num);
1125 
1126  // write essence container ul
1127  mxf_write_local_tag(s, 16, 0x3004);
1128  if (mxf->essence_container_count > 1)
1129  ul = multiple_desc_ul;
1130  else {
1131  MXFStreamContext *sc = s->streams[0]->priv_data;
1132  ul = *sc->container_ul;
1133  }
1134  avio_write(pb, ul, 16);
1135 
1136  // write sub descriptor refs
1137  mxf_write_local_tag(s, s->nb_streams * 16 + 8, 0x3F01);
1138  mxf_write_refs_count(pb, s->nb_streams);
1139  for (i = 0; i < s->nb_streams; i++)
1141 }
1142 
1144 {
1145  MXFContext *mxf = s->priv_data;
1146  MXFStreamContext *sc = st->priv_data;
1147  AVIOContext *pb = s->pb;
1148  int64_t pos;
1149 
1150  avio_write(pb, key, 16);
1151  klv_encode_ber4_length(pb, 0);
1152  pos = avio_tell(pb);
1153 
1154  mxf_write_local_tag(s, 16, 0x3C0A);
1156 
1157  mxf_write_local_tag(s, 4, 0x3006);
1158  avio_wb32(pb, st->index+2);
1159 
1160  mxf_write_local_tag(s, 8, 0x3001);
1161  if (IS_D10(s)) {
1162  avio_wb32(pb, mxf->time_base.den);
1163  avio_wb32(pb, mxf->time_base.num);
1164  } else {
1165  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE ||
1167  avio_wb32(pb, st->codecpar->sample_rate);
1168  avio_wb32(pb, 1);
1169  } else {
1170  avio_wb32(pb, mxf->time_base.den);
1171  avio_wb32(pb, mxf->time_base.num);
1172  }
1173  }
1174 
1175  mxf_write_local_tag(s, 16, 0x3004);
1176  avio_write(pb, *sc->container_ul, 16);
1177 
1178  return pos;
1179 }
1180 
1181 static const UID mxf_s436m_anc_descriptor_key = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5c,0x00 };
1182 static const UID mxf_mpegvideo_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 };
1183 static const UID mxf_wav_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 };
1184 static const UID mxf_aes3_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 };
1185 static const UID mxf_cdci_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x28,0x00 };
1186 static const UID mxf_rgba_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x29,0x00 };
1187 static const UID mxf_generic_sound_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x42,0x00 };
1188 
1189 static const UID mxf_avc_subdescriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x6E,0x00 };
1190 static const UID mxf_ffv1_subdescriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x81,0x03 };
1191 static const UID mxf_jpeg2000_subdescriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x5A,0x00};
1192 
1193 static inline uint16_t rescale_mastering_chroma(AVRational q)
1194 {
1196 }
1197 
1198 static inline uint32_t rescale_mastering_luma(AVRational q)
1199 {
1201 }
1202 
1204 {
1205  MXFStreamContext *sc = st->priv_data;
1206  AVIOContext *pb = s->pb;
1207  int stored_width = st->codecpar->width;
1208  int stored_height = st->codecpar->height;
1209  int display_width;
1210  int display_height;
1211  int f1, f2;
1212  const MXFCodecUL *color_primaries_ul;
1213  const MXFCodecUL *color_trc_ul;
1214  const MXFCodecUL *color_space_ul;
1216  const AVPacketSideData *side_data;
1217 
1221 
1222  if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO) {
1223  if (st->codecpar->height == 1080)
1224  stored_width = 1920;
1225  else if (st->codecpar->height == 720)
1226  stored_width = 1280;
1227  }
1228  display_width = stored_width;
1229 
1230  switch (st->codecpar->codec_id) {
1232  case AV_CODEC_ID_H264:
1233  //Based on 16x16 macroblocks
1234  stored_width = (stored_width+15)/16*16;
1235  stored_height = (stored_height+15)/16*16;
1236  break;
1237  default:
1238  break;
1239  }
1240 
1241  //Stored width
1242  mxf_write_local_tag(s, 4, 0x3203);
1243  avio_wb32(pb, stored_width);
1244 
1245  //Stored height
1246  mxf_write_local_tag(s, 4, 0x3202);
1247  avio_wb32(pb, stored_height>>sc->interlaced);
1248 
1249  if (IS_D10(s)) {
1250  //Stored F2 Offset
1251  mxf_write_local_tag(s, 4, 0x3216);
1252  avio_wb32(pb, 0);
1253 
1254  //Image Start Offset
1255  mxf_write_local_tag(s, 4, 0x3213);
1256  avio_wb32(pb, 0);
1257 
1258  //Image End Offset
1259  mxf_write_local_tag(s, 4, 0x3214);
1260  avio_wb32(pb, 0);
1261  }
1262 
1263  //Sampled width
1264  mxf_write_local_tag(s, 4, 0x3205);
1265  avio_wb32(pb, display_width);
1266 
1267  //Samples height
1268  mxf_write_local_tag(s, 4, 0x3204);
1269  avio_wb32(pb, st->codecpar->height>>sc->interlaced);
1270 
1271  //Sampled X Offset
1272  mxf_write_local_tag(s, 4, 0x3206);
1273  avio_wb32(pb, 0);
1274 
1275  //Sampled Y Offset
1276  mxf_write_local_tag(s, 4, 0x3207);
1277  avio_wb32(pb, 0);
1278 
1279  //Display width
1280  mxf_write_local_tag(s, 4, 0x3209);
1281  avio_wb32(pb, display_width);
1282 
1283  if (st->codecpar->height == 608) // PAL + VBI
1284  display_height = 576;
1285  else if (st->codecpar->height == 512) // NTSC + VBI
1286  display_height = 486;
1287  else
1288  display_height = st->codecpar->height;
1289 
1290  //Display height
1291  mxf_write_local_tag(s, 4, 0x3208);
1292  avio_wb32(pb, display_height>>sc->interlaced);
1293 
1294  // display X offset
1295  mxf_write_local_tag(s, 4, 0x320A);
1296  avio_wb32(pb, 0);
1297 
1298  // display Y offset
1299  mxf_write_local_tag(s, 4, 0x320B);
1300  avio_wb32(pb, (st->codecpar->height - display_height)>>sc->interlaced);
1301 
1302  if (sc->interlaced) {
1303  //Display F2 Offset
1304  mxf_write_local_tag(s, 4, 0x3217);
1305  avio_wb32(pb, -((st->codecpar->height - display_height)&1));
1306  }
1307 
1308  if (key != mxf_rgba_descriptor_key) {
1309  // component depth
1310  mxf_write_local_tag(s, 4, 0x3301);
1311  avio_wb32(pb, sc->component_depth);
1312 
1313  // horizontal subsampling
1314  mxf_write_local_tag(s, 4, 0x3302);
1315  avio_wb32(pb, sc->h_chroma_sub_sample);
1316 
1317  // vertical subsampling
1318  mxf_write_local_tag(s, 4, 0x3308);
1319  avio_wb32(pb, sc->v_chroma_sub_sample);
1320 
1321  // color siting
1322  mxf_write_local_tag(s, 1, 0x3303);
1323  avio_w8(pb, sc->color_siting);
1324 
1325  // Padding Bits
1326  mxf_write_local_tag(s, 2, 0x3307);
1327  avio_wb16(pb, 0);
1328 
1330  int black = 0,
1331  white = (1<<sc->component_depth) - 1,
1332  color = (1<<sc->component_depth);
1333  if (st->codecpar->color_range == AVCOL_RANGE_MPEG) {
1334  black = 1 << (sc->component_depth - 4);
1335  white = 235 << (sc->component_depth - 8);
1336  color = (14 << (sc->component_depth - 4)) + 1;
1337  }
1338  mxf_write_local_tag(s, 4, 0x3304);
1339  avio_wb32(pb, black);
1340  mxf_write_local_tag(s, 4, 0x3305);
1341  avio_wb32(pb, white);
1342  mxf_write_local_tag(s, 4, 0x3306);
1343  avio_wb32(pb, color);
1344  }
1345  }
1346 
1347  if (sc->signal_standard) {
1348  mxf_write_local_tag(s, 1, 0x3215);
1349  avio_w8(pb, sc->signal_standard);
1350  }
1351 
1352  // frame layout
1353  mxf_write_local_tag(s, 1, 0x320C);
1354  avio_w8(pb, sc->interlaced);
1355 
1356  // video line map
1357  switch (st->codecpar->height) {
1358  case 576: f1 = 23; f2 = st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO ? 335 : 336; break;
1359  case 608: f1 = 7; f2 = 320; break;
1360  case 480: f1 = 20; f2 = st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO ? 285 : 283; break;
1361  case 512: f1 = 7; f2 = 270; break;
1362  case 720: f1 = 26; f2 = 0; break; // progressive
1363  case 1080: f1 = 21; f2 = 584; break;
1364  default: f1 = 0; f2 = 0; break;
1365  }
1366 
1367  if (!sc->interlaced && f2) {
1368  f2 = 0;
1369  f1 *= 2;
1370  }
1371 
1372 
1373  mxf_write_local_tag(s, 16, 0x320D);
1374  avio_wb32(pb, 2);
1375  avio_wb32(pb, 4);
1376  avio_wb32(pb, f1);
1377  avio_wb32(pb, f2);
1378 
1379  mxf_write_local_tag(s, 8, 0x320E);
1380  avio_wb32(pb, sc->aspect_ratio.num);
1381  avio_wb32(pb, sc->aspect_ratio.den);
1382 
1383  if (color_primaries_ul->uid[0]) {
1384  mxf_write_local_tag(s, 16, 0x3219);
1385  avio_write(pb, color_primaries_ul->uid, 16);
1386  };
1387 
1388  if (color_trc_ul->uid[0]) {
1389  mxf_write_local_tag(s, 16, 0x3210);
1390  avio_write(pb, color_trc_ul->uid, 16);
1391  };
1392 
1393  if (color_space_ul->uid[0]) {
1394  mxf_write_local_tag(s, 16, 0x321A);
1395  avio_write(pb, color_space_ul->uid, 16);
1396  };
1397 
1398  mxf_write_local_tag(s, 16, 0x3201);
1399  avio_write(pb, *sc->codec_ul, 16);
1400 
1401  // Mastering Display metadata
1405  if (side_data) {
1406  const AVMasteringDisplayMetadata *metadata = (const AVMasteringDisplayMetadata*)side_data->data;
1407  if (metadata->has_primaries) {
1408  mxf_write_local_tag(s, 12, 0x8301);
1415  mxf_write_local_tag(s, 4, 0x8302);
1416  avio_wb16(pb, rescale_mastering_chroma(metadata->white_point[0]));
1417  avio_wb16(pb, rescale_mastering_chroma(metadata->white_point[1]));
1418  } else {
1419  av_log(NULL, AV_LOG_VERBOSE, "Not writing mastering display primaries. Missing data.\n");
1420  }
1421  if (metadata->has_luminance) {
1422  mxf_write_local_tag(s, 4, 0x8303);
1424  mxf_write_local_tag(s, 4, 0x8304);
1426  } else {
1427  av_log(NULL, AV_LOG_VERBOSE, "Not writing mastering display luminances. Missing data.\n");
1428  }
1429  }
1430 
1431  if (sc->interlaced && sc->field_dominance) {
1432  mxf_write_local_tag(s, 1, 0x3212);
1433  avio_w8(pb, sc->field_dominance);
1434  }
1435 
1436  if (st->codecpar->codec_id == AV_CODEC_ID_H264 && !sc->avc_intra) {
1437  // write avc sub descriptor ref
1438  mxf_write_local_tag(s, 8 + 16, 0x8100);
1439  mxf_write_refs_count(pb, 1);
1441  }
1442 
1443  if (st->codecpar->codec_id == AV_CODEC_ID_FFV1) {
1444  // write ffv1 sub descriptor ref
1445  mxf_write_local_tag(s, 8 + 16, 0x8100);
1446  mxf_write_refs_count(pb, 1);
1448  }
1449 
1450  return pos;
1451 }
1452 
1454 {
1455  int64_t cur_pos = avio_tell(pb);
1456  int size = cur_pos - pos;
1457  avio_seek(pb, pos - 4, SEEK_SET);
1459  avio_seek(pb, cur_pos, SEEK_SET);
1460 }
1461 
1463 {
1464  AVIOContext *pb = s->pb;
1465  int64_t pos;
1466 
1468  klv_encode_ber4_length(pb, 0);
1469  pos = avio_tell(pb);
1470 
1471  mxf_write_local_tag(s, 16, 0x3C0A);
1473 
1474  mxf_write_local_tag(s, 1, 0x8200);
1475  avio_w8(pb, 0xFF); // AVC Decoding Delay, unknown
1476 
1477  mxf_write_local_tag(s, 1, 0x8201);
1478  avio_w8(pb, st->codecpar->profile); // AVC Profile
1479 
1480  mxf_write_local_tag(s, 1, 0x8202);
1481  avio_w8(pb, st->codecpar->level); // AVC Level
1482 
1483  mxf_update_klv_size(s->pb, pos);
1484 }
1485 
1487 {
1488  MXFStreamContext *sc = st->priv_data;
1489  AVIOContext *pb = s->pb;
1490  int64_t pos;
1491  int component_count = av_pix_fmt_count_planes(st->codecpar->format);
1492 
1493  /* JPEG2000 subdescriptor key */
1495  klv_encode_ber4_length(pb, 0);
1496  pos = avio_tell(pb);
1497 
1498  mxf_write_local_tag(s, 16, 0x3C0A);
1500 
1501  /* Value defining the decoder capabilities (rsiz) */
1502  mxf_write_local_tag(s, 2, 0x8401);
1503  avio_wb16(pb, sc->j2k_info.j2k_rsiz);
1504  /* Width of the JPEG2000 reference grid (Xsiz) */
1505  mxf_write_local_tag(s, 4, 0x8402);
1506  avio_wb32(pb, st->codecpar->width);
1507  /* Height of the JPEG2000 reference grid (Ysiz) */
1508  mxf_write_local_tag(s, 4, 0x8403);
1509  avio_wb32(pb, st->codecpar->height);
1510  /* Horizontal offset from the reference grid origin to the left side of the image area (X0siz) */
1511  mxf_write_local_tag(s, 4, 0x8404);
1512  avio_wb32(pb, sc->j2k_info.j2k_x0siz);
1513  /* Vertical offset from the reference grid origin to the left side of the image area (Y0siz) */
1514  mxf_write_local_tag(s, 4, 0x8405);
1515  avio_wb32(pb, sc->j2k_info.j2k_y0siz);
1516  /* Width of one reference tile with respect to the reference grid (XTsiz) */
1517  mxf_write_local_tag(s, 4, 0x8406);
1518  avio_wb32(pb, sc->j2k_info.j2k_xtsiz);
1519  /* Height of one reference tile with respect to the reference grid (YTsiz) */
1520  mxf_write_local_tag(s, 4, 0x8407);
1521  avio_wb32(pb, sc->j2k_info.j2k_ytsiz);
1522  /* Horizontal offset from the origin of the reference grid to the left side of the first tile (XT0siz) */
1523  mxf_write_local_tag(s, 4, 0x8408);
1524  avio_wb32(pb, sc->j2k_info.j2k_xt0siz);
1525  /* Vertical offset from the origin of the reference grid to the left side of the first tile (YT0siz) */
1526  mxf_write_local_tag(s, 4, 0x8409);
1527  avio_wb32(pb, sc->j2k_info.j2k_yt0siz);
1528  /* Image components number (Csiz) */
1529  mxf_write_local_tag(s, 2, 0x840A);
1530  avio_wb16(pb, component_count);
1531  /* Array of picture components where each component comprises 3 bytes named Ssiz(i) (Pixel bitdepth - 1),
1532  XRSiz(i) (Horizontal sampling), YRSiz(i) (Vertical sampling). The array of 3-byte groups is preceded
1533  by the array header comprising a 4-byte value of the number of components followed by a 4-byte
1534  value of 3. */
1535  mxf_write_local_tag(s, 8 + 3*component_count, 0x840B);
1536  avio_wb32(pb, component_count);
1537  avio_wb32(pb, 3);
1538  avio_write(pb, sc->j2k_info.j2k_comp_desc, 3*component_count);
1539 
1540  mxf_update_klv_size(pb, pos);
1541 }
1542 
1544 {
1546  mxf_update_klv_size(s->pb, pos);
1547 
1548  if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
1549  mxf_write_avc_subdesc(s, st);
1550  }
1551  if (st->codecpar->codec_id == AV_CODEC_ID_JPEG2000) {
1553  }
1554 }
1555 
1557 {
1558  MXFStreamContext *sc = st->priv_data;
1559  if (sc->avc_intra) {
1561  } else {
1563  mxf_update_klv_size(s->pb, pos);
1564  mxf_write_avc_subdesc(s, st);
1565  }
1566 }
1567 
1569 {
1570  AVIOContext *pb = s->pb;
1571  MXFStreamContext *sc = st->priv_data;
1572  int64_t pos;
1573 
1575  klv_encode_ber4_length(pb, 0);
1576  pos = avio_tell(pb);
1577 
1578  mxf_write_local_tag(s, 16, 0x3C0A);
1580 
1581  if (st->codecpar->extradata_size) {
1583  avio_write(pb, st->codecpar->extradata, st->codecpar->extradata_size); // FFV1InitializationMetadata
1584  }
1585 
1586  mxf_write_local_tag(s, 2, 0xDFDA);
1587  avio_wb16(pb, (*sc->codec_ul)[14]); // FFV1Version
1588 
1589  if (st->codecpar->extradata_size) {
1590  mxf_write_local_tag(s, 2, 0xDFD9);
1591  avio_wb16(pb, sc->micro_version); // FFV1MicroVersion
1592  }
1593 
1594  mxf_update_klv_size(s->pb, pos);
1595 }
1596 
1598 {
1599  int is_rgb, pos;
1601  av_assert0(desc);
1602  is_rgb = desc->flags & AV_PIX_FMT_FLAG_RGB;
1603 
1605  mxf_update_klv_size(s->pb, pos);
1607 }
1608 
1610 {
1612  mxf_update_klv_size(s->pb, pos);
1613 }
1614 
1616 {
1617  AVIOContext *pb = s->pb;
1618  MXFStreamContext *sc = st->priv_data;
1619  int profile_and_level = (st->codecpar->profile<<4) | st->codecpar->level;
1621 
1622  if (st->codecpar->codec_id != AV_CODEC_ID_H264) {
1623  // bit rate
1624  mxf_write_local_tag(s, 4, 0x8000);
1625  avio_wb32(pb, sc->video_bit_rate);
1626 
1627  // profile and level
1628  mxf_write_local_tag(s, 1, 0x8007);
1629  if (!st->codecpar->profile)
1630  profile_and_level |= 0x80; // escape bit
1631  avio_w8(pb, profile_and_level);
1632 
1633  // low delay
1634  mxf_write_local_tag(s, 1, 0x8003);
1635  avio_w8(pb, sc->low_delay);
1636 
1637  // closed gop
1638  mxf_write_local_tag(s, 1, 0x8004);
1639  avio_w8(pb, sc->seq_closed_gop);
1640 
1641  // max gop
1642  mxf_write_local_tag(s, 2, 0x8006);
1643  avio_wb16(pb, sc->max_gop);
1644 
1645  // b picture count
1646  mxf_write_local_tag(s, 2, 0x8008);
1647  avio_wb16(pb, sc->b_picture_count);
1648  }
1649 
1650  mxf_update_klv_size(pb, pos);
1651 }
1652 
1654 {
1655  AVIOContext *pb = s->pb;
1656  MXFContext *mxf = s->priv_data;
1657  int show_warnings = !mxf->footer_partition_offset;
1659 
1660  if (IS_OPATOM(s)) {
1661  mxf_write_local_tag(s, 8, 0x3002);
1662  avio_wb64(pb, mxf->body_offset / mxf->edit_unit_byte_count);
1663  }
1664 
1665  // audio locked
1666  mxf_write_local_tag(s, 1, 0x3D02);
1667  avio_w8(pb, 1);
1668 
1669  // write audio sampling rate
1670  mxf_write_local_tag(s, 8, 0x3D03);
1671  avio_wb32(pb, st->codecpar->sample_rate);
1672  avio_wb32(pb, 1);
1673 
1674  if (IS_D10(s)) {
1675  mxf_write_local_tag(s, 1, 0x3D04);
1676  avio_w8(pb, 0);
1677  }
1678 
1679  mxf_write_local_tag(s, 4, 0x3D07);
1680  if (mxf->channel_count == -1) {
1681  if (show_warnings && IS_D10(s) &&
1682  (st->codecpar->ch_layout.nb_channels != 4) &&
1683  (st->codecpar->ch_layout.nb_channels != 8))
1684  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");
1686  } else if (IS_D10(s)) {
1687  if (show_warnings && (mxf->channel_count < st->codecpar->ch_layout.nb_channels))
1688  av_log(s, AV_LOG_WARNING, "d10_channelcount < actual number of audio channels : some channels will be discarded\n");
1689  if (show_warnings && (mxf->channel_count != 4) && (mxf->channel_count != 8))
1690  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");
1691  avio_wb32(pb, mxf->channel_count);
1692  } else {
1694  }
1695 
1696  mxf_write_local_tag(s, 4, 0x3D01);
1698 
1699  return pos;
1700 }
1701 
1703 {
1704  AVIOContext *pb = s->pb;
1706 
1707  mxf_write_local_tag(s, 2, 0x3D0A);
1708  avio_wb16(pb, st->codecpar->block_align);
1709 
1710  // avg bytes per sec
1711  mxf_write_local_tag(s, 4, 0x3D09);
1713 
1714  return pos;
1715 }
1716 
1718 {
1720  mxf_update_klv_size(s->pb, pos);
1721 }
1722 
1724 {
1726  mxf_update_klv_size(s->pb, pos);
1727 }
1728 
1730 {
1732  mxf_update_klv_size(s->pb, pos);
1733 }
1734 
1735 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 };
1736 
1737 static int mxf_write_tagged_value(AVFormatContext *s, const char* name, const char* value)
1738 {
1739  MXFContext *mxf = s->priv_data;
1740  AVIOContext *pb = s->pb;
1741  int name_size = mxf_utf16_local_tag_length(name);
1742  int indirect_value_size = 13 + mxf_utf16_local_tag_length(value);
1743 
1744  if (!name_size || indirect_value_size == 13)
1745  return 1;
1746 
1747  mxf_write_metadata_key(pb, 0x013f00);
1748  klv_encode_ber_length(pb, 24 + name_size + indirect_value_size);
1749 
1750  // write instance UID
1751  mxf_write_local_tag(s, 16, 0x3C0A);
1753 
1754  // write name
1755  mxf_write_local_tag_utf16(s, 0x5001, name); // Name
1756 
1757  // write indirect value
1758  mxf_write_local_tag(s, indirect_value_size, 0x5003);
1760  avio_put_str16le(pb, value);
1761 
1762  mxf->tagged_value_count++;
1763  return 0;
1764 }
1765 
1767 {
1768  MXFContext *mxf = s->priv_data;
1769  AVDictionaryEntry *t = NULL;
1770  int count = 0;
1771 
1772  while ((t = av_dict_get(m, "comment_", t, AV_DICT_IGNORE_SUFFIX))) {
1773  if (mxf->tagged_value_count >= UINT16_MAX) {
1774  av_log(s, AV_LOG_ERROR, "too many tagged values, ignoring remaining\n");
1775  return count;
1776  }
1777 
1778  if (mxf_write_tagged_value(s, t->key + 8, t->value) == 0)
1779  count++;
1780  }
1781  return count;
1782 }
1783 
1785 {
1786  MXFContext *mxf = s->priv_data;
1787  AVIOContext *pb = s->pb;
1788  int i, track_count = s->nb_streams+1;
1789  int name_size = mxf_utf16_local_tag_length(package->name);
1790  int user_comment_count = 0;
1791 
1792  if (package->type == MaterialPackage) {
1793  if (mxf->store_user_comments)
1794  user_comment_count = mxf_write_user_comments(s, s->metadata);
1795  mxf_write_metadata_key(pb, 0x013600);
1796  PRINT_KEY(s, "Material Package key", pb->buf_ptr - 16);
1797  klv_encode_ber_length(pb, 92 + name_size + (16*track_count) + (16*user_comment_count) + 12LL*mxf->store_user_comments);
1798  } else {
1799  mxf_write_metadata_key(pb, 0x013700);
1800  PRINT_KEY(s, "Source Package key", pb->buf_ptr - 16);
1801  klv_encode_ber_length(pb, 112 + name_size + (16*track_count) + 12LL*mxf->store_user_comments); // 20 bytes length for descriptor reference
1802  }
1803 
1804  // write uid
1805  mxf_write_local_tag(s, 16, 0x3C0A);
1806  mxf_write_uuid(pb, package->type, package->instance);
1807  av_log(s, AV_LOG_DEBUG, "package type:%d\n", package->type);
1808  PRINT_KEY(s, "package uid", pb->buf_ptr - 16);
1809 
1810  // write package umid
1811  mxf_write_local_tag(s, 32, 0x4401);
1812  mxf_write_umid(s, package->instance);
1813  PRINT_KEY(s, "package umid second part", pb->buf_ptr - 16);
1814 
1815  // package name
1816  if (name_size)
1817  mxf_write_local_tag_utf16(s, 0x4402, package->name);
1818 
1819  // package creation date
1820  mxf_write_local_tag(s, 8, 0x4405);
1821  avio_wb64(pb, mxf->timestamp);
1822 
1823  // package modified date
1824  mxf_write_local_tag(s, 8, 0x4404);
1825  avio_wb64(pb, mxf->timestamp);
1826 
1827  // write track refs
1828  mxf_write_local_tag(s, track_count*16 + 8, 0x4403);
1829  mxf_write_refs_count(pb, track_count);
1830  // these are the uuids of the tracks the will be written in mxf_write_track
1831  for (i = 0; i < track_count; i++)
1833 
1834  // write user comment refs
1835  if (mxf->store_user_comments) {
1836  mxf_write_local_tag(s, user_comment_count*16 + 8, 0x4406);
1837  mxf_write_refs_count(pb, user_comment_count);
1838  for (i = 0; i < user_comment_count; i++)
1839  mxf_write_uuid(pb, TaggedValue, mxf->tagged_value_count - user_comment_count + i);
1840  }
1841 
1842  // write multiple descriptor reference
1843  if (package->type == SourcePackage && package->instance == 1) {
1844  mxf_write_local_tag(s, 16, 0x4701);
1845  if (s->nb_streams > 1) {
1848  } else
1849  mxf_write_uuid(pb, SubDescriptor, 0);
1850  } else if (package->type == SourcePackage && package->instance == 2) {
1851  mxf_write_local_tag(s, 16, 0x4701);
1854  }
1855 
1856  /*
1857  * for every 1 track in a package there is 1 sequence and 1 component.
1858  * all 3 of these elements share the same instance number for generating
1859  * there instance uuids. mxf->track_instance_count stores this value.
1860  * mxf->track_instance_count is incremented after a group of all 3 of
1861  * these elements are written.
1862  */
1863 
1864  // write timecode track
1865  mxf_write_track(s, mxf->timecode_track, package);
1866  mxf_write_sequence(s, mxf->timecode_track, package);
1868  mxf->track_instance_count++;
1869 
1870  for (i = 0; i < s->nb_streams; i++) {
1871  AVStream *st = s->streams[i];
1872  mxf_write_track(s, st, package);
1873  mxf_write_sequence(s, st, package);
1874  mxf_write_structural_component(s, st, package);
1875  mxf->track_instance_count++;
1876 
1877  if (package->type == SourcePackage && package->instance == 1) {
1878  MXFStreamContext *sc = st->priv_data;
1880  }
1881  }
1882 }
1883 
1885 {
1886  AVIOContext *pb = s->pb;
1887 
1888  mxf_write_metadata_key(pb, 0x012300);
1889  klv_encode_ber_length(pb, 72);
1890 
1891  mxf_write_local_tag(s, 16, 0x3C0A); // Instance UID
1893 
1894  mxf_write_local_tag(s, 32, 0x2701); // Linked Package UID
1895  mxf_write_umid(s, 1);
1896 
1897  mxf_write_local_tag(s, 4, 0x3F07); // BodySID
1898  avio_wb32(pb, 1);
1899 
1900  mxf_write_local_tag(s, 4, 0x3F06); // IndexSID
1901  avio_wb32(pb, 2);
1902 
1903  return 0;
1904 }
1905 
1907 {
1908  MXFContext *mxf = s->priv_data;
1910  AVStream *st = NULL;
1911  int i;
1912  MXFPackage packages[3] = {{0}};
1913  int package_count = 2;
1914  packages[0].type = MaterialPackage;
1915  packages[1].type = SourcePackage;
1916  packages[1].instance = 1;
1917  packages[0].ref = &packages[1];
1918 
1919 
1920  if (entry = av_dict_get(s->metadata, "material_package_name", NULL, 0))
1921  packages[0].name = entry->value;
1922 
1923  if (entry = av_dict_get(s->metadata, "file_package_name", NULL, 0)) {
1924  packages[1].name = entry->value;
1925  } else {
1926  /* check if any of the streams contain a file_package_name */
1927  for (i = 0; i < s->nb_streams; i++) {
1928  st = s->streams[i];
1929  if (entry = av_dict_get(st->metadata, "file_package_name", NULL, 0)) {
1930  packages[1].name = entry->value;
1931  break;
1932  }
1933  }
1934  }
1935 
1936  entry = av_dict_get(s->metadata, "reel_name", NULL, 0);
1937  if (entry) {
1938  packages[2].name = entry->value;
1939  packages[2].type = SourcePackage;
1940  packages[2].instance = 2;
1941  packages[1].ref = &packages[2];
1942  package_count = 3;
1943  }
1944 
1947  mxf_write_content_storage(s, packages, package_count);
1948  mxf->track_instance_count = 0;
1949  for (i = 0; i < package_count; i++)
1950  mxf_write_package(s, &packages[i]);
1952  return 0;
1953 }
1954 
1955 static unsigned klv_fill_size(uint64_t size)
1956 {
1957  unsigned pad = KAG_SIZE - (size & (KAG_SIZE-1));
1958  if (pad < 20) // smallest fill item possible
1959  return pad + KAG_SIZE;
1960  else
1961  return pad & (KAG_SIZE-1);
1962 }
1963 
1965 {
1966  MXFContext *mxf = s->priv_data;
1967  AVIOContext *pb = s->pb;
1968  int i, j, temporal_reordering = 0;
1969  int key_index = mxf->last_key_index;
1970  int prev_non_b_picture = 0;
1971  int audio_frame_size = 0;
1972  int64_t pos;
1973 
1974  av_log(s, AV_LOG_DEBUG, "edit units count %d\n", mxf->edit_units_count);
1975 
1976  if (!mxf->edit_units_count && !mxf->edit_unit_byte_count)
1977  return;
1978 
1980 
1981  klv_encode_ber4_length(pb, 0);
1982  pos = avio_tell(pb);
1983 
1984  // instance id
1985  mxf_write_local_tag(s, 16, 0x3C0A);
1987 
1988  // index edit rate
1989  mxf_write_local_tag(s, 8, 0x3F0B);
1990  avio_wb32(pb, mxf->time_base.den);
1991  avio_wb32(pb, mxf->time_base.num);
1992 
1993  // index start position
1994  mxf_write_local_tag(s, 8, 0x3F0C);
1996 
1997  // index duration
1998  mxf_write_local_tag(s, 8, 0x3F0D);
1999  if (mxf->edit_unit_byte_count)
2000  avio_wb64(pb, 0); // index table covers whole container
2001  else
2002  avio_wb64(pb, mxf->edit_units_count);
2003 
2004  // edit unit byte count
2005  mxf_write_local_tag(s, 4, 0x3F05);
2006  avio_wb32(pb, mxf->edit_unit_byte_count);
2007 
2008  // index sid
2009  mxf_write_local_tag(s, 4, 0x3F06);
2010  avio_wb32(pb, 2);
2011 
2012  // body sid
2013  mxf_write_local_tag(s, 4, 0x3F07);
2014  avio_wb32(pb, 1);
2015 
2016  // real slice count - 1
2017  mxf_write_local_tag(s, 1, 0x3F08);
2018  avio_w8(pb, !mxf->edit_unit_byte_count); // only one slice for CBR
2019 
2020  // delta entry array
2021  mxf_write_local_tag(s, 8 + (s->nb_streams+1)*6, 0x3F09);
2022  avio_wb32(pb, s->nb_streams+1); // num of entries
2023  avio_wb32(pb, 6); // size of one entry
2024  // write system item delta entry
2025  avio_w8(pb, 0);
2026  avio_w8(pb, 0); // slice entry
2027  avio_wb32(pb, 0); // element delta
2028  // write each stream delta entry
2029  for (i = 0; i < s->nb_streams; i++) {
2030  AVStream *st = s->streams[i];
2031  MXFStreamContext *sc = st->priv_data;
2032  avio_w8(pb, sc->temporal_reordering);
2033  if (sc->temporal_reordering)
2034  temporal_reordering = 1;
2035  if (mxf->edit_unit_byte_count) {
2036  avio_w8(pb, 0); // slice number
2037  avio_wb32(pb, sc->slice_offset);
2038  } else if (i == 0) { // video track
2039  avio_w8(pb, 0); // slice number
2040  avio_wb32(pb, KAG_SIZE); // system item size including klv fill
2041  } else { // audio or data track
2042  if (!audio_frame_size) {
2043  audio_frame_size = sc->frame_size;
2044  audio_frame_size += klv_fill_size(audio_frame_size);
2045  }
2046  avio_w8(pb, 1);
2047  avio_wb32(pb, (i-1)*audio_frame_size); // element delta
2048  }
2049  }
2050 
2051  if (!mxf->edit_unit_byte_count) {
2052  MXFStreamContext *sc = s->streams[0]->priv_data;
2053  mxf_write_local_tag(s, 8 + mxf->edit_units_count*15, 0x3F0A);
2054  avio_wb32(pb, mxf->edit_units_count); // num of entries
2055  avio_wb32(pb, 15); // size of one entry
2056 
2057  for (i = 0; i < mxf->edit_units_count; i++) {
2058  int temporal_offset = 0;
2059 
2060  if (!(mxf->index_entries[i].flags & 0x33)) { // I-frame
2061  sc->max_gop = FFMAX(sc->max_gop, i - mxf->last_key_index);
2062  mxf->last_key_index = key_index;
2063  key_index = i;
2064  }
2065 
2066  if (temporal_reordering) {
2067  int pic_num_in_gop = i - key_index;
2068  if (pic_num_in_gop != mxf->index_entries[i].temporal_ref) {
2069  for (j = key_index; j < mxf->edit_units_count; j++) {
2070  if (pic_num_in_gop == mxf->index_entries[j].temporal_ref)
2071  break;
2072  }
2073  if (j == mxf->edit_units_count)
2074  av_log(s, AV_LOG_WARNING, "missing frames\n");
2075  temporal_offset = j - key_index - pic_num_in_gop;
2076  }
2077  }
2078  avio_w8(pb, temporal_offset);
2079 
2080  if ((mxf->index_entries[i].flags & 0x30) == 0x30) { // back and forward prediction
2081  sc->b_picture_count = FFMAX(sc->b_picture_count, i - prev_non_b_picture);
2082  avio_w8(pb, mxf->last_key_index - i);
2083  } else {
2084  avio_w8(pb, key_index - i); // key frame offset
2085  if ((mxf->index_entries[i].flags & 0x20) == 0x20) // only forward
2086  mxf->last_key_index = key_index;
2087  prev_non_b_picture = i;
2088  }
2089 
2090  if (!(mxf->index_entries[i].flags & 0x33) && // I-frame
2091  mxf->index_entries[i].flags & 0x40 && !temporal_offset)
2092  mxf->index_entries[i].flags |= 0x80; // random access
2093  avio_w8(pb, mxf->index_entries[i].flags);
2094  // stream offset
2095  avio_wb64(pb, mxf->index_entries[i].offset);
2096  if (s->nb_streams > 1)
2098  else
2099  avio_wb32(pb, 0);
2100  }
2101 
2102  mxf->last_key_index = key_index - mxf->edit_units_count;
2104  mxf->edit_units_count = 0;
2105  }
2106 
2107  mxf_update_klv_size(pb, pos);
2108 }
2109 
2111 {
2112  unsigned pad = klv_fill_size(avio_tell(s->pb));
2113  if (pad) {
2114  avio_write(s->pb, klv_fill_key, 16);
2115  pad -= 16 + 4;
2116  klv_encode_ber4_length(s->pb, pad);
2117  ffio_fill(s->pb, 0, pad);
2118  av_assert1(!(avio_tell(s->pb) & (KAG_SIZE-1)));
2119  }
2120 }
2121 
2122 static int mxf_write_partition(AVFormatContext *s, int bodysid,
2123  int indexsid,
2124  const uint8_t *key, int write_metadata)
2125 {
2126  MXFContext *mxf = s->priv_data;
2127  AVIOContext *pb = s->pb;
2128  int64_t header_byte_count_offset;
2129  unsigned index_byte_count = 0;
2130  uint64_t partition_offset = avio_tell(pb);
2131  int err;
2132 
2133  if (!mxf->edit_unit_byte_count && mxf->edit_units_count)
2134  index_byte_count = 85 + 12+(s->nb_streams+1)*6 +
2135  12+mxf->edit_units_count*15;
2136  else if (mxf->edit_unit_byte_count && indexsid)
2137  index_byte_count = 80;
2138 
2139  if (index_byte_count) {
2140  index_byte_count += 16 + 4; // add encoded ber4 length
2141  index_byte_count += klv_fill_size(index_byte_count);
2142  }
2143 
2144  if (key && !memcmp(key, body_partition_key, 16)) {
2146  sizeof(*mxf->body_partition_offset))) < 0) {
2147  mxf->body_partitions_count = 0;
2148  return err;
2149  }
2150  mxf->body_partition_offset[mxf->body_partitions_count++] = partition_offset;
2151  }
2152 
2153  // write klv
2154  if (key)
2155  avio_write(pb, key, 16);
2156  else
2157  avio_write(pb, body_partition_key, 16);
2158 
2160 
2161  // write partition value
2162  avio_wb16(pb, 1); // majorVersion
2163  avio_wb16(pb, 3); // minorVersion
2164  avio_wb32(pb, KAG_SIZE); // KAGSize
2165 
2166  avio_wb64(pb, partition_offset); // ThisPartition
2167 
2168  if (key && !memcmp(key, body_partition_key, 16) && mxf->body_partitions_count > 1)
2169  avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-2]); // PreviousPartition
2170  else if (key && !memcmp(key, footer_partition_key, 16) && mxf->body_partitions_count)
2171  avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-1]); // PreviousPartition
2172  else
2173  avio_wb64(pb, 0);
2174 
2175  avio_wb64(pb, mxf->footer_partition_offset); // footerPartition
2176 
2177  // set offset
2178  header_byte_count_offset = avio_tell(pb);
2179  avio_wb64(pb, 0); // headerByteCount, update later
2180 
2181  // indexTable
2182  avio_wb64(pb, index_byte_count); // indexByteCount
2183  avio_wb32(pb, index_byte_count ? indexsid : 0); // indexSID
2184 
2185  // BodyOffset
2186  if (bodysid && mxf->edit_units_count && mxf->body_partitions_count && !IS_OPATOM(s))
2187  avio_wb64(pb, mxf->body_offset);
2188  else
2189  avio_wb64(pb, 0);
2190 
2191  avio_wb32(pb, bodysid); // bodySID
2192 
2193  // operational pattern
2194  if (IS_OPATOM(s))
2195  avio_write(pb, opatom_ul, 16);
2196  else
2197  avio_write(pb, op1a_ul, 16);
2198 
2199  // essence container
2201 
2202  if (write_metadata) {
2203  // mark the start of the headermetadata and calculate metadata size
2204  int64_t pos, start;
2205  unsigned header_byte_count;
2206 
2208  start = avio_tell(s->pb);
2212  pos = avio_tell(s->pb);
2213  header_byte_count = pos - start + klv_fill_size(pos);
2214 
2215  // update header_byte_count
2216  avio_seek(pb, header_byte_count_offset, SEEK_SET);
2217  avio_wb64(pb, header_byte_count);
2218  avio_seek(pb, pos, SEEK_SET);
2219  }
2220 
2221  if(key)
2223 
2224  return 0;
2225 }
2226 
2227 static const struct {
2228  int profile;
2230 } mxf_prores_codec_uls[] = {
2231  { AV_PROFILE_PRORES_PROXY, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x01,0x00 } },
2232  { AV_PROFILE_PRORES_LT, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x02,0x00 } },
2233  { AV_PROFILE_PRORES_STANDARD, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x03,0x00 } },
2234  { AV_PROFILE_PRORES_HQ, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x04,0x00 } },
2235  { AV_PROFILE_PRORES_4444, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x05,0x00 } },
2236  { AV_PROFILE_PRORES_XQ, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x06,0x00 } },
2237 };
2238 
2240 {
2241  MXFContext *mxf = s->priv_data;
2242  MXFStreamContext *sc = st->priv_data;
2243  int i, profile;
2244 
2245  if (mxf->header_written)
2246  return 1;
2247 
2248  profile = st->codecpar->profile;
2249  for (i = 0; i < FF_ARRAY_ELEMS(mxf_prores_codec_uls); i++) {
2251  sc->codec_ul = &mxf_prores_codec_uls[i].codec_ul;
2252  break;
2253  }
2254  }
2256  return 0;
2257 
2258  sc->frame_size = pkt->size;
2259 
2260  return 1;
2261 }
2262 
2263 static const struct {
2264  uint16_t cid;
2265  uint8_t interlaced;
2266  UID codec_ul;
2267 } mxf_dnxhd_codec_uls[] = {
2268  { 1235, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x01,0x00,0x00 } }, // 1080p 10bit HIGH
2269  { 1237, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x03,0x00,0x00 } }, // 1080p 8bit MED
2270  { 1238, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x04,0x00,0x00 } }, // 1080p 8bit HIGH
2271  { 1241, 1, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x07,0x00,0x00 } }, // 1080i 10bit HIGH
2272  { 1242, 1, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x08,0x00,0x00 } }, // 1080i 8bit MED
2273  { 1243, 1, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x09,0x00,0x00 } }, // 1080i 8bit HIGH
2274  { 1244, 1, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x0a,0x00,0x00 } }, // 1080i 8bit TR
2275  { 1250, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x10,0x00,0x00 } }, // 720p 10bit
2276  { 1251, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x11,0x00,0x00 } }, // 720p 8bit HIGH
2277  { 1252, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x12,0x00,0x00 } }, // 720p 8bit MED
2278  { 1253, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x13,0x00,0x00 } }, // 720p 8bit LOW
2279  { 1256, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x16,0x00,0x00 } }, // 1080p 10bit 444
2280  { 1258, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x18,0x00,0x00 } }, // 720p 8bit TR
2281  { 1259, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x19,0x00,0x00 } }, // 1080p 8bit TR
2282  { 1260, 1, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x1a,0x00,0x00 } }, // 1080i 8bit TR MBAFF
2283  { 1270, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x24,0x00,0x00 } }, // DNXHR 444
2284  { 1271, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x25,0x00,0x00 } }, // DNXHR HQX
2285  { 1272, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x26,0x00,0x00 } }, // DNXHR HQ
2286  { 1273, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x27,0x00,0x00 } }, // DNXHR SQ
2287  { 1274, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x28,0x00,0x00 } }, // DNXHR LB
2288 };
2289 
2291 {
2292  MXFContext *mxf = s->priv_data;
2293  MXFStreamContext *sc = st->priv_data;
2294  int i, cid;
2295 
2296  if (mxf->header_written)
2297  return 1;
2298 
2299  if (pkt->size < 43)
2300  return 0;
2301 
2302  cid = AV_RB32(pkt->data + 0x28);
2303  for (i = 0; i < FF_ARRAY_ELEMS(mxf_dnxhd_codec_uls); i++) {
2304  if (cid == mxf_dnxhd_codec_uls[i].cid) {
2305  sc->codec_ul = &mxf_dnxhd_codec_uls[i].codec_ul;
2306  sc->interlaced = mxf_dnxhd_codec_uls[i].interlaced;
2307  break;
2308  }
2309  }
2311  return 0;
2312 
2313  sc->component_depth = 0;
2314  switch (pkt->data[0x21] >> 5) {
2315  case 1: sc->component_depth = 8; break;
2316  case 2: sc->component_depth = 10; break;
2317  case 3: sc->component_depth = 12; break;
2318  }
2319  if (!sc->component_depth)
2320  return 0;
2321 
2322  if (cid >= 1270) { // RI raster
2324  st->codecpar->width, st->codecpar->height,
2325  INT_MAX);
2326  } else {
2327  sc->aspect_ratio = (AVRational){ 16, 9 };
2328  }
2329 
2330  sc->frame_size = pkt->size;
2331 
2332  return 1;
2333 }
2334 
2335 static const struct {
2337  const UID codec_ul;
2338 } mxf_dv_uls[] = {
2339  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x01,0x01 }, // IEC DV25 525/60
2340  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x01,0x01,0x00 } },
2341  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x02,0x01 }, // IEC DV25 626/50
2342  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x01,0x02,0x00 } },
2343  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x40,0x01 }, // DV25 525/60
2344  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x01,0x00 }, },
2345  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, // DV25 625/50
2346  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x02,0x00 }, },
2347  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x50,0x01 }, // DV50 525/60
2348  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x03,0x00 }, },
2349  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x51,0x01 }, // DV50 625/50
2350  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x04,0x00 }, },
2351  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x60,0x01 }, // DV100 1080/60
2352  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x05,0x00 }, },
2353  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x61,0x01 }, // DV100 1080/50
2354  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x06,0x00 }, },
2355  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x62,0x01 }, // DV100 720/60
2356  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x07,0x00 }, },
2357  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x63,0x01 }, // DV100 720/50
2358  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x08,0x00 }, },
2359 };
2360 
2362 {
2363  MXFContext *mxf = s->priv_data;
2364  MXFStreamContext *sc = st->priv_data;
2365  const uint8_t *vs_pack, *vsc_pack;
2366  int apt, ul_index, stype, pal;
2367 
2368  if (mxf->header_written)
2369  return 1;
2370 
2371  // Check for minimal frame size
2372  if (pkt->size < 120000)
2373  return -1;
2374 
2375  apt = pkt->data[4] & 0x7;
2376  vs_pack = pkt->data + 80*5 + 48;
2377  vsc_pack = pkt->data + 80*5 + 53;
2378  stype = vs_pack[3] & 0x1f;
2379  pal = (vs_pack[3] >> 5) & 0x1;
2380 
2381  if ((vsc_pack[2] & 0x07) == 0x02) {
2382  sc->aspect_ratio = (AVRational){ 16, 9 };
2383  } else {
2384  sc->aspect_ratio = (AVRational){ 4, 3 };
2385  }
2386 
2387  sc->interlaced = (vsc_pack[3] >> 4) & 0x01;
2388  // TODO: fix dv encoder to set proper FF/FS value in VSC pack
2389  // and set field dominance accordingly
2390  // av_log(s, AV_LOG_DEBUG, "DV vsc pack ff/ss = %x\n", vsc_pack[2] >> 6);
2391 
2392  switch (stype) {
2393  case 0x18: // DV100 720p
2394  ul_index = 8+pal;
2395  if (sc->interlaced) {
2396  av_log(s, AV_LOG_ERROR, "source marked as interlaced but codec profile is progressive\n");
2397  sc->interlaced = 0;
2398  }
2399  break;
2400  case 0x14: // DV100 1080i
2401  ul_index = 6+pal;
2402  break;
2403  case 0x04: // DV50
2404  ul_index = 4+pal;
2405  break;
2406  default: // DV25
2407  if (!apt) { // IEC
2408  ul_index = 0+pal;
2409  } else {
2410  ul_index = 2+pal;
2411  }
2412  }
2413 
2414  sc->container_ul = &mxf_dv_uls[ul_index].container_ul;
2415  sc->codec_ul = &mxf_dv_uls[ul_index].codec_ul;
2416 
2417  sc->frame_size = pkt->size;
2418 
2419  return 1;
2420 }
2421 
2422 static const struct {
2425  uint8_t profile;
2426  uint8_t interlaced;
2427  int8_t intra_only; // 1 or 0 when there are separate UIDs for Long GOP and Intra, -1 when Intra/LGOP detection can be ignored
2428 } mxf_h264_codec_uls[] = {
2429  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x11,0x01 }, 0, 66, 0, -1 }, // AVC Baseline
2430  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x20,0x01 }, 0, 77, 0, -1 }, // AVC Main
2431  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x30,0x01 }, 0, 88, 0, -1 }, // AVC Extended
2432  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x40,0x01 }, 0, 100, 0, -1 }, // AVC High
2433  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x50,0x01 }, 0, 110, 0, 0 }, // AVC High 10
2434  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x60,0x01 }, 0, 122, 0, 0 }, // AVC High 422
2435  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x70,0x01 }, 0, 244, 0, 0 }, // AVC High 444
2436  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x20,0x01 }, 0, 110, 0, 1 }, // AVC High 10 Intra
2437  {{ 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
2438  {{ 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
2439  {{ 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
2440  {{ 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
2441  {{ 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
2442  {{ 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
2443  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x30,0x01 }, 0, 122, 0, 1 }, // AVC High 422 Intra
2444  {{ 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
2445  {{ 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
2446  {{ 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
2447  {{ 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
2448  {{ 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
2449  {{ 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
2450  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x01,0x32,0x40,0x01 }, 0, 244, 0, 1 }, // AVC High 444 Intra
2451  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x01,0x32,0x50,0x01 }, 0, 44, 0, -1 }, // AVC CAVLC 444
2452 };
2453 
2455  AVPacket *pkt, MXFIndexEntry *e)
2456 {
2457  MXFContext *mxf = s->priv_data;
2458  MXFStreamContext *sc = st->priv_data;
2459  H264SPS seq, *const sps = &seq;
2460  GetBitContext gb;
2461  const uint8_t *buf = pkt->data;
2462  const uint8_t *buf_end = pkt->data + pkt->size;
2463  const uint8_t *nal_end;
2464  const UID *codec_ul = NULL;
2465  uint32_t state = -1;
2466  int extra_size = 512; // support AVC Intra files without SPS/PPS header
2467  int i, frame_size, slice_type, has_sps = 0, intra_only = 0, ret;
2468 
2469  for (;;) {
2470  buf = avpriv_find_start_code(buf, buf_end, &state);
2471  if (buf >= buf_end)
2472  break;
2473 
2474  switch (state & 0x1f) {
2475  case H264_NAL_SPS:
2476  e->flags |= 0x40;
2477 
2478  if (mxf->header_written)
2479  break;
2480 
2481  nal_end = ff_nal_find_startcode(buf, buf_end);
2482  ret = ff_avc_decode_sps(sps, buf, nal_end - buf);
2483  if (ret < 0) {
2484  av_log(s, AV_LOG_ERROR, "error parsing sps\n");
2485  return 0;
2486  }
2487  has_sps = 1;
2488 
2489  sc->aspect_ratio.num = st->codecpar->width * sps->sar.num;
2490  sc->aspect_ratio.den = st->codecpar->height * sps->sar.den;
2492  sc->aspect_ratio.num, sc->aspect_ratio.den, 1024*1024);
2493  intra_only = (sps->constraint_set_flags >> 3) & 1;
2494  sc->interlaced = !sps->frame_mbs_only_flag;
2495  sc->component_depth = sps->bit_depth_luma;
2496 
2497  buf = nal_end;
2498  break;
2499  case H264_NAL_PPS:
2500  if (e->flags & 0x40) { // sequence header present
2501  e->flags |= 0x80; // random access
2502  extra_size = 0;
2503  }
2504  break;
2505  case H264_NAL_IDR_SLICE:
2506  e->flags |= 0x04; // IDR Picture
2507  buf = buf_end;
2508  break;
2509  case H264_NAL_SLICE:
2510  init_get_bits8(&gb, buf, buf_end - buf);
2511  get_ue_golomb_long(&gb); // skip first_mb_in_slice
2512  slice_type = get_ue_golomb_31(&gb);
2513  switch (slice_type % 5) {
2514  case 0:
2515  e->flags |= 0x20; // P Picture
2516  e->flags |= 0x06; // P Picture
2517  break;
2518  case 1:
2519  e->flags |= 0x30; // B Picture
2520  e->flags |= 0x03; // non-referenced B Picture
2521  break;
2522  }
2523  buf = buf_end;
2524  break;
2525  default:
2526  break;
2527  }
2528  }
2529 
2530  if (mxf->header_written)
2531  return 1;
2532 
2533  if (!has_sps)
2534  sc->interlaced = st->codecpar->field_order != AV_FIELD_PROGRESSIVE ? 1 : 0;
2535  frame_size = pkt->size + extra_size;
2536 
2537  for (i = 0; i < FF_ARRAY_ELEMS(mxf_h264_codec_uls); i++) {
2538  if (frame_size == mxf_h264_codec_uls[i].frame_size && sc->interlaced == mxf_h264_codec_uls[i].interlaced) {
2539  codec_ul = &mxf_h264_codec_uls[i].uid;
2540  sc->component_depth = 10; // AVC Intra is always 10 Bit
2541  sc->aspect_ratio = (AVRational){ 16, 9 }; // 16:9 is mandatory for broadcast HD
2542  st->codecpar->profile = mxf_h264_codec_uls[i].profile;
2543  sc->avc_intra = 1;
2544  mxf->cbr_index = 1;
2545  sc->frame_size = pkt->size;
2546  if (sc->interlaced)
2547  sc->field_dominance = 1; // top field first is mandatory for AVC Intra
2548  break;
2549  } else if (has_sps && mxf_h264_codec_uls[i].frame_size == 0 &&
2550  mxf_h264_codec_uls[i].profile == sps->profile_idc &&
2551  (mxf_h264_codec_uls[i].intra_only < 0 ||
2552  mxf_h264_codec_uls[i].intra_only == intra_only)) {
2553  codec_ul = &mxf_h264_codec_uls[i].uid;
2554  st->codecpar->profile = sps->profile_idc;
2555  st->codecpar->level = sps->level_idc;
2556  // continue to check for avc intra
2557  }
2558  }
2559 
2560  if (!codec_ul) {
2561  av_log(s, AV_LOG_ERROR, "h264 profile not supported\n");
2562  return 0;
2563  }
2564  sc->codec_ul = codec_ul;
2565 
2566  return 1;
2567 }
2568 
2569 static inline int get_ffv1_unsigned_symbol(RangeCoder *c, uint8_t *state) {
2570  if(get_rac(c, state+0))
2571  return 0;
2572  else{
2573  int i, e;
2574  unsigned a;
2575  e= 0;
2576  while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
2577  e++;
2578  if (e > 31)
2579  return AVERROR_INVALIDDATA;
2580  }
2581 
2582  a= 1;
2583  for(i=e-1; i>=0; i--){
2584  a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
2585  }
2586 
2587  return a;
2588  }
2589 }
2590 #define FFV1_CONTEXT_SIZE 32
2592 {
2593  MXFContext *mxf = s->priv_data;
2594  MXFStreamContext *sc = st->priv_data;
2595  uint8_t state[FFV1_CONTEXT_SIZE];
2596  RangeCoder c;
2597  unsigned v;
2598 
2599  sc->frame_size = pkt->size;
2600 
2601  if (mxf->header_written)
2602  return 1;
2603 
2604  memset(state, 128, sizeof(state));
2605  if (st->codecpar->extradata) {
2607  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
2609  av_assert0(v >= 2);
2610  if (v > 4) {
2611  av_log(s, AV_LOG_ERROR, "unsupported ffv1 version %d\n", v);
2612  return 0;
2613  }
2615  } else {
2616  uint8_t keystate = 128;
2618  ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);
2619  get_rac(&c, &keystate); // keyframe
2621  av_assert0(v < 2);
2622  }
2623  sc->codec_ul = &mxf_ffv1_codec_uls[v];
2624 
2626  sc->interlaced = 1;
2628  }
2632  sc->aspect_ratio.num, sc->aspect_ratio.den, INT_MAX);
2633 
2634  return 1;
2635 }
2636 
2638 {
2639  MXFContext *mxf = s->priv_data;
2640  MXFStreamContext *sc = st->priv_data;
2641  int component_count = av_pix_fmt_count_planes(st->codecpar->format);
2642  GetByteContext g;
2643  uint32_t j2k_ncomponents;
2644 
2645  if (mxf->header_written)
2646  return 1;
2647 
2649 
2650  while (bytestream2_get_bytes_left(&g) >= 3 && bytestream2_peek_be16(&g) != JPEG2000_SOC)
2651  bytestream2_skip(&g, 1);
2652 
2653  if (bytestream2_get_be16u(&g) != JPEG2000_SOC) {
2654  av_log(s, AV_LOG_ERROR, "Mandatory SOC marker is not present\n");
2655  return AVERROR_INVALIDDATA;
2656  }
2657 
2658  /* Extract usefull size information from the SIZ marker */
2659  if (bytestream2_get_be16u(&g) != JPEG2000_SIZ) {
2660  av_log(s, AV_LOG_ERROR, "Mandatory SIZ marker is not present\n");
2661  return AVERROR_INVALIDDATA;
2662  }
2663  bytestream2_skip(&g, 2); // Skip Lsiz
2664  sc->j2k_info.j2k_cap = bytestream2_get_be16u(&g);
2665  sc->j2k_info.j2k_xsiz = bytestream2_get_be32u(&g);
2666  sc->j2k_info.j2k_ysiz = bytestream2_get_be32u(&g);
2667  sc->j2k_info.j2k_x0siz = bytestream2_get_be32u(&g);
2668  sc->j2k_info.j2k_y0siz = bytestream2_get_be32u(&g);
2669  sc->j2k_info.j2k_xtsiz = bytestream2_get_be32u(&g);
2670  sc->j2k_info.j2k_ytsiz = bytestream2_get_be32u(&g);
2671  sc->j2k_info.j2k_xt0siz = bytestream2_get_be32u(&g);
2672  sc->j2k_info.j2k_yt0siz = bytestream2_get_be32u(&g);
2673  j2k_ncomponents = bytestream2_get_be16u(&g);
2674  if (j2k_ncomponents != component_count) {
2675  av_log(s, AV_LOG_ERROR, "Incoherence about components image number.\n");
2676  return AVERROR_INVALIDDATA;
2677  }
2678  bytestream2_get_bufferu(&g, sc->j2k_info.j2k_comp_desc, 3 * j2k_ncomponents);
2679 
2680  sc->frame_size = pkt->size;
2681 
2682  return 1;
2683 }
2684 
2685 static const UID mxf_mpeg2_codec_uls[] = {
2686  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x10,0x00 }, // MP-ML I-Frame
2687  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x11,0x00 }, // MP-ML Long GOP
2688  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x02,0x00 }, // 422P-ML I-Frame
2689  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x03,0x00 }, // 422P-ML Long GOP
2690  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x02,0x00 }, // MP-HL I-Frame
2691  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x03,0x00 }, // MP-HL Long GOP
2692  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x02,0x00 }, // 422P-HL I-Frame
2693  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x03,0x00 }, // 422P-HL Long GOP
2694  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x05,0x02,0x00 }, // MP@H-14 I-Frame
2695  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x05,0x03,0x00 }, // MP@H-14 Long GOP
2696 };
2697 
2699 {
2700  int long_gop = 1;
2701 
2702  if (par->profile == 4) { // Main
2703  if (par->level == 8) // Main
2704  return &mxf_mpeg2_codec_uls[0+long_gop];
2705  else if (par->level == 4) // High
2706  return &mxf_mpeg2_codec_uls[4+long_gop];
2707  else if (par->level == 6) // High 14
2708  return &mxf_mpeg2_codec_uls[8+long_gop];
2709  } else if (par->profile == 0) { // 422
2710  if (par->level == 5) // Main
2711  return &mxf_mpeg2_codec_uls[2+long_gop];
2712  else if (par->level == 2) // High
2713  return &mxf_mpeg2_codec_uls[6+long_gop];
2714  }
2715  return NULL;
2716 }
2717 
2719  AVPacket *pkt, MXFIndexEntry *e)
2720 {
2721  MXFStreamContext *sc = st->priv_data;
2722  uint32_t c = -1;
2723  int i;
2724 
2725  for(i = 0; i < pkt->size - 4; i++) {
2726  c = (c<<8) + pkt->data[i];
2727  if (c == 0x1b5) {
2728  if ((pkt->data[i+1] & 0xf0) == 0x10) { // seq ext
2729  st->codecpar->profile = pkt->data[i+1] & 0x07;
2730  st->codecpar->level = pkt->data[i+2] >> 4;
2731  sc->low_delay = pkt->data[i+6] >> 7;
2732  } else if (i + 5 < pkt->size && (pkt->data[i+1] & 0xf0) == 0x80) { // pict coding ext
2733  sc->interlaced = !(pkt->data[i+5] & 0x80); // progressive frame
2734  if (sc->interlaced)
2735  sc->field_dominance = 1 + !(pkt->data[i+4] & 0x80); // top field first
2736  break;
2737  }
2738  } else if (c == 0x1b8) { // gop
2739  if (pkt->data[i+4]>>6 & 0x01) { // closed
2740  if (sc->seq_closed_gop == -1)
2741  sc->seq_closed_gop = 1;
2742  sc->closed_gop = 1;
2743  if (e->flags & 0x40) // sequence header present
2744  e->flags |= 0x80; // random access
2745  } else {
2746  sc->seq_closed_gop = 0;
2747  sc->closed_gop = 0;
2748  }
2749  } else if (c == 0x1b3) { // seq
2750  e->flags |= 0x40;
2751  switch ((pkt->data[i+4]>>4) & 0xf) {
2752  case 2: sc->aspect_ratio = (AVRational){ 4, 3}; break;
2753  case 3: sc->aspect_ratio = (AVRational){ 16, 9}; break;
2754  case 4: sc->aspect_ratio = (AVRational){221,100}; break;
2755  default:
2757  st->codecpar->width, st->codecpar->height, 1024*1024);
2758  }
2759  } else if (c == 0x100) { // pic
2760  int pict_type = (pkt->data[i+2]>>3) & 0x07;
2761  e->temporal_ref = (pkt->data[i+1]<<2) | (pkt->data[i+2]>>6);
2762  if (pict_type == 2) { // P-frame
2763  e->flags |= 0x22;
2764  sc->closed_gop = 0; // reset closed GOP, don't matter anymore
2765  } else if (pict_type == 3) { // B-frame
2766  if (sc->closed_gop)
2767  e->flags |= 0x13; // only backward prediction
2768  else
2769  e->flags |= 0x33;
2770  sc->temporal_reordering = -1;
2771  } else if (!pict_type) {
2772  av_log(s, AV_LOG_ERROR, "error parsing mpeg2 frame\n");
2773  return 0;
2774  }
2775  }
2776  }
2777  if (!IS_D10(s)) {
2779  if (!codec_ul)
2780  return 0;
2781  sc->codec_ul = codec_ul;
2782  }
2783  return 1;
2784 }
2785 
2786 static uint64_t mxf_parse_timestamp(int64_t timestamp64)
2787 {
2788  time_t timestamp = timestamp64 / 1000000;
2789  struct tm tmbuf;
2790  struct tm *time = gmtime_r(&timestamp, &tmbuf);
2791  if (!time)
2792  return 0;
2793  return (uint64_t)(time->tm_year+1900) << 48 |
2794  (uint64_t)(time->tm_mon+1) << 40 |
2795  (uint64_t) time->tm_mday << 32 |
2796  time->tm_hour << 24 |
2797  time->tm_min << 16 |
2798  time->tm_sec << 8 |
2799  (timestamp64 % 1000000) / 4000;
2800 }
2801 
2803 {
2804  MXFContext *mxf = s->priv_data;
2805  uint32_t seed = av_get_random_seed();
2806  uint64_t umid = seed + 0x5294713400000000LL;
2807 
2808  AV_WB64(mxf->umid , umid);
2809  AV_WB64(mxf->umid+8, umid>>8);
2810 
2811  mxf->instance_number = seed & 0xFFFFFF;
2812 }
2813 
2815 {
2816  MXFContext *mxf = s->priv_data;
2817  AVDictionaryEntry *tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
2818 
2819  if (!ff_mxf_get_content_package_rate(tbc)) {
2820  if (s->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
2821  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);
2822  return AVERROR(EINVAL);
2823  } else {
2824  av_log(s, AV_LOG_WARNING, "Unofficial frame rate %d/%d.\n", tbc.den, tbc.num);
2825  }
2826  }
2827 
2828  mxf->timecode_base = (tbc.den + tbc.num/2) / tbc.num;
2829  if (!tcr)
2830  tcr = av_dict_get(st->metadata, "timecode", NULL, 0);
2831 
2832  if (tcr)
2833  return av_timecode_init_from_string(&mxf->tc, av_inv_q(tbc), tcr->value, s);
2834  else
2835  return av_timecode_init(&mxf->tc, av_inv_q(tbc), 0, 0, s);
2836 }
2837 
2839 {
2840  AVCodecParameters *par = st->codecpar;
2841  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(par->format);
2842 
2844  return par->chroma_location;
2845 
2846  if (pix_desc) {
2847  if (pix_desc->log2_chroma_h == 0) {
2848  return AVCHROMA_LOC_TOPLEFT;
2849  } else if (pix_desc->log2_chroma_w == 1 && pix_desc->log2_chroma_h == 1) {
2851  switch (par->codec_id) {
2852  case AV_CODEC_ID_MJPEG:
2854  }
2855  }
2857  switch (par->codec_id) {
2859  }
2860  }
2861  }
2862  }
2863 
2864  return AVCHROMA_LOC_UNSPECIFIED;
2865 }
2866 
2868 {
2869  MXFContext *mxf = s->priv_data;
2870  int i, ret;
2871  uint8_t present[FF_ARRAY_ELEMS(mxf_essence_container_uls)] = {0};
2872  int64_t timestamp = 0;
2873 
2874  if (IS_OPATOM(s) && s->nb_streams != 1) {
2875  av_log(s, AV_LOG_ERROR, "there must be exactly one stream for mxf opatom\n");
2876  return -1;
2877  }
2878 
2879  if (!av_dict_get(s->metadata, "comment_", NULL, AV_DICT_IGNORE_SUFFIX))
2880  mxf->store_user_comments = 0;
2881 
2882  for (i = 0; i < s->nb_streams; i++) {
2883  AVStream *st = s->streams[i];
2884  MXFStreamContext *sc = av_mallocz(sizeof(*sc));
2885  if (!sc)
2886  return AVERROR(ENOMEM);
2887  st->priv_data = sc;
2888  sc->index = -1;
2889 
2890  if (((i == 0) ^ (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)) && !IS_OPATOM(s)) {
2891  av_log(s, AV_LOG_ERROR, "there must be exactly one video stream and it must be the first one\n");
2892  return -1;
2893  }
2894 
2895  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2896  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(st->codecpar->format);
2897  AVRational tbc = (AVRational){ 0, 0 };
2898  if (st->avg_frame_rate.num > 0 && st->avg_frame_rate.den > 0)
2899  tbc = av_inv_q(st->avg_frame_rate);
2900  else if (st->r_frame_rate.num > 0 && st->r_frame_rate.den > 0)
2901  tbc = av_inv_q(st->r_frame_rate);
2902 
2903  // Default component depth to 8
2904  sc->component_depth = 8;
2905  sc->h_chroma_sub_sample = 2;
2906  sc->v_chroma_sub_sample = 2;
2907  sc->color_siting = 0xFF;
2908 
2911  av_make_q(st->codecpar->width, st->codecpar->height));
2912  }
2913 
2914  if (pix_desc) {
2915  sc->component_depth = pix_desc->comp[0].depth;
2916  sc->h_chroma_sub_sample = 1 << pix_desc->log2_chroma_w;
2917  sc->v_chroma_sub_sample = 1 << pix_desc->log2_chroma_h;
2918  }
2919  switch (choose_chroma_location(s, st)) {
2920  case AVCHROMA_LOC_TOPLEFT: sc->color_siting = 0; break;
2921  case AVCHROMA_LOC_LEFT: sc->color_siting = 6; break;
2922  case AVCHROMA_LOC_TOP: sc->color_siting = 1; break;
2923  case AVCHROMA_LOC_CENTER: sc->color_siting = 3; break;
2924  }
2925 
2927  mxf->time_base = tbc;
2928  avpriv_set_pts_info(st, 64, mxf->time_base.num, mxf->time_base.den);
2929  if((ret = mxf_init_timecode(s, st, tbc)) < 0)
2930  return ret;
2931 
2933  sc->seq_closed_gop = -1; // unknown yet
2934  }
2935 
2936  sc->video_bit_rate = st->codecpar->bit_rate;
2937 
2938  if (IS_D10(s) ||
2941  mxf->cbr_index = 1;
2942 
2943  if (IS_D10(s)) {
2944  int ntsc = mxf->time_base.den != 25;
2945  int ul_index;
2946 
2948  av_log(s, AV_LOG_ERROR, "error MXF D-10 only support MPEG-2 Video\n");
2949  return AVERROR(EINVAL);
2950  }
2951  if ((sc->video_bit_rate == 50000000) && (mxf->time_base.den == 25)) {
2952  ul_index = 0;
2953  } else if ((sc->video_bit_rate == 49999840 || sc->video_bit_rate == 50000000) && ntsc) {
2954  ul_index = 1;
2955  } else if (sc->video_bit_rate == 40000000) {
2956  ul_index = 2+ntsc;
2957  } else if (sc->video_bit_rate == 30000000) {
2958  ul_index = 4+ntsc;
2959  } else {
2960  av_log(s, AV_LOG_ERROR, "error MXF D-10 only support 30/40/50 mbit/s\n");
2961  return -1;
2962  }
2963 
2964  sc->codec_ul = &mxf_d10_codec_uls[ul_index];
2965  sc->container_ul = &mxf_d10_container_uls[ul_index];
2966  sc->index = INDEX_D10_VIDEO;
2967  sc->signal_standard = 1;
2968  sc->color_siting = 0;
2969  sc->frame_size = (int64_t)sc->video_bit_rate *
2970  mxf->time_base.num / (8*mxf->time_base.den);
2971  }
2972  if (mxf->signal_standard >= 0)
2973  sc->signal_standard = mxf->signal_standard;
2974  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2975  char bsf_arg[32];
2976  if (st->codecpar->sample_rate != 48000) {
2977  av_log(s, AV_LOG_ERROR, "only 48khz is implemented\n");
2978  return -1;
2979  }
2980  avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
2981  if (IS_D10(s)) {
2982  if (st->index != 1) {
2983  av_log(s, AV_LOG_ERROR, "MXF D-10 only support one audio track\n");
2984  return -1;
2985  }
2986  if (st->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE &&
2988  av_log(s, AV_LOG_ERROR, "MXF D-10 only support 16 or 24 bits le audio\n");
2989  }
2990  sc->index = INDEX_D10_AUDIO;
2991  sc->container_ul = ((MXFStreamContext*)s->streams[0]->priv_data)->container_ul;
2992  sc->frame_size = 4 + 8 * av_rescale_rnd(st->codecpar->sample_rate, mxf->time_base.num, mxf->time_base.den, AV_ROUND_UP) * 4;
2993  } else if (IS_OPATOM(s)) {
2994  AVRational tbc = av_inv_q(mxf->audio_edit_rate);
2995 
2996  if (st->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE &&
2998  av_log(s, AV_LOG_ERROR, "Only pcm_s16le and pcm_s24le audio codecs are implemented\n");
2999  return AVERROR_PATCHWELCOME;
3000  }
3001  if (st->codecpar->ch_layout.nb_channels != 1) {
3002  av_log(s, AV_LOG_ERROR, "MXF OPAtom only supports single channel audio\n");
3003  return AVERROR(EINVAL);
3004  }
3005 
3006  mxf->time_base = st->time_base;
3007  if((ret = mxf_init_timecode(s, st, tbc)) < 0)
3008  return ret;
3009 
3011  sc->index = INDEX_WAV;
3012  } else {
3013  mxf->slice_count = 1;
3017  }
3018  snprintf(bsf_arg, sizeof(bsf_arg), "r=%d/%d", mxf->tc.rate.num, mxf->tc.rate.den);
3019  ret = ff_stream_add_bitstream_filter(st, "pcm_rechunk", bsf_arg);
3020  if (ret < 0)
3021  return ret;
3022  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
3023  AVDictionaryEntry *e = av_dict_get(st->metadata, "data_type", NULL, 0);
3024  if (e && !strcmp(e->value, "vbi_vanc_smpte_436M")) {
3025  sc->index = INDEX_S436M;
3026  } else {
3027  av_log(s, AV_LOG_ERROR, "track %d: unsupported data type\n", i);
3028  return -1;
3029  }
3030  if (st->index != s->nb_streams - 1) {
3031  av_log(s, AV_LOG_ERROR, "data track must be placed last\n");
3032  return -1;
3033  }
3034  }
3035 
3036  if (sc->index == -1) {
3038  if (sc->index == -1) {
3039  av_log(s, AV_LOG_ERROR, "track %d: could not find essence container ul, "
3040  "codec not currently supported in container\n", i);
3041  return -1;
3042  }
3043  }
3044 
3045  if (!sc->codec_ul)
3047  if (!sc->container_ul)
3049 
3051  sc->track_essence_element_key[15] = present[sc->index];
3052  if (IS_OPATOM(s) && st->codecpar->codec_id == AV_CODEC_ID_DNXHD) {
3053  // clip-wrapping requires 0x0D per ST2019-4:2009 or 0x06 per previous version ST2019-4:2008
3054  // we choose to use 0x06 instead 0x0D to be compatible with AVID systems
3055  // and produce mxf files with the most relevant flavour for opatom
3056  sc->track_essence_element_key[14] = 0x06;
3057  }
3058  PRINT_KEY(s, "track essence element key", sc->track_essence_element_key);
3059 
3060  if (!present[sc->index])
3061  mxf->essence_container_count++;
3062  present[sc->index]++;
3063  }
3064 
3065  if (IS_D10(s) || IS_OPATOM(s)) {
3066  mxf->essence_container_count = 1;
3067  }
3068 
3069  if (!(s->flags & AVFMT_FLAG_BITEXACT))
3070  mxf_gen_umid(s);
3071 
3072  for (i = 0; i < s->nb_streams; i++) {
3073  MXFStreamContext *sc = s->streams[i]->priv_data;
3074  // update element count
3075  sc->track_essence_element_key[13] = present[sc->index];
3077  sc->order = (0x15 << 24) | AV_RB32(sc->track_essence_element_key+13);
3078  else
3079  sc->order = AV_RB32(sc->track_essence_element_key+12);
3080  }
3081 
3082  if (ff_parse_creation_time_metadata(s, &timestamp, 0) > 0)
3083  mxf->timestamp = mxf_parse_timestamp(timestamp);
3084  mxf->duration = -1;
3085 
3086  mxf->timecode_track = av_mallocz(sizeof(*mxf->timecode_track));
3087  if (!mxf->timecode_track)
3088  return AVERROR(ENOMEM);
3090  mxf->timecode_track->index = -1;
3091 
3092  return 0;
3093 }
3094 
3095 static const uint8_t system_metadata_pack_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04,0x01,0x01,0x00 };
3096 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 };
3097 
3099 {
3100  MXFContext *mxf = s->priv_data;
3101  AVIOContext *pb = s->pb;
3102  unsigned frame;
3103  uint32_t time_code;
3104  int i, system_item_bitmap = 0x58; // UL, user date/time stamp, picture present
3105 
3107 
3108  // write system metadata pack
3110  klv_encode_ber4_length(pb, 57);
3111 
3112  for (i = 0; i < s->nb_streams; i++) {
3113  if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
3114  system_item_bitmap |= 0x4;
3115  else if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
3116  system_item_bitmap |= 0x2;
3117  }
3118  avio_w8(pb, system_item_bitmap);
3119  avio_w8(pb, mxf->content_package_rate); // content package rate
3120  avio_w8(pb, 0x00); // content package type
3121  avio_wb16(pb, 0x00); // channel handle
3122  avio_wb16(pb, frame & 0xFFFF); // continuity count, supposed to overflow
3123  if (mxf->essence_container_count > 1)
3124  avio_write(pb, multiple_desc_ul, 16);
3125  else {
3126  MXFStreamContext *sc = s->streams[0]->priv_data;
3127  avio_write(pb, *sc->container_ul, 16);
3128  }
3129  avio_w8(pb, 0);
3130  avio_wb64(pb, 0);
3131  avio_wb64(pb, 0); // creation date/time stamp
3132 
3133  avio_w8(pb, 0x81); // SMPTE 12M time code
3134  time_code = av_timecode_get_smpte_from_framenum(&mxf->tc, frame);
3135  avio_wb32(pb, time_code);
3136  avio_wb32(pb, 0); // binary group data
3137  avio_wb64(pb, 0);
3138 
3139  // write system metadata package set
3141  klv_encode_ber4_length(pb, 35);
3142  avio_w8(pb, 0x83); // UMID
3143  avio_wb16(pb, 0x20);
3144  mxf_write_umid(s, 1);
3145 }
3146 
3148 {
3149  MXFContext *mxf = s->priv_data;
3150  AVIOContext *pb = s->pb;
3151  int frame_size = pkt->size / st->codecpar->block_align;
3152  const uint8_t *samples = pkt->data;
3153  const uint8_t *const end = pkt->data + pkt->size;
3154  int i;
3155 
3156  klv_encode_ber4_length(pb, 4 + frame_size*4*8);
3157 
3158  avio_w8(pb, (frame_size == 1920 ? 0 : (mxf->edit_units_count-1) % 5 + 1));
3159  avio_wl16(pb, frame_size);
3160  avio_w8(pb, (1 << st->codecpar->ch_layout.nb_channels)-1);
3161 
3162  while (samples < end) {
3163  for (i = 0; i < st->codecpar->ch_layout.nb_channels; i++) {
3164  uint32_t sample;
3165  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE) {
3166  sample = AV_RL24(samples)<< 4;
3167  samples += 3;
3168  } else {
3169  sample = AV_RL16(samples)<<12;
3170  samples += 2;
3171  }
3172  avio_wl32(pb, sample | i);
3173  }
3174  for (; i < 8; i++)
3175  avio_wl32(pb, i);
3176  }
3177 }
3178 
3180 {
3181  MXFContext *mxf = s->priv_data;
3182  AVIOContext *pb = s->pb;
3183  AVStream *st = s->streams[0];
3184  MXFStreamContext *sc = st->priv_data;
3185  const uint8_t *key = NULL;
3186 
3187  int err;
3188 
3189  if (!mxf->header_written)
3191 
3192  if ((err = mxf_write_partition(s, 1, 0, key, 0)) < 0)
3193  return err;
3197  return 0;
3198 }
3199 
3201 {
3202  MXFContext *mxf = s->priv_data;
3203  AVIOContext *pb = s->pb;
3204 
3205  int err;
3206 
3207  if (!mxf->header_written) {
3208  if ((err = mxf_write_partition(s, 0, 0, header_open_partition_key, 1)) < 0)
3209  return err;
3211 
3212  if ((err = mxf_write_opatom_body_partition(s)) < 0)
3213  return err;
3214  mxf->header_written = 1;
3215  }
3216 
3217  if (!mxf->edit_unit_byte_count) {
3219  mxf->index_entries[mxf->edit_units_count].flags = ie->flags;
3221  }
3222  mxf->edit_units_count++;
3223  avio_write(pb, pkt->data, pkt->size);
3224  mxf->body_offset += pkt->size;
3225 
3226  return 0;
3227 }
3228 
3230 {
3231  MXFContext *mxf = s->priv_data;
3232  int i;
3233 
3234  if (IS_OPATOM(s)) {
3235  MXFStreamContext *sc = s->streams[0]->priv_data;
3236  mxf->edit_unit_byte_count = sc->frame_size;
3237  return;
3238  }
3239 
3240  mxf->edit_unit_byte_count = KAG_SIZE; // system element
3241  for (i = 0; i < s->nb_streams; i++) {
3242  AVStream *st = s->streams[i];
3243  MXFStreamContext *sc = st->priv_data;
3245  mxf->edit_unit_byte_count += 16 + 4 + sc->frame_size;
3247  }
3248 }
3249 
3251 {
3252  MXFContext *mxf = s->priv_data;
3253  AVIOContext *pb = s->pb;
3254  AVStream *st = s->streams[pkt->stream_index];
3255  MXFStreamContext *sc = st->priv_data;
3256  MXFIndexEntry ie = {0};
3257  int err;
3258 
3259  if (!mxf->header_written && pkt->stream_index != 0 &&
3260  !IS_OPATOM(s)) {
3261  av_log(s, AV_LOG_ERROR, "Received non-video packet before "
3262  "header has been written\n");
3263  return AVERROR_INVALIDDATA;
3264  }
3265 
3266  if (!mxf->cbr_index && !mxf->edit_unit_byte_count && !(mxf->edit_units_count % EDIT_UNITS_PER_BODY)) {
3267  if ((err = av_reallocp_array(&mxf->index_entries, mxf->edit_units_count
3268  + EDIT_UNITS_PER_BODY, sizeof(*mxf->index_entries))) < 0) {
3269  mxf->edit_units_count = 0;
3270  av_log(s, AV_LOG_ERROR, "could not allocate index entries\n");
3271  return err;
3272  }
3273  }
3274 
3276  if (!mxf_parse_mpeg2_frame(s, st, pkt, &ie)) {
3277  av_log(s, AV_LOG_ERROR, "could not get mpeg2 profile and level\n");
3278  return -1;
3279  }
3280  } else if (st->codecpar->codec_id == AV_CODEC_ID_DNXHD) {
3281  if (!mxf_parse_dnxhd_frame(s, st, pkt)) {
3282  av_log(s, AV_LOG_ERROR, "could not get dnxhd profile\n");
3283  return -1;
3284  }
3285  } else if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
3286  if (!mxf_parse_prores_frame(s, st, pkt)) {
3287  av_log(s, AV_LOG_ERROR, "could not get prores profile\n");
3288  return -1;
3289  }
3290  } else if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO) {
3291  if (!mxf_parse_dv_frame(s, st, pkt)) {
3292  av_log(s, AV_LOG_ERROR, "could not get dv profile\n");
3293  return -1;
3294  }
3295  } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
3296  if (!mxf_parse_h264_frame(s, st, pkt, &ie)) {
3297  av_log(s, AV_LOG_ERROR, "could not get h264 profile\n");
3298  return -1;
3299  }
3300  } else if (st->codecpar->codec_id == AV_CODEC_ID_FFV1) {
3301  if (!mxf_parse_ffv1_frame(s, st, pkt)) {
3302  av_log(s, AV_LOG_ERROR, "could not get ffv1 version\n");
3303  return -1;
3304  }
3305  } else if (st->codecpar->codec_id == AV_CODEC_ID_JPEG2000) {
3306  if (!mxf_parse_jpeg2000_frame(s, st, pkt)) {
3307  av_log(s, AV_LOG_ERROR, "could not get jpeg2000 profile\n");
3308  return -1;
3309  }
3310  }
3311 
3312  if (mxf->cbr_index) {
3313  if (pkt->size != sc->frame_size && st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3314  av_log(s, AV_LOG_ERROR, "track %d: frame size does not match index unit size, %d != %d\n",
3315  st->index, pkt->size, sc->frame_size);
3316  return -1;
3317  }
3318  if (!mxf->header_written)
3320  }
3321 
3322  if (IS_OPATOM(s))
3323  return mxf_write_opatom_packet(s, pkt, &ie);
3324 
3325  if (!mxf->header_written) {
3326  if (mxf->edit_unit_byte_count) {
3327  if ((err = mxf_write_partition(s, 1, 2, header_open_partition_key, 1)) < 0)
3328  return err;
3331  } else {
3332  if ((err = mxf_write_partition(s, 0, 0, header_open_partition_key, 1)) < 0)
3333  return err;
3334  }
3335  mxf->header_written = 1;
3336  }
3337 
3338  if (st->index == 0) {
3339  if (!mxf->edit_unit_byte_count &&
3341  !(ie.flags & 0x33)) { // I-frame, GOP start
3343  if ((err = mxf_write_partition(s, 1, 2, body_partition_key, 0)) < 0)
3344  return err;
3347  }
3348 
3351 
3352  if (!mxf->edit_unit_byte_count) {
3354  mxf->index_entries[mxf->edit_units_count].flags = ie.flags;
3356  mxf->body_offset += KAG_SIZE; // size of system element
3357  }
3358  mxf->edit_units_count++;
3359  } else if (!mxf->edit_unit_byte_count && st->index == 1) {
3360  if (!mxf->edit_units_count) {
3361  av_log(s, AV_LOG_ERROR, "No packets in first stream\n");
3362  return AVERROR_PATCHWELCOME;
3363  }
3365  mxf->body_offset - mxf->index_entries[mxf->edit_units_count-1].offset;
3366  }
3367 
3369  avio_write(pb, sc->track_essence_element_key, 16); // write key
3370  if (IS_D10(s) && st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3372  } else {
3373  klv_encode_ber4_length(pb, pkt->size); // write length
3374  avio_write(pb, pkt->data, pkt->size);
3375  mxf->body_offset += 16+4+pkt->size + klv_fill_size(16+4+pkt->size);
3376  }
3377 
3378  return 0;
3379 }
3380 
3382 {
3383  MXFContext *mxf = s->priv_data;
3384  AVIOContext *pb = s->pb;
3385  uint64_t pos = avio_tell(pb);
3386  int i;
3387 
3389  klv_encode_ber_length(pb, 28 + 12LL*mxf->body_partitions_count);
3390 
3391  if (mxf->edit_unit_byte_count && !IS_OPATOM(s))
3392  avio_wb32(pb, 1); // BodySID of header partition
3393  else
3394  avio_wb32(pb, 0);
3395  avio_wb64(pb, 0); // offset of header partition
3396 
3397  for (i = 0; i < mxf->body_partitions_count; i++) {
3398  avio_wb32(pb, 1); // BodySID
3399  avio_wb64(pb, mxf->body_partition_offset[i]);
3400  }
3401 
3402  avio_wb32(pb, 0); // BodySID of footer partition
3404 
3405  avio_wb32(pb, avio_tell(pb) - pos + 4);
3406 }
3407 
3409 {
3410  MXFContext *mxf = s->priv_data;
3411  AVIOContext *pb = s->pb;
3412  int i, err;
3413 
3414  if (!mxf->header_written ||
3415  (IS_OPATOM(s) && !mxf->body_partition_offset)) {
3416  /* reason could be invalid options/not supported codec/out of memory */
3417  return AVERROR_UNKNOWN;
3418  }
3419 
3421 
3424  if (mxf->edit_unit_byte_count && !IS_OPATOM(s)) { // no need to repeat index
3425  if ((err = mxf_write_partition(s, 0, 0, footer_partition_key, 0)) < 0)
3426  return err;
3427  } else {
3428  if ((err = mxf_write_partition(s, 0, 2, footer_partition_key, 0)) < 0)
3429  return err;
3432  }
3433 
3436 
3437  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
3438  if (IS_OPATOM(s)) {
3439  /* rewrite body partition to update lengths */
3440  avio_seek(pb, mxf->body_partition_offset[0], SEEK_SET);
3441  if ((err = mxf_write_opatom_body_partition(s)) < 0)
3442  return err;
3443  }
3444 
3445  avio_seek(pb, 0, SEEK_SET);
3446  if (mxf->edit_unit_byte_count && !IS_OPATOM(s)) {
3447  if ((err = mxf_write_partition(s, 1, 2, header_closed_partition_key, 1)) < 0)
3448  return err;
3451  } else {
3452  if ((err = mxf_write_partition(s, 0, 0, header_closed_partition_key, 1)) < 0)
3453  return err;
3454  }
3455  // update footer partition offset
3456  for (i = 0; i < mxf->body_partitions_count; i++) {
3457  avio_seek(pb, mxf->body_partition_offset[i]+44, SEEK_SET);
3459  }
3460  }
3461 
3462  return 0;
3463 }
3464 
3466 {
3467  MXFContext *mxf = s->priv_data;
3468 
3469  av_freep(&mxf->index_entries);
3471  av_freep(&mxf->timecode_track);
3472 }
3473 
3475 {
3476  FFFormatContext *const si = ffformatcontext(s);
3477  int i, stream_count = 0;
3478 
3479  for (i = 0; i < s->nb_streams; i++)
3480  stream_count += !!ffstream(s->streams[i])->last_in_packet_buffer;
3481 
3482  if (stream_count && (s->nb_streams == stream_count || flush)) {
3483  PacketListEntry *pktl = si->packet_buffer.head;
3484  if (s->nb_streams != stream_count) {
3485  PacketListEntry *last = NULL;
3486  // find last packet in edit unit
3487  while (pktl) {
3488  if (!stream_count || pktl->pkt.stream_index == 0)
3489  break;
3490  // update last packet in packet buffer
3491  if (ffstream(s->streams[pktl->pkt.stream_index])->last_in_packet_buffer != pktl)
3492  ffstream(s->streams[pktl->pkt.stream_index])->last_in_packet_buffer = pktl;
3493  last = pktl;
3494  pktl = pktl->next;
3495  stream_count--;
3496  }
3497  // purge packet queue
3498  while (pktl) {
3499  PacketListEntry *next = pktl->next;
3500  av_packet_unref(&pktl->pkt);
3501  av_freep(&pktl);
3502  pktl = next;
3503  }
3504  if (last)
3505  last->next = NULL;
3506  else {
3507  si->packet_buffer.head = NULL;
3508  si->packet_buffer.tail = NULL;
3509  goto out;
3510  }
3511  pktl = si->packet_buffer.head;
3512  }
3513 
3514  if (ffstream(s->streams[pktl->pkt.stream_index])->last_in_packet_buffer == pktl)
3515  ffstream(s->streams[pktl->pkt.stream_index])->last_in_packet_buffer = NULL;
3517  av_log(s, AV_LOG_TRACE, "out st:%d dts:%"PRId64"\n", out->stream_index, out->dts);
3518  return 1;
3519  } else {
3520  out:
3521  return 0;
3522  }
3523 }
3524 
3526  const AVPacket *pkt)
3527 {
3528  MXFStreamContext *sc = s->streams[pkt ->stream_index]->priv_data;
3529  MXFStreamContext *sc2 = s->streams[next->stream_index]->priv_data;
3530 
3531  return next->dts > pkt->dts ||
3532  (next->dts == pkt->dts && sc->order < sc2->order);
3533 }
3534 
3536  int flush, int has_packet)
3537 {
3538  int ret;
3539  if (has_packet) {
3540  MXFStreamContext *sc = s->streams[pkt->stream_index]->priv_data;
3541  pkt->pts = pkt->dts = sc->pkt_cnt++;
3543  return ret;
3544  }
3546 }
3547 
3549 {
3550  if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
3551  if (pkt->size >= 5 && AV_RB32(pkt->data) != 0x0000001 &&
3552  AV_RB24(pkt->data) != 0x000001)
3553  return ff_stream_add_bitstream_filter(st, "h264_mp4toannexb", NULL);
3554  }
3555  return 1;
3556 }
3557 
3558 #define MXF_COMMON_OPTIONS \
3559  { "signal_standard", "Force/set Signal Standard",\
3560  offsetof(MXFContext, signal_standard), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, .unit = "signal_standard"},\
3561  { "bt601", "ITU-R BT.601 and BT.656, also SMPTE 125M (525 and 625 line interlaced)",\
3562  0, AV_OPT_TYPE_CONST, {.i64 = 1}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, .unit = "signal_standard"},\
3563  { "bt1358", "ITU-R BT.1358 and ITU-R BT.799-3, also SMPTE 293M (525 and 625 line progressive)",\
3564  0, AV_OPT_TYPE_CONST, {.i64 = 2}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, .unit = "signal_standard"},\
3565  { "smpte347m", "SMPTE 347M (540 Mbps mappings)",\
3566  0, AV_OPT_TYPE_CONST, {.i64 = 3}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, .unit = "signal_standard"},\
3567  { "smpte274m", "SMPTE 274M (1125 line)",\
3568  0, AV_OPT_TYPE_CONST, {.i64 = 4}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, .unit = "signal_standard"},\
3569  { "smpte296m", "SMPTE 296M (750 line progressive)",\
3570  0, AV_OPT_TYPE_CONST, {.i64 = 5}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, .unit = "signal_standard"},\
3571  { "smpte349m", "SMPTE 349M (1485 Mbps mappings)",\
3572  0, AV_OPT_TYPE_CONST, {.i64 = 6}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, .unit = "signal_standard"},\
3573  { "smpte428", "SMPTE 428-1 DCDM",\
3574  0, AV_OPT_TYPE_CONST, {.i64 = 7}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, .unit = "signal_standard"},
3575 
3576 
3577 
3578 static const AVOption mxf_options[] = {
3580  { "store_user_comments", "",
3581  offsetof(MXFContext, store_user_comments), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
3582  { NULL },
3583 };
3584 
3585 static const AVClass mxf_muxer_class = {
3586  .class_name = "MXF muxer",
3587  .item_name = av_default_item_name,
3588  .option = mxf_options,
3589  .version = LIBAVUTIL_VERSION_INT,
3590 };
3591 
3592 static const AVOption d10_options[] = {
3593  { "d10_channelcount", "Force/set channelcount in generic sound essence descriptor",
3594  offsetof(MXFContext, channel_count), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 8, AV_OPT_FLAG_ENCODING_PARAM},
3596  { "store_user_comments", "",
3597  offsetof(MXFContext, store_user_comments), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
3598  { NULL },
3599 };
3600 
3602  .class_name = "MXF-D10 muxer",
3603  .item_name = av_default_item_name,
3604  .option = d10_options,
3605  .version = LIBAVUTIL_VERSION_INT,
3606 };
3607 
3608 static const AVOption opatom_options[] = {
3609  { "mxf_audio_edit_rate", "Audio edit rate for timecode",
3610  offsetof(MXFContext, audio_edit_rate), AV_OPT_TYPE_RATIONAL, {.dbl=25}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
3612  { "store_user_comments", "",
3613  offsetof(MXFContext, store_user_comments), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
3614  { NULL },
3615 };
3616 
3618  .class_name = "MXF-OPAtom muxer",
3619  .item_name = av_default_item_name,
3620  .option = opatom_options,
3621  .version = LIBAVUTIL_VERSION_INT,
3622 };
3623 
3625  .p.name = "mxf",
3626  .p.long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3627  .p.mime_type = "application/mxf",
3628  .p.extensions = "mxf",
3629  .priv_data_size = sizeof(MXFContext),
3630  .p.audio_codec = AV_CODEC_ID_PCM_S16LE,
3631  .p.video_codec = AV_CODEC_ID_MPEG2VIDEO,
3632  .init = mxf_init,
3633  .write_packet = mxf_write_packet,
3634  .write_trailer = mxf_write_footer,
3635  .deinit = mxf_deinit,
3636  .p.flags = AVFMT_NOTIMESTAMPS,
3637  .interleave_packet = mxf_interleave,
3638  .p.priv_class = &mxf_muxer_class,
3639  .check_bitstream = mxf_check_bitstream,
3640 };
3641 
3643  .p.name = "mxf_d10",
3644  .p.long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format) D-10 Mapping"),
3645  .p.mime_type = "application/mxf",
3646  .priv_data_size = sizeof(MXFContext),
3647  .p.audio_codec = AV_CODEC_ID_PCM_S16LE,
3648  .p.video_codec = AV_CODEC_ID_MPEG2VIDEO,
3649  .init = mxf_init,
3650  .write_packet = mxf_write_packet,
3651  .write_trailer = mxf_write_footer,
3652  .deinit = mxf_deinit,
3653  .p.flags = AVFMT_NOTIMESTAMPS,
3654  .interleave_packet = mxf_interleave,
3655  .p.priv_class = &mxf_d10_muxer_class,
3656 };
3657 
3659  .p.name = "mxf_opatom",
3660  .p.long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format) Operational Pattern Atom"),
3661  .p.mime_type = "application/mxf",
3662  .p.extensions = "mxf",
3663  .priv_data_size = sizeof(MXFContext),
3664  .p.audio_codec = AV_CODEC_ID_PCM_S16LE,
3665  .p.video_codec = AV_CODEC_ID_DNXHD,
3666  .init = mxf_init,
3667  .write_packet = mxf_write_packet,
3668  .write_trailer = mxf_write_footer,
3669  .deinit = mxf_deinit,
3670  .p.flags = AVFMT_NOTIMESTAMPS,
3671  .interleave_packet = mxf_interleave,
3672  .p.priv_class = &mxf_opatom_muxer_class,
3673  .check_bitstream = mxf_check_bitstream,
3674 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:333
H264SPS
Definition: avc.h:32
AVMasteringDisplayMetadata::has_primaries
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
Definition: mastering_display_metadata.h:62
MXFContext::edit_units_count
unsigned edit_units_count
Definition: mxfenc.c:460
primer_pack_key
static const uint8_t primer_pack_key[]
Definition: mxfenc.c:283
MXFStreamContext
Definition: mxfenc.c:99
IS_OPATOM
#define IS_OPATOM(s)
Definition: mxfenc.c:73
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:429
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:134
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:57
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
PacketList::head
PacketListEntry * head
Definition: packet_internal.h:34
entry
#define entry
Definition: aom_film_grain_template.c:66
ff_mxf_color_primaries_uls
const MXFCodecUL ff_mxf_color_primaries_uls[]
Definition: mxf.c:98
AVOutputFormat::name
const char * name
Definition: avformat.h:510
d10_options
static const AVOption d10_options[]
Definition: mxfenc.c:3592
AVERROR
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
uid
UID uid
Definition: mxfenc.c:2423
opt.h
Track
Definition: ismindex.c:70
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
out
FILE * out
Definition: movenc.c:55
mxf_write_random_index_pack
static void mxf_write_random_index_pack(AVFormatContext *s)
Definition: mxfenc.c:3381
mxf_utf16len
static uint64_t mxf_utf16len(const char *utf8_str)
Definition: mxfenc.c:780
color
Definition: vf_paletteuse.c:511
MXFContext::tc
AVTimecode tc
timecode context
Definition: mxfenc.c:468
GetByteContext
Definition: bytestream.h:33
FF_MXF_MasteringDisplayMinimumLuminance
#define FF_MXF_MasteringDisplayMinimumLuminance
Definition: mxf.h:100
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
INDEX_H264
@ INDEX_H264
Definition: mxfenc.c:151
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:188
klv_encode_ber_length
static int klv_encode_ber_length(AVIOContext *pb, uint64_t len)
Definition: mxfenc.c:517
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition: codec_par.h:169
MXFStreamContext::j2k_info
j2k_info_t j2k_info
Definition: mxfenc.c:125
AVStream::priv_data
void * priv_data
Definition: avformat.h:773
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3025
mxf_write_opatom_body_partition
static int mxf_write_opatom_body_partition(AVFormatContext *s)
Definition: mxfenc.c:3179
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: defs.h:202
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:219
AVMasteringDisplayMetadata::display_primaries
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
Definition: mastering_display_metadata.h:42
mxf_write_local_tag
static void mxf_write_local_tag(AVFormatContext *s, int size, int tag)
Definition: mxfenc.c:670
TaggedValue
@ TaggedValue
Definition: mxf.h:50
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition: mastering_display_metadata.h:67
MXFContext::tagged_value_count
uint32_t tagged_value_count
Definition: mxfenc.c:478
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:479
int64_t
long long int64_t
Definition: coverity.c:34
MXF_COMMON_OPTIONS
#define MXF_COMMON_OPTIONS
Definition: mxfenc.c:3558
j2k_info_t::j2k_rsiz
uint16_t j2k_rsiz
j2k required decoder capabilities (Rsiz)
Definition: mxfenc.c:87
mxf_write_d10_audio_packet
static void mxf_write_d10_audio_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:3147
FF_MXF_MasteringDisplayPrimaries
#define FF_MXF_MasteringDisplayPrimaries
Definition: mxf.h:97
MXFPackage::type
enum MXFMetadataSetType type
Definition: mxfenc.c:137
DESCRIPTOR_COUNT
#define DESCRIPTOR_COUNT(essence_container_count)
Definition: mxfenc.c:700
pixdesc.h
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:390
AVPacket::data
uint8_t * data
Definition: packet.h:539
header_metadata_key
static const uint8_t header_metadata_key[]
partial key for header metadata
Definition: mxfenc.c:293
ContentStorage
@ ContentStorage
Definition: mxf.h:45
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
j2k_info_t
Definition: mxfenc.c:85
SourceClip
@ SourceClip
Definition: mxf.h:35
AVOption
AVOption.
Definition: opt.h:429
JPEG2000_SOC
@ JPEG2000_SOC
Definition: jpeg2000.h:39
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:837
MXFPackage::instance
int instance
Definition: mxfenc.c:138
AVTimecode::flags
uint32_t flags
flags such as drop frame, +24 hours support, ...
Definition: timecode.h:43
rangecoder.h
MXFContext::body_offset
uint64_t body_offset
Definition: mxfenc.c:473
MXFStreamContext::frame_size
int frame_size
frame size in bytes
Definition: mxfenc.c:118
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:75
MXFIndexEntry
Definition: mxfenc.c:78
mxf_parse_dnxhd_frame
static int mxf_parse_dnxhd_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:2290
ff_parse_creation_time_metadata
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: mux_utils.c:138
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
LIBAVFORMAT_VERSION_MICRO
#define LIBAVFORMAT_VERSION_MICRO
Definition: version.h:35
MXFStreamContext::index
int index
index in mxf_essence_container_uls table
Definition: mxfenc.c:102
j2k_info_t::j2k_xsiz
uint32_t j2k_xsiz
j2k width of the reference grid (Xsiz)
Definition: mxfenc.c:88
AVDictionary
Definition: dict.c:34
product_uid
static const uint8_t product_uid[]
Definition: mxfenc.c:273
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
MXFStreamContext::signal_standard
int signal_standard
Definition: mxfenc.c:110
mxf_write_content_storage
static void mxf_write_content_storage(AVFormatContext *s, MXFPackage *packages, int package_count)
Definition: mxfenc.c:905
mxf_rgba_descriptor_key
static const UID mxf_rgba_descriptor_key
Definition: mxfenc.c:1186
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AV_OPT_TYPE_RATIONAL
@ AV_OPT_TYPE_RATIONAL
Underlying C type is AVRational.
Definition: opt.h:280
rescale_mastering_luma
static uint32_t rescale_mastering_luma(AVRational q)
Definition: mxfenc.c:1198
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
ff_mxf_d10_muxer
const FFOutputFormat ff_mxf_d10_muxer
Definition: mxfenc.c:3642
mxf_muxer_class
static const AVClass mxf_muxer_class
Definition: mxfenc.c:3585
MXFContext
Definition: mxfdec.c:301
ff_mxf_color_trc_uls
const MXFCodecUL ff_mxf_color_trc_uls[]
Definition: mxf.c:113
TimecodeComponent
@ TimecodeComponent
Definition: mxf.h:36
MXFContainerEssenceEntry::codec_ul
UID codec_ul
Definition: mxfenc.c:131
INDEX_MPEG2
@ INDEX_MPEG2
Definition: mxfenc.c:143
AV_WB64
#define AV_WB64(p, v)
Definition: intreadwrite.h:429
MXFStreamContext::interlaced
int interlaced
whether picture is interlaced
Definition: mxfenc.c:106
mxf_get_essence_container_ul_index
static int mxf_get_essence_container_ul_index(enum AVCodecID id)
Definition: mxfenc.c:552
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:65
mxf_avc_subdescriptor_key
static const UID mxf_avc_subdescriptor_key
Definition: mxfenc.c:1189
AV_PROFILE_PRORES_STANDARD
#define AV_PROFILE_PRORES_STANDARD
Definition: defs.h:183
av_get_random_seed
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
Definition: random_seed.c:167
INDEX_DNXHD
@ INDEX_DNXHD
Definition: mxfenc.c:149
MXFContainerEssenceEntry::write_desc
void(* write_desc)(AVFormatContext *, AVStream *)
Definition: mxfenc.c:132
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
MXF_NUM_TAGS
#define MXF_NUM_TAGS
Definition: mxfenc.c:451
mxf_ffv1_codec_uls
static const UID mxf_ffv1_codec_uls[]
Definition: mxfenc.c:265
avio_wl16
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:437
AVCodecParameters::color_primaries
enum AVColorPrimaries color_primaries
Definition: codec_par.h:167
avio_write_marker
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:461
golomb.h
exp golomb vlc stuff
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
TapeDescriptor
@ TapeDescriptor
Definition: mxf.h:51
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3065
ff_mxf_get_content_package_rate
int ff_mxf_get_content_package_rate(AVRational time_base)
Definition: mxf.c:220
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: defs.h:203
intra_only
int8_t intra_only
Definition: mxfenc.c:2427
INDEX_JPEG2000
@ INDEX_JPEG2000
Definition: mxfenc.c:150
mxf.h
AV_PROFILE_PRORES_HQ
#define AV_PROFILE_PRORES_HQ
Definition: defs.h:184
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:862
store_version
static void store_version(AVFormatContext *s)
Definition: mxfenc.c:835
KAG_SIZE
#define KAG_SIZE
Definition: mxfenc.c:76
PLATFORM_IDENT
#define PLATFORM_IDENT
Definition: mxfenc.c:851
smpte_12m_timecode_track_data_ul
static const uint8_t smpte_12m_timecode_track_data_ul[]
Definition: mxfenc.c:978
mxf_write_generic_sound_desc
static void mxf_write_generic_sound_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1729
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:419
header_open_partition_key
static const uint8_t header_open_partition_key[]
Definition: mxfenc.c:285
LIBAVFORMAT_VERSION_MAJOR
#define LIBAVFORMAT_VERSION_MAJOR
Definition: version_major.h:32
FFV1_CONTEXT_SIZE
#define FFV1_CONTEXT_SIZE
Definition: mxfenc.c:2590
mxf_write_footer
static int mxf_write_footer(AVFormatContext *s)
Definition: mxfenc.c:3408
mxf_mark_tag_unused
static void mxf_mark_tag_unused(MXFContext *mxf, int tag)
Definition: mxfenc.c:574
timecode.h
MXFStreamContext::track_essence_element_key
UID track_essence_element_key
Definition: mxfenc.c:101
mxf_local_tag_batch
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....
Definition: mxfenc.c:300
GetBitContext
Definition: get_bits.h:108
ff_avc_decode_sps
int ff_avc_decode_sps(H264SPS *sps, const uint8_t *buf, int buf_size)
Definition: avc.c:208
MXFCodecUL::id
int id
Definition: mxf.h:108
AVTimecode::start
int start
timecode frame start (first base frame number)
Definition: timecode.h:42
gmtime_r
#define gmtime_r
Definition: time_internal.h:34
mxf_write_multi_descriptor
static void mxf_write_multi_descriptor(AVFormatContext *s)
Definition: mxfenc.c:1106
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
avpriv_packet_list_get
int avpriv_packet_list_get(PacketList *pkt_buffer, AVPacket *pkt)
Remove the oldest AVPacket in the list and return it.
Definition: packet.c:582
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
MXFStreamContext::v_chroma_sub_sample
int v_chroma_sub_sample
Definition: mxfenc.c:112
mxf_ffv1_subdescriptor_key
static const UID mxf_ffv1_subdescriptor_key
Definition: mxfenc.c:1190
av_reduce
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
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_FIELD_TB
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition: defs.h:205
body_partition_key
static const uint8_t body_partition_key[]
Definition: mxfenc.c:288
MXFContext::header_written
int header_written
Definition: mxfenc.c:458
mxf_write_header_metadata_sets
static int mxf_write_header_metadata_sets(AVFormatContext *s)
Definition: mxfenc.c:1906
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:550
GET_UTF8
#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:488
AVCodecParameters::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:168
mxf_check_bitstream
static int mxf_check_bitstream(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
Definition: mxfenc.c:3548
avassert.h
mxf_write_package
static void mxf_write_package(AVFormatContext *s, MXFPackage *package)
Definition: mxfenc.c:1784
system_metadata_package_set_key
static const uint8_t system_metadata_package_set_key[]
Definition: mxfenc.c:3096
mxf_write_sequence
static void mxf_write_sequence(AVFormatContext *s, AVStream *st, MXFPackage *package)
Definition: mxfenc.c:1004
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:235
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
mxf_parse_prores_frame
static int mxf_parse_prores_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:2239
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
PRINT_KEY
#define PRINT_KEY(pc, s, x)
Definition: mxf.h:155
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition: defs.h:201
av_timecode_init
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:222
MXFStreamContext::h_chroma_sub_sample
int h_chroma_sub_sample
Definition: mxfenc.c:111
av_dict_get
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:62
mxf_essence_mappings
static const struct @404 mxf_essence_mappings[]
ff_mxf_data_definition_uls
const MXFCodecUL ff_mxf_data_definition_uls[]
SMPTE RP224 http://www.smpte-ra.org/mdd/index.html.
Definition: mxf.c:31
mxf_write_user_comments
static int mxf_write_user_comments(AVFormatContext *s, const AVDictionary *m)
Definition: mxfenc.c:1766
MXFStreamContext::temporal_reordering
int temporal_reordering
Definition: mxfenc.c:113
mxf_parse_h264_frame
static int mxf_parse_h264_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt, MXFIndexEntry *e)
Definition: mxfenc.c:2454
mxf_write_cdci_common
static int64_t mxf_write_cdci_common(AVFormatContext *s, AVStream *st, const UID key)
Definition: mxfenc.c:1203
mxf_write_common_fields
static void mxf_write_common_fields(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:980
mxf_write_identification
static void mxf_write_identification(AVFormatContext *s)
Definition: mxfenc.c:852
MXFContext::slice_count
uint8_t slice_count
index slice count minus 1 (1 if no audio, 0 otherwise)
Definition: mxfenc.c:462
AVMasteringDisplayMetadata::white_point
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Definition: mastering_display_metadata.h:47
MXFPackage::ref
struct MXFPackage * ref
Definition: mxfenc.c:139
s
#define s(width, name)
Definition: cbs_vp9.c:198
MXFMetadataSetType
MXFMetadataSetType
Definition: mxf.h:32
AVCHROMA_LOC_TOP
@ AVCHROMA_LOC_TOP
Definition: pixfmt.h:720
MultipleDescriptor
@ MultipleDescriptor
Definition: mxf.h:39
MXFContext::timecode_base
int timecode_base
rounded time code base (25 or 30)
Definition: mxfenc.c:470
klv_encode_ber9_length
static void klv_encode_ber9_length(AVIOContext *pb, uint64_t len)
Definition: mxfenc.c:543
INDEX_S436M
@ INDEX_S436M
Definition: mxfenc.c:152
FFFormatContext::packet_buffer
PacketList packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:98
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:144
choose_chroma_location
static enum AVChromaLocation choose_chroma_location(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:2838
g
const char * g
Definition: vf_curves.c:128
AVDictionaryEntry::key
char * key
Definition: dict.h:90
frame_size
int frame_size
Definition: mxfenc.c:2424
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
jpeg2000.h
ULIndex
ULIndex
Definition: mxfenc.c:142
AVCSubDescriptor
@ AVCSubDescriptor
Definition: mxf.h:52
mxf_parse_mpeg2_frame
static int mxf_parse_mpeg2_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt, MXFIndexEntry *e)
Definition: mxfenc.c:2718
mxf_write_wav_desc
static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1717
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
mxf_write_track
static void mxf_write_track(AVFormatContext *s, AVStream *st, MXFPackage *package)
Definition: mxfenc.c:932
j2k_info_t::j2k_ysiz
uint32_t j2k_ysiz
j2k height of the reference grid (Ysiz)
Definition: mxfenc.c:89
UID
AVUUID UID
Definition: mxf.h:30
mxf_d10_muxer_class
static const AVClass mxf_d10_muxer_class
Definition: mxfenc.c:3601
mxf_cdci_descriptor_key
static const UID mxf_cdci_descriptor_key
Definition: mxfenc.c:1185
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
AVPacketSideData::data
uint8_t * data
Definition: packet.h:391
mxf_write_klv_fill
static void mxf_write_klv_fill(AVFormatContext *s)
Definition: mxfenc.c:2110
INDEX_WAV
@ INDEX_WAV
Definition: mxfenc.c:145
mxf_dnxhd_codec_uls
static const struct @406 mxf_dnxhd_codec_uls[]
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
INDEX_DV
@ INDEX_DV
Definition: mxfenc.c:148
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
mxf_compare_timestamps
static int mxf_compare_timestamps(AVFormatContext *s, const AVPacket *next, const AVPacket *pkt)
Definition: mxfenc.c:3525
mxf_write_opatom_packet
static int mxf_write_opatom_packet(AVFormatContext *s, AVPacket *pkt, MXFIndexEntry *ie)
Definition: mxfenc.c:3200
key
const char * key
Definition: hwcontext_opencl.c:189
MXFContext::audio_edit_rate
AVRational audio_edit_rate
Definition: mxfenc.c:479
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:86
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
Preface
@ Preface
Definition: mxf.h:43
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
mxf_essence_container_uls
static const MXFContainerEssenceEntry mxf_essence_container_uls[]
Definition: mxfenc.c:182
ff_mxf_color_space_uls
const MXFCodecUL ff_mxf_color_space_uls[]
Definition: mxf.c:134
PacketList::tail
PacketListEntry * tail
Definition: packet_internal.h:34
JPEG2000SubDescriptor
@ JPEG2000SubDescriptor
Definition: mxf.h:57
time_internal.h
if
if(ret)
Definition: filter_design.txt:179
FFFormatContext
Definition: internal.h:64
mxf_jpeg2000_subdescriptor_key
static const UID mxf_jpeg2000_subdescriptor_key
Definition: mxfenc.c:1191
MXFContext::duration
uint64_t duration
Definition: mxfenc.c:467
MXFIndexEntry::slice_offset
unsigned slice_offset
offset of audio slice
Definition: mxfenc.c:80
SubDescriptor
@ SubDescriptor
Definition: mxf.h:46
AVFormatContext
Format I/O context.
Definition: avformat.h:1300
mxf_write_tagged_value
static int mxf_write_tagged_value(AVFormatContext *s, const char *name, const char *value)
Definition: mxfenc.c:1737
internal.h
MXFContext::store_user_comments
int store_user_comments
Definition: mxfenc.c:480
FF_MXF_MASTERING_LUMA_DEN
#define FF_MXF_MASTERING_LUMA_DEN
Definition: mxf.h:103
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
mxf_d10_container_uls
static const UID mxf_d10_container_uls[]
Definition: mxfenc.c:255
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
mxf_write_aes3_desc
static void mxf_write_aes3_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1723
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:787
NULL
#define NULL
Definition: coverity.c:32
MaterialPackage
@ MaterialPackage
Definition: mxf.h:33
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
MXFContext::edit_unit_byte_count
int edit_unit_byte_count
fixed edit unit byte count
Definition: mxfenc.c:471
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:717
mxf_write_essence_container_data
static int mxf_write_essence_container_data(AVFormatContext *s)
Definition: mxfenc.c:1884
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:719
FF_MXF_MASTERING_CHROMA_DEN
#define FF_MXF_MASTERING_CHROMA_DEN
Definition: mxf.h:102
mxf_interleave_get_packet
static int mxf_interleave_get_packet(AVFormatContext *s, AVPacket *out, int flush)
Definition: mxfenc.c:3474
MXFContainerEssenceEntry
Definition: mxfenc.c:128
uuid_base
static const uint8_t uuid_base[]
Definition: mxfenc.c:274
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
avc.h
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:370
MXFStreamContext::b_picture_count
int b_picture_count
maximum number of consecutive b pictures, used in mpeg-2 descriptor
Definition: mxfenc.c:121
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:828
mxf_utf16_local_tag_length
static int mxf_utf16_local_tag_length(const char *utf8_str)
Definition: mxfenc.c:802
MXFContext::signal_standard
int signal_standard
Definition: mxfenc.c:477
avpriv_find_start_code
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
FFOutputFormat
Definition: mux.h:61
mxf_parse_ffv1_frame
static int mxf_parse_ffv1_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:2591
mxf_write_structural_component
static void mxf_write_structural_component(AVFormatContext *s, AVStream *st, MXFPackage *package)
Definition: mxfenc.c:1058
MXFContext::last_indexed_edit_unit
int last_indexed_edit_unit
Definition: mxfenc.c:463
time.h
MXFStreamContext::max_gop
int max_gop
maximum gop size, used by mpeg-2 descriptor
Definition: mxfenc.c:120
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:179
j2k_info_t::j2k_xtsiz
uint32_t j2k_xtsiz
j2k width of one reference tile with respect to the reference grid (XTsiz)
Definition: mxfenc.c:92
ffio_fill
void ffio_fill(AVIOContext *s, int b, int64_t count)
Definition: aviobuf.c:187
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
mxf_init
static int mxf_init(AVFormatContext *s)
Definition: mxfenc.c:2867
mxf_mpeg2_codec_uls
static const UID mxf_mpeg2_codec_uls[]
Definition: mxfenc.c:2685
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
PacketListEntry::next
struct PacketListEntry * next
Definition: packet_internal.h:29
mxf_write_index_table_segment
static void mxf_write_index_table_segment(AVFormatContext *s)
Definition: mxfenc.c:1964
MXFStreamContext::codec_ul
const UID * codec_ul
Definition: mxfenc.c:103
seed
static unsigned int seed
Definition: videogen.c:78
j2k_info_t::j2k_ytsiz
uint32_t j2k_ytsiz
j2k height of one reference tile with respect to the reference grid (YTsiz)
Definition: mxfenc.c:93
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:662
AVCodecParameters::level
int level
Definition: codec_par.h:129
INDEX_D10_AUDIO
@ INDEX_D10_AUDIO
Definition: mxfenc.c:147
AVTimecode::rate
AVRational rate
frame rate in rational form
Definition: timecode.h:44
AV_OPT_FLAG_ENCODING_PARAM
#define AV_OPT_FLAG_ENCODING_PARAM
A generic parameter which can be set by the user for muxing or encoding.
Definition: opt.h:352
c
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
mxf_dv_uls
static const struct @407 mxf_dv_uls[]
AV_PROFILE_PRORES_LT
#define AV_PROFILE_PRORES_LT
Definition: defs.h:182
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
cid
uint16_t cid
Definition: mxfenc.c:2264
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:53
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
MXFStreamContext::order
int order
interleaving order if dts are equal
Definition: mxfenc.c:105
j2k_info_t::j2k_comp_desc
uint8_t j2k_comp_desc[12]
j2k components descriptor (Ssiz(i), XRsiz(i), YRsiz(i))
Definition: mxfenc.c:96
av_packet_side_data_get
const AVPacketSideData * av_packet_side_data_get(const AVPacketSideData *sd, int nb_sd, enum AVPacketSideDataType type)
Get side information from a side data array.
Definition: packet.c:656
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
mxf_compute_edit_unit_byte_count
static void mxf_compute_edit_unit_byte_count(AVFormatContext *s)
Definition: mxfenc.c:3229
startcode.h
mxf_deinit
static void mxf_deinit(AVFormatContext *s)
Definition: mxfenc.c:3465
av_rescale_rnd
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
mxf_indirect_value_utf16le
static const uint8_t mxf_indirect_value_utf16le[]
Definition: mxfenc.c:1735
INDEX_FFV1
@ INDEX_FFV1
Definition: mxfenc.c:154
ff_init_range_decoder
av_cold void ff_init_range_decoder(RangeCoder *c, const uint8_t *buf, int buf_size)
Definition: rangecoder.c:53
FF_MXF_MasteringDisplayWhitePointChromaticity
#define FF_MXF_MasteringDisplayWhitePointChromaticity
Definition: mxf.h:98
AV_CODEC_ID_FFV1
@ AV_CODEC_ID_FFV1
Definition: codec_id.h:85
ff_mxf_muxer
const FFOutputFormat ff_mxf_muxer
Definition: mxfenc.c:3624
MXFStreamContext::closed_gop
int closed_gop
gop is closed, used in mpeg-2 frame parsing
Definition: mxfenc.c:115
klv_encode_ber4_length
static void klv_encode_ber4_length(AVIOContext *pb, int len)
Definition: mxfenc.c:537
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:345
MXFContext::cbr_index
int cbr_index
use a constant bitrate index
Definition: mxfenc.c:482
j2k_info_t::j2k_y0siz
uint32_t j2k_y0siz
j2k vertical offset from the origin of the reference grid to the left side of the image (Y0siz)
Definition: mxfenc.c:91
AVPacket::size
int size
Definition: packet.h:540
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:136
MXFStreamContext::color_siting
int color_siting
Definition: mxfenc.c:109
MXFStreamContext::pkt_cnt
int64_t pkt_cnt
pkt counter for muxed packets
Definition: mxfenc.c:100
mxf_prores_codec_uls
static const struct @405 mxf_prores_codec_uls[]
sample
#define sample
Definition: flacdsp_template.c:44
mxf_write_packet
static int mxf_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mxfenc.c:3250
size
int size
Definition: twinvq_data.h:10344
Identification
@ Identification
Definition: mxf.h:44
INDEX_AES3
@ INDEX_AES3
Definition: mxfenc.c:144
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
ff_build_rac_states
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:68
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
mxf_update_klv_size
static void mxf_update_klv_size(AVIOContext *pb, int64_t pos)
Definition: mxfenc.c:1453
AV_RB32
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:96
PacketListEntry::pkt
AVPacket pkt
Definition: packet_internal.h:30
AVCodecParameters::profile
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:128
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:716
MXFContext::time_base
AVRational time_base
Definition: mxfenc.c:457
get_ffv1_unsigned_symbol
static int get_ffv1_unsigned_symbol(RangeCoder *c, uint8_t *state)
Definition: mxfenc.c:2569
AV_RL24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:93
MXFContext::av_class
AVClass * av_class
Definition: mxfenc.c:454
MXFContext::timestamp
uint64_t timestamp
timestamp, as year(16),month(8),day(8),hour(8),minutes(8),msec/4(8)
Definition: mxfenc.c:461
mxf_write_umid
static void mxf_write_umid(AVFormatContext *s, int type)
Definition: mxfenc.c:494
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:201
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:365
AV_PROFILE_PRORES_4444
#define AV_PROFILE_PRORES_4444
Definition: defs.h:185
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
av_reallocp_array
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate an array through a pointer to a pointer.
Definition: mem.c:225
mxf_opatom_muxer_class
static const AVClass mxf_opatom_muxer_class
Definition: mxfenc.c:3617
avio_wl32
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:357
IndexTableSegment
@ IndexTableSegment
Definition: mxf.h:47
mxf_gen_umid
static void mxf_gen_umid(AVFormatContext *s)
Definition: mxfenc.c:2802
mxf_write_system_item
static void mxf_write_system_item(AVFormatContext *s)
Definition: mxfenc.c:3098
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: defs.h:61
MXFStreamContext::micro_version
int micro_version
format micro_version, used in ffv1 descriptor
Definition: mxfenc.c:124
version
version
Definition: libkvazaar.c:321
MXFContext::timecode_track_priv
MXFStreamContext timecode_track_priv
Definition: mxfenc.c:484
AV_PROFILE_PRORES_PROXY
#define AV_PROFILE_PRORES_PROXY
Definition: defs.h:181
MXFContext::body_partition_offset
uint64_t * body_partition_offset
Definition: mxfenc.c:464
multiple_desc_ul
static const uint8_t multiple_desc_ul[]
Definition: mxfenc.c:294
opatom_options
static const AVOption opatom_options[]
Definition: mxfenc.c:3608
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:715
footer_partition_key
static const uint8_t footer_partition_key[]
Definition: mxfenc.c:282
av_timecode_get_smpte_from_framenum
uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum)
Convert frame number to SMPTE 12M binary representation.
Definition: timecode.c:53
MXFContext::footer_partition_offset
int64_t footer_partition_offset
Definition: mxfenc.c:455
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
container_ul
const UID container_ul
Definition: mxfenc.c:2336
mxf_get_codec_ul_by_id
static const MXFCodecUL * mxf_get_codec_ul_by_id(const MXFCodecUL *uls, int id)
Definition: mxfenc.c:689
interlaced
uint8_t interlaced
Definition: mxfenc.c:2265
mxf_write_avc_subdesc
static void mxf_write_avc_subdesc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1462
mxf_lookup_local_tag
static const MXFLocalTagPair * mxf_lookup_local_tag(int tag)
Definition: mxfenc.c:561
PacketListEntry
Definition: packet_internal.h:28
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
j2k_info_t::j2k_x0siz
uint32_t j2k_x0siz
j2k horizontal offset from the origin of the reference grid to the left side of the image (X0siz)
Definition: mxfenc.c:90
MXFContext::content_package_rate
int content_package_rate
content package rate in system element, see SMPTE 326M
Definition: mxfenc.c:472
avio_internal.h
klv_fill_size
static unsigned klv_fill_size(uint64_t size)
Definition: mxfenc.c:1955
mxf_write_cdci_desc
static void mxf_write_cdci_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1543
MXFContext::timecode_track
AVStream * timecode_track
Definition: mxfenc.c:469
codec_ul
UID codec_ul
Definition: mxfenc.c:2229
MXFStreamContext::slice_offset
int slice_offset
Definition: mxfenc.c:117
state
static struct @457 state
index
enum ULIndex index
Definition: mxfenc.c:159
AVCodecParameters::height
int height
Definition: codec_par.h:135
mxf_write_s436m_anc_desc
static void mxf_write_s436m_anc_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1609
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:191
MXFStreamContext::container_ul
const UID * container_ul
Definition: mxfenc.c:104
ff_interleave_add_packet
int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt, int(*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
Add packet to an AVFormatContext's packet_buffer list, determining its interleaved position using com...
Definition: mux.c:855
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
mxf_parse_dv_frame
static int mxf_parse_dv_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:2361
j2k_info_t::j2k_xt0siz
uint32_t j2k_xt0siz
j2k horizontal offset from the origin of the reference grid to the left side of the first tile (XT0si...
Definition: mxfenc.c:94
MXFContainerEssenceEntry::element_ul
UID element_ul
Definition: mxfenc.c:130
umid_ul
static const uint8_t umid_ul[]
Definition: mxfenc.c:275
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
MXFIndexEntry::flags
uint8_t flags
Definition: mxfenc.c:82
mxf_d10_codec_uls
static const UID mxf_d10_codec_uls[]
Definition: mxfenc.c:246
mxf_write_timecode_component
static void mxf_write_timecode_component(AVFormatContext *s, AVStream *st, MXFPackage *package)
Definition: mxfenc.c:1031
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
system_metadata_pack_key
static const uint8_t system_metadata_pack_key[]
Definition: mxfenc.c:3095
AV_STRINGIFY
#define AV_STRINGIFY(s)
Definition: macros.h:66
AV_CODEC_ID_DVVIDEO
@ AV_CODEC_ID_DVVIDEO
Definition: codec_id.h:76
JPEG2000_SIZ
@ JPEG2000_SIZ
Definition: jpeg2000.h:41
MXFIndexEntry::offset
uint64_t offset
Definition: mxfenc.c:79
ff_mxf_opatom_muxer
const FFOutputFormat ff_mxf_opatom_muxer
Definition: mxfenc.c:3658
EssenceContainerData
@ EssenceContainerData
Definition: mxf.h:48
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
mxf_write_uuid
static void mxf_write_uuid(AVIOContext *pb, enum MXFMetadataSetType type, int value)
Definition: mxfenc.c:487
mxf_write_ffv1_subdesc
static void mxf_write_ffv1_subdesc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1568
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
AVCodecParameters::color_range
enum AVColorRange color_range
Video only.
Definition: codec_par.h:166
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
len
int len
Definition: vorbis_enc_data.h:426
AV_CODEC_ID_JPEG2000
@ AV_CODEC_ID_JPEG2000
Definition: codec_id.h:140
get_rac
static int get_rac(RangeCoder *c, uint8_t *const state)
Definition: rangecoder.h:127
profile
int profile
Definition: mxfenc.c:2228
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition: codec_par.h:81
nal.h
FFStream::last_in_packet_buffer
PacketListEntry * last_in_packet_buffer
last packet in packet_buffer for this stream when muxing.
Definition: internal.h:375
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:679
MXFContext::instance_number
uint32_t instance_number
Definition: mxfenc.c:474
MXFContext::last_key_index
int last_key_index
index of last key frame
Definition: mxfenc.c:466
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:161
MXFPackage
Definition: mxfdec.c:268
mxf_interleave
static int mxf_interleave(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
Definition: mxfenc.c:3535
versi