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