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 {
111  void (*write_desc)(AVFormatContext *, AVStream *);
113 
114 typedef struct MXFPackage {
115  char *name;
117  int instance;
118  struct MXFPackage *ref;
119 } MXFPackage;
120 
121 enum ULIndex {
153 };
154 
155 static const struct {
156  enum AVCodecID id;
158 } mxf_essence_mappings[] = {
161  { AV_CODEC_ID_PCM_S16LE, INDEX_AES3 },
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 
530 static void mxf_write_umid(AVFormatContext *s, int type)
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);
615  local_tag_number += mxf->store_user_comments * FF_ARRAY_ELEMS(mxf_user_comments_local_tag);
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) {
620  avc_tags_count = FF_ARRAY_ELEMS(mxf_avc_subdescriptor_local_tags);
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);
633  avio_write(pb, mxf_local_tag_batch[i].uid, 16);
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);
638  avio_write(pb, mxf_user_comments_local_tag[i].uid, 16);
639  }
640  if (avc_tags_count > 0)
641  mxf_write_local_tags(pb, mxf_avc_subdescriptor_local_tags, avc_tags_count);
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 
656 static void mxf_free(AVFormatContext *s)
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 
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;
694  avio_write(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
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) +
845  klv_encode_ber_length(pb, length);
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 
902 static void mxf_write_track(AVFormatContext *s, AVStream *st, MXFPackage *package)
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 
1013  mxf_write_common_fields(s, st);
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);
1043  mxf_write_common_fields(s, st);
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;
1104  ul = mxf_essence_container_uls[sc->index].container_ul;
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);
1111  for (i = 0; i < s->nb_streams; i++)
1112  mxf_write_uuid(pb, SubDescriptor, 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);
1148  avio_write(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
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 
1190 static int64_t mxf_write_cdci_common(AVFormatContext *s, AVStream *st, const UID key)
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);
1368  klv_encode_ber4_length(pb, size);
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) {
1410  mxf_write_mpegvideo_desc(s, st);
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 
1509 static int64_t mxf_write_wav_common(AVFormatContext *s, AVStream *st, const UID key)
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++)
1639  mxf_write_uuid(pb, Track, mxf->track_instance_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);
1674  mxf_write_timecode_component(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;
1686  mxf_essence_container_uls[sc->index].write_desc(s, st);
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 
1752  mxf_write_preface(s);
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)
1904  avio_wb32(pb, mxf->index_entries[i].slice_offset);
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  // add encoded ber length
1948  index_byte_count += 16 + klv_ber_length(index_byte_count);
1949  index_byte_count += klv_fill_size(index_byte_count);
1950  }
1951 
1952  if (key && !memcmp(key, body_partition_key, 16)) {
1954  sizeof(*mxf->body_partition_offset))) < 0) {
1955  mxf->body_partitions_count = 0;
1956  return err;
1957  }
1958  mxf->body_partition_offset[mxf->body_partitions_count++] = partition_offset;
1959  }
1960 
1961  // write klv
1962  if (key)
1963  avio_write(pb, key, 16);
1964  else
1965  avio_write(pb, body_partition_key, 16);
1966 
1968 
1969  // write partition value
1970  avio_wb16(pb, 1); // majorVersion
1971  avio_wb16(pb, 3); // minorVersion
1972  avio_wb32(pb, KAG_SIZE); // KAGSize
1973 
1974  avio_wb64(pb, partition_offset); // ThisPartition
1975 
1976  if (key && !memcmp(key, body_partition_key, 16) && mxf->body_partitions_count > 1)
1977  avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-2]); // PreviousPartition
1978  else if (key && !memcmp(key, footer_partition_key, 16) && mxf->body_partitions_count)
1979  avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-1]); // PreviousPartition
1980  else
1981  avio_wb64(pb, 0);
1982 
1983  avio_wb64(pb, mxf->footer_partition_offset); // footerPartition
1984 
1985  // set offset
1986  header_byte_count_offset = avio_tell(pb);
1987  avio_wb64(pb, 0); // headerByteCount, update later
1988 
1989  // indexTable
1990  avio_wb64(pb, index_byte_count); // indexByteCount
1991  avio_wb32(pb, index_byte_count ? indexsid : 0); // indexSID
1992 
1993  // BodyOffset
1994  if (bodysid && mxf->edit_units_count && mxf->body_partitions_count && s->oformat != &ff_mxf_opatom_muxer)
1995  avio_wb64(pb, mxf->body_offset);
1996  else
1997  avio_wb64(pb, 0);
1998 
1999  avio_wb32(pb, bodysid); // bodySID
2000 
2001  // operational pattern
2002  if (s->oformat == &ff_mxf_opatom_muxer)
2003  avio_write(pb, opatom_ul, 16);
2004  else
2005  avio_write(pb, op1a_ul, 16);
2006 
2007  // essence container
2009 
2010  if (write_metadata) {
2011  // mark the start of the headermetadata and calculate metadata size
2012  int64_t pos, start;
2013  unsigned header_byte_count;
2014 
2015  mxf_write_klv_fill(s);
2016  start = avio_tell(s->pb);
2018  mxf_write_klv_fill(s);
2020  pos = avio_tell(s->pb);
2021  header_byte_count = pos - start + klv_fill_size(pos);
2022 
2023  // update header_byte_count
2024  avio_seek(pb, header_byte_count_offset, SEEK_SET);
2025  avio_wb64(pb, header_byte_count);
2026  avio_seek(pb, pos, SEEK_SET);
2027  }
2028 
2029  if(key)
2030  avio_flush(pb);
2031 
2032  return 0;
2033 }
2034 
2035 static const struct {
2036  int profile;
2038 } mxf_prores_codec_uls[] = {
2039  { FF_PROFILE_PRORES_PROXY, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x01,0x00 } },
2040  { FF_PROFILE_PRORES_LT, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x02,0x00 } },
2041  { FF_PROFILE_PRORES_STANDARD, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x03,0x00 } },
2042  { FF_PROFILE_PRORES_HQ, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x04,0x00 } },
2043  { FF_PROFILE_PRORES_4444, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x05,0x00 } },
2044  { FF_PROFILE_PRORES_XQ, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x06,0x00 } },
2045 };
2046 
2048 {
2049  MXFContext *mxf = s->priv_data;
2050  MXFStreamContext *sc = st->priv_data;
2051  int i, profile;
2052 
2053  if (mxf->header_written)
2054  return 1;
2055 
2056  sc->codec_ul = NULL;
2057  profile = st->codecpar->profile;
2058  for (i = 0; i < FF_ARRAY_ELEMS(mxf_prores_codec_uls); i++) {
2059  if (profile == mxf_prores_codec_uls[i].profile) {
2060  sc->codec_ul = &mxf_prores_codec_uls[i].codec_ul;
2061  break;
2062  }
2063  }
2064  if (!sc->codec_ul)
2065  return 0;
2066 
2067  sc->frame_size = pkt->size;
2068 
2069  return 1;
2070 }
2071 
2072 static const struct {
2073  int cid;
2074  UID codec_ul;
2075 } mxf_dnxhd_codec_uls[] = {
2076  { 1235, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x01,0x00,0x00 } }, // 1080p 10bit HIGH
2077  { 1237, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x03,0x00,0x00 } }, // 1080p 8bit MED
2078  { 1238, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x04,0x00,0x00 } }, // 1080p 8bit HIGH
2079  { 1241, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x07,0x00,0x00 } }, // 1080i 10bit HIGH
2080  { 1242, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x08,0x00,0x00 } }, // 1080i 8bit MED
2081  { 1243, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x09,0x00,0x00 } }, // 1080i 8bit HIGH
2082  { 1244, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x0a,0x00,0x00 } }, // 1080i 8bit TR
2083  { 1250, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x10,0x00,0x00 } }, // 720p 10bit
2084  { 1251, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x11,0x00,0x00 } }, // 720p 8bit HIGH
2085  { 1252, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x12,0x00,0x00 } }, // 720p 8bit MED
2086  { 1253, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x13,0x00,0x00 } }, // 720p 8bit LOW
2087  { 1256, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x16,0x00,0x00 } }, // 1080p 10bit 444
2088  { 1258, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x18,0x00,0x00 } }, // 720p 8bit TR
2089  { 1259, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x19,0x00,0x00 } }, // 1080p 8bit TR
2090  { 1260, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x1a,0x00,0x00 } }, // 1080i 8bit TR MBAFF
2091  { 1270, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x24,0x00,0x00 } }, // DNXHR 444
2092  { 1271, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x25,0x00,0x00 } }, // DNXHR HQX
2093  { 1272, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x26,0x00,0x00 } }, // DNXHR HQ
2094  { 1273, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x27,0x00,0x00 } }, // DNXHR SQ
2095  { 1274, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x28,0x00,0x00 } }, // DNXHR LB
2096 };
2097 
2099 {
2100  MXFContext *mxf = s->priv_data;
2101  MXFStreamContext *sc = st->priv_data;
2102  int i, cid, frame_size = 0;
2103 
2104  if (mxf->header_written)
2105  return 1;
2106 
2107  if (pkt->size < 43)
2108  return 0;
2109 
2110  sc->codec_ul = NULL;
2111  cid = AV_RB32(pkt->data + 0x28);
2112  for (i = 0; i < FF_ARRAY_ELEMS(mxf_dnxhd_codec_uls); i++) {
2113  if (cid == mxf_dnxhd_codec_uls[i].cid) {
2114  sc->codec_ul = &mxf_dnxhd_codec_uls[i].codec_ul;
2115  break;
2116  }
2117  }
2118  if (!sc->codec_ul)
2119  return 0;
2120 
2121  sc->component_depth = 0;
2122  switch (pkt->data[0x21] >> 5) {
2123  case 1: sc->component_depth = 8; break;
2124  case 2: sc->component_depth = 10; break;
2125  case 3: sc->component_depth = 12; break;
2126  }
2127  if (!sc->component_depth)
2128  return 0;
2129 
2130  if ((frame_size = avpriv_dnxhd_get_frame_size(cid)) == DNXHD_VARIABLE) {
2131  frame_size = avpriv_dnxhd_get_hr_frame_size(cid, st->codecpar->width, st->codecpar->height);
2132  }
2133  if (frame_size < 0)
2134  return 0;
2135 
2136  if ((sc->interlaced = avpriv_dnxhd_get_interlaced(cid)) < 0)
2137  return 0;
2138 
2139  if (cid >= 1270) { // RI raster
2141  st->codecpar->width, st->codecpar->height,
2142  INT_MAX);
2143  } else {
2144  sc->aspect_ratio = (AVRational){ 16, 9 };
2145  }
2146 
2147  sc->frame_size = pkt->size;
2148 
2149  return 1;
2150 }
2151 
2153 {
2154  MXFContext *mxf = s->priv_data;
2155  MXFStreamContext *sc = st->priv_data;
2156  uint8_t *vs_pack, *vsc_pack;
2157  int ul_index, stype, pal;
2158  const AVDVProfile *profile;
2159 
2160  if (mxf->header_written)
2161  return 1;
2162 
2163  // Check for minimal frame size
2164  if (pkt->size < 120000)
2165  return -1;
2166 
2167  profile = av_dv_frame_profile(NULL, pkt->data, pkt->size);
2168 
2169  vs_pack = pkt->data + 80*5 + 48;
2170  vsc_pack = pkt->data + 80*5 + 53;
2171  stype = vs_pack[3] & 0x1f;
2172  pal = (vs_pack[3] >> 5) & 0x1;
2173 
2174  if ((vsc_pack[2] & 0x07) == 0x02) {
2175  sc->aspect_ratio = (AVRational){ 16, 9 };
2176  } else {
2177  sc->aspect_ratio = (AVRational){ 4, 3 };
2178  }
2179 
2180  sc->interlaced = (vsc_pack[3] >> 4) & 0x01;
2181  // TODO: fix dv encoder to set proper FF/FS value in VSC pack
2182  // and set field dominance accordingly
2183  // av_log(s, AV_LOG_DEBUG, "DV vsc pack ff/ss = %x\n", vsc_pack[2] >> 6);
2184 
2185  switch (stype) {
2186  case 0x18: // DV100 720p
2187  ul_index = INDEX_DV100_720_50 + pal;
2188  if (sc->interlaced) {
2189  av_log(s, AV_LOG_ERROR, "source marked as interlaced but codec profile is progressive\n");
2190  sc->interlaced = 0;
2191  }
2192  break;
2193  case 0x14: // DV100 1080i
2194  ul_index = INDEX_DV100_1080_50 + pal;
2195  break;
2196  case 0x04: // DV50
2197  ul_index = INDEX_DV50_525_60 + pal;
2198  break;
2199  default: // DV25
2200  if (profile && profile->pix_fmt == AV_PIX_FMT_YUV420P && pal) {
2201  ul_index = INDEX_DV25_525_60_IEC + pal;
2202  break;
2203  }
2204  ul_index = INDEX_DV25_525_60 + pal;
2205  }
2206 
2207  sc->index = ul_index;
2208  sc->codec_ul = &mxf_essence_container_uls[sc->index].codec_ul;
2209  sc->frame_size = pkt->size;
2210 
2211  return 1;
2212 }
2213 
2214 static const struct {
2217  int profile;
2219  int intra_only; // 1 or 0 when there are separate UIDs for Long GOP and Intra, -1 when Intra/LGOP detection can be ignored
2220 } mxf_h264_codec_uls[] = {
2221  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x11,0x01 }, 0, 66, 0, -1 }, // AVC Baseline
2222  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x20,0x01 }, 0, 77, 0, -1 }, // AVC Main
2223  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x30,0x01 }, 0, 88, 0, -1 }, // AVC Extended
2224  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x40,0x01 }, 0, 100, 0, -1 }, // AVC High
2225  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x50,0x01 }, 0, 110, 0, 0 }, // AVC High 10
2226  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x60,0x01 }, 0, 122, 0, 0 }, // AVC High 422
2227  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x70,0x01 }, 0, 244, 0, 0 }, // AVC High 444
2228  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x20,0x01 }, 0, 110, 0, 1 }, // AVC High 10 Intra
2229  {{ 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
2230  {{ 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
2231  {{ 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
2232  {{ 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
2233  {{ 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
2234  {{ 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
2235  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x30,0x01 }, 0, 122, 0, 1 }, // AVC High 422 Intra
2236  {{ 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
2237  {{ 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
2238  {{ 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
2239  {{ 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
2240  {{ 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
2241  {{ 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
2242  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x01,0x32,0x40,0x01 }, 0, 244, 0, 1 }, // AVC High 444 Intra
2243  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x01,0x32,0x50,0x01 }, 0, 44, 0, -1 }, // AVC CAVLC 444
2244 };
2245 
2247  AVPacket *pkt, MXFIndexEntry *e)
2248 {
2249  MXFContext *mxf = s->priv_data;
2250  MXFStreamContext *sc = st->priv_data;
2252  GetBitContext gb;
2253  const uint8_t *buf = pkt->data;
2254  const uint8_t *buf_end = pkt->data + pkt->size;
2255  const uint8_t *nal_end;
2256  uint32_t state = -1;
2257  int extra_size = 512; // support AVC Intra files without SPS/PPS header
2258  int i, frame_size, slice_type, intra_only = 0;
2259 
2260  for (;;) {
2261  buf = avpriv_find_start_code(buf, buf_end, &state);
2262  if (buf >= buf_end)
2263  break;
2264 
2265  switch (state & 0x1f) {
2266  case H264_NAL_SPS:
2267  e->flags |= 0x40;
2268 
2269  if (mxf->header_written)
2270  break;
2271 
2272  nal_end = ff_avc_find_startcode(buf, buf_end);
2273  sps = ff_avc_decode_sps(buf, nal_end - buf);
2274  if (!sps) {
2275  av_log(s, AV_LOG_ERROR, "error parsing sps\n");
2276  return 0;
2277  }
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 (!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 (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  av_free(sps);
2352 
2353  if (!sc->codec_ul) {
2354  av_log(s, AV_LOG_ERROR, "h264 profile not supported\n");
2355  return 0;
2356  }
2357 
2358  return 1;
2359 }
2360 
2361 static const UID mxf_mpeg2_codec_uls[] = {
2362  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x10,0x00 }, // MP-ML I-Frame
2363  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x11,0x00 }, // MP-ML Long GOP
2364  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x02,0x00 }, // 422P-ML I-Frame
2365  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x03,0x00 }, // 422P-ML Long GOP
2366  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x02,0x00 }, // MP-HL I-Frame
2367  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x03,0x00 }, // MP-HL Long GOP
2368  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x02,0x00 }, // 422P-HL I-Frame
2369  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x03,0x00 }, // 422P-HL Long GOP
2370  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x05,0x02,0x00 }, // MP@H-14 I-Frame
2371  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x05,0x03,0x00 }, // MP@H-14 Long GOP
2372 };
2373 
2375 {
2376  int long_gop = 1;
2377 
2378  if (par->profile == 4) { // Main
2379  if (par->level == 8) // Main
2380  return &mxf_mpeg2_codec_uls[0+long_gop];
2381  else if (par->level == 4) // High
2382  return &mxf_mpeg2_codec_uls[4+long_gop];
2383  else if (par->level == 6) // High 14
2384  return &mxf_mpeg2_codec_uls[8+long_gop];
2385  } else if (par->profile == 0) { // 422
2386  if (par->level == 5) // Main
2387  return &mxf_mpeg2_codec_uls[2+long_gop];
2388  else if (par->level == 2) // High
2389  return &mxf_mpeg2_codec_uls[6+long_gop];
2390  }
2391  return NULL;
2392 }
2393 
2395  AVPacket *pkt, MXFIndexEntry *e)
2396 {
2397  MXFStreamContext *sc = st->priv_data;
2398  uint32_t c = -1;
2399  int i;
2400 
2401  for(i = 0; i < pkt->size - 4; i++) {
2402  c = (c<<8) + pkt->data[i];
2403  if (c == 0x1b5) {
2404  if ((pkt->data[i+1] & 0xf0) == 0x10) { // seq ext
2405  st->codecpar->profile = pkt->data[i+1] & 0x07;
2406  st->codecpar->level = pkt->data[i+2] >> 4;
2407  sc->low_delay = pkt->data[i+6] >> 7;
2408  } else if (i + 5 < pkt->size && (pkt->data[i+1] & 0xf0) == 0x80) { // pict coding ext
2409  sc->interlaced = !(pkt->data[i+5] & 0x80); // progressive frame
2410  if (sc->interlaced)
2411  sc->field_dominance = 1 + !(pkt->data[i+4] & 0x80); // top field first
2412  break;
2413  }
2414  } else if (c == 0x1b8) { // gop
2415  if (pkt->data[i+4]>>6 & 0x01) { // closed
2416  if (sc->seq_closed_gop == -1)
2417  sc->seq_closed_gop = 1;
2418  sc->closed_gop = 1;
2419  if (e->flags & 0x40) // sequence header present
2420  e->flags |= 0x80; // random access
2421  } else {
2422  sc->seq_closed_gop = 0;
2423  sc->closed_gop = 0;
2424  }
2425  } else if (c == 0x1b3) { // seq
2426  e->flags |= 0x40;
2427  switch ((pkt->data[i+4]>>4) & 0xf) {
2428  case 2: sc->aspect_ratio = (AVRational){ 4, 3}; break;
2429  case 3: sc->aspect_ratio = (AVRational){ 16, 9}; break;
2430  case 4: sc->aspect_ratio = (AVRational){221,100}; break;
2431  default:
2433  st->codecpar->width, st->codecpar->height, 1024*1024);
2434  }
2435  } else if (c == 0x100) { // pic
2436  int pict_type = (pkt->data[i+2]>>3) & 0x07;
2437  e->temporal_ref = (pkt->data[i+1]<<2) | (pkt->data[i+2]>>6);
2438  if (pict_type == 2) { // P-frame
2439  e->flags |= 0x22;
2440  sc->closed_gop = 0; // reset closed GOP, don't matter anymore
2441  } else if (pict_type == 3) { // B-frame
2442  if (sc->closed_gop)
2443  e->flags |= 0x13; // only backward prediction
2444  else
2445  e->flags |= 0x33;
2446  sc->temporal_reordering = -1;
2447  } else if (!pict_type) {
2448  av_log(s, AV_LOG_ERROR, "error parsing mpeg2 frame\n");
2449  return 0;
2450  }
2451  }
2452  }
2453  if (s->oformat != &ff_mxf_d10_muxer)
2455  return !!sc->codec_ul;
2456 }
2457 
2458 static uint64_t mxf_parse_timestamp(int64_t timestamp64)
2459 {
2460  time_t timestamp = timestamp64 / 1000000;
2461  struct tm tmbuf;
2462  struct tm *time = gmtime_r(&timestamp, &tmbuf);
2463  if (!time)
2464  return 0;
2465  return (uint64_t)(time->tm_year+1900) << 48 |
2466  (uint64_t)(time->tm_mon+1) << 40 |
2467  (uint64_t) time->tm_mday << 32 |
2468  time->tm_hour << 24 |
2469  time->tm_min << 16 |
2470  time->tm_sec << 8 |
2471  (timestamp64 % 1000000) / 4000;
2472 }
2473 
2475 {
2476  MXFContext *mxf = s->priv_data;
2477  uint32_t seed = av_get_random_seed();
2478  uint64_t umid = seed + 0x5294713400000000LL;
2479 
2480  AV_WB64(mxf->umid , umid);
2481  AV_WB64(mxf->umid+8, umid>>8);
2482 
2483  mxf->instance_number = seed & 0xFFFFFF;
2484 }
2485 
2487 {
2488  MXFContext *mxf = s->priv_data;
2489  AVDictionaryEntry *tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
2490  if (!tcr)
2491  tcr = av_dict_get(st->metadata, "timecode", NULL, 0);
2492 
2493  if (tcr)
2494  return av_timecode_init_from_string(&mxf->tc, rate, tcr->value, s);
2495  else
2496  return av_timecode_init(&mxf->tc, rate, 0, 0, s);
2497 }
2498 
2500 {
2501  MXFContext *mxf = s->priv_data;
2502  int i, ret;
2503  uint8_t present[FF_ARRAY_ELEMS(mxf_essence_container_uls)] = {0};
2504  const MXFSamplesPerFrame *spf = NULL;
2505  int64_t timestamp = 0;
2506 
2507  if (!s->nb_streams)
2508  return -1;
2509 
2510  if (s->oformat == &ff_mxf_opatom_muxer && s->nb_streams !=1) {
2511  av_log(s, AV_LOG_ERROR, "there must be exactly one stream for mxf opatom\n");
2512  return -1;
2513  }
2514 
2515  if (!av_dict_get(s->metadata, "comment_", NULL, AV_DICT_IGNORE_SUFFIX))
2516  mxf->store_user_comments = 0;
2517 
2518  for (i = 0; i < s->nb_streams; i++) {
2519  AVStream *st = s->streams[i];
2520  MXFStreamContext *sc = av_mallocz(sizeof(*sc));
2521  if (!sc)
2522  return AVERROR(ENOMEM);
2523  st->priv_data = sc;
2524 
2525  if (((i == 0) ^ (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)) && s->oformat != &ff_mxf_opatom_muxer) {
2526  av_log(s, AV_LOG_ERROR, "there must be exactly one video stream and it must be the first one\n");
2527  return -1;
2528  }
2529 
2530  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2531  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(st->codecpar->format);
2532  // TODO: should be avg_frame_rate
2533  AVRational rate, tbc = st->time_base;
2534  // Default component depth to 8
2535  sc->component_depth = 8;
2536  sc->h_chroma_sub_sample = 2;
2537  sc->v_chroma_sub_sample = 2;
2538  sc->color_siting = 0xFF;
2539 
2542  av_make_q(st->codecpar->width, st->codecpar->height));
2543  }
2544 
2545  if (pix_desc) {
2546  sc->component_depth = pix_desc->comp[0].depth;
2547  sc->h_chroma_sub_sample = 1 << pix_desc->log2_chroma_w;
2548  sc->v_chroma_sub_sample = 1 << pix_desc->log2_chroma_h;
2549  }
2550  switch (ff_choose_chroma_location(s, st)) {
2551  case AVCHROMA_LOC_TOPLEFT: sc->color_siting = 0; break;
2552  case AVCHROMA_LOC_LEFT: sc->color_siting = 6; break;
2553  case AVCHROMA_LOC_TOP: sc->color_siting = 1; break;
2554  case AVCHROMA_LOC_CENTER: sc->color_siting = 3; break;
2555  }
2556 
2557  mxf->timecode_base = (tbc.den + tbc.num/2) / tbc.num;
2558  spf = ff_mxf_get_samples_per_frame(s, tbc);
2559  if (!spf) {
2560  av_log(s, AV_LOG_ERROR, "Unsupported video frame rate %d/%d\n",
2561  tbc.den, tbc.num);
2562  return AVERROR(EINVAL);
2563  }
2565  mxf->time_base = spf->time_base;
2566  rate = av_inv_q(mxf->time_base);
2567  avpriv_set_pts_info(st, 64, mxf->time_base.num, mxf->time_base.den);
2568  if((ret = mxf_init_timecode(s, st, rate)) < 0)
2569  return ret;
2570 
2572  sc->seq_closed_gop = -1; // unknown yet
2573  }
2574 
2575  sc->video_bit_rate = st->codecpar->bit_rate;
2576 
2577  if (s->oformat == &ff_mxf_d10_muxer ||
2580  mxf->cbr_index = 1;
2581 
2582  if (s->oformat == &ff_mxf_d10_muxer) {
2584  av_log(s, AV_LOG_ERROR, "error MXF D-10 only support MPEG-2 Video\n");
2585  return AVERROR(EINVAL);
2586  }
2587  if ((sc->video_bit_rate == 50000000) && (mxf->time_base.den == 25)) {
2589  } else if ((sc->video_bit_rate == 49999840 || sc->video_bit_rate == 50000000) && (mxf->time_base.den != 25)) {
2591  } else if (sc->video_bit_rate == 40000000) {
2592  if (mxf->time_base.den == 25) sc->index = INDEX_D10_625_50_40_VIDEO;
2593  else sc->index = INDEX_D10_525_60_40_VIDEO;
2594  } else if (sc->video_bit_rate == 30000000) {
2595  if (mxf->time_base.den == 25) sc->index = INDEX_D10_625_50_30_VIDEO;
2596  else sc->index = INDEX_D10_525_60_30_VIDEO;
2597  } else {
2598  av_log(s, AV_LOG_ERROR, "error MXF D-10 only support 30/40/50 mbit/s\n");
2599  return -1;
2600  }
2601 
2602  sc->signal_standard = 1;
2603  sc->color_siting = 0;
2604  sc->frame_size = (int64_t)sc->video_bit_rate *
2605  mxf->time_base.num / (8*mxf->time_base.den);
2606  }
2607  if (mxf->signal_standard >= 0)
2608  sc->signal_standard = mxf->signal_standard;
2609  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2610  if (st->codecpar->sample_rate != 48000) {
2611  av_log(s, AV_LOG_ERROR, "only 48khz is implemented\n");
2612  return -1;
2613  }
2614  avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
2615  if (s->oformat == &ff_mxf_d10_muxer) {
2616  if (st->index != 1) {
2617  av_log(s, AV_LOG_ERROR, "MXF D-10 only support one audio track\n");
2618  return -1;
2619  }
2620  if (st->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE &&
2622  av_log(s, AV_LOG_ERROR, "MXF D-10 only support 16 or 24 bits le audio\n");
2623  }
2624  sc->index = ((MXFStreamContext*)s->streams[0]->priv_data)->index + 1;
2625  sc->frame_size = 4 + 8 * spf[0].samples_per_frame[0] * 4;
2626  } else if (s->oformat == &ff_mxf_opatom_muxer) {
2627  AVRational tbc = av_inv_q(mxf->audio_edit_rate);
2628 
2629  if (st->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE &&
2631  av_log(s, AV_LOG_ERROR, "Only pcm_s16le and pcm_s24le audio codecs are implemented\n");
2632  return AVERROR_PATCHWELCOME;
2633  }
2634  if (st->codecpar->channels != 1) {
2635  av_log(s, AV_LOG_ERROR, "MXF OPAtom only supports single channel audio\n");
2636  return AVERROR(EINVAL);
2637  }
2638 
2639  spf = ff_mxf_get_samples_per_frame(s, tbc);
2640  if (!spf) {
2641  av_log(s, AV_LOG_ERROR, "Unsupported timecode frame rate %d/%d\n", tbc.den, tbc.num);
2642  return AVERROR(EINVAL);
2643  }
2644 
2645  mxf->time_base = st->time_base;
2646  if((ret = mxf_init_timecode(s, st, av_inv_q(spf->time_base))) < 0)
2647  return ret;
2648 
2649  mxf->timecode_base = (tbc.den + tbc.num/2) / tbc.num;
2651  sc->index = INDEX_WAV;
2652  } else {
2653  mxf->slice_count = 1;
2654  sc->frame_size = (st->codecpar->channels * spf[0].samples_per_frame[0] *
2656  }
2657  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2658  AVDictionaryEntry *e = av_dict_get(st->metadata, "data_type", NULL, 0);
2659  if (e && !strcmp(e->value, "vbi_vanc_smpte_436M")) {
2660  sc->index = INDEX_S436M;
2661  } else {
2662  av_log(s, AV_LOG_ERROR, "track %d: unsupported data type\n", i);
2663  return -1;
2664  }
2665  if (st->index != s->nb_streams - 1) {
2666  av_log(s, AV_LOG_ERROR, "data track must be placed last\n");
2667  return -1;
2668  }
2669  }
2670 
2671  if (!sc->index) {
2673  if (sc->index == -1) {
2674  av_log(s, AV_LOG_ERROR, "track %d: could not find essence container ul, "
2675  "codec not currently supported in container\n", i);
2676  return -1;
2677  }
2678  }
2679 
2680  sc->codec_ul = &mxf_essence_container_uls[sc->index].codec_ul;
2681 
2682  memcpy(sc->track_essence_element_key, mxf_essence_container_uls[sc->index].element_ul, 15);
2683  sc->track_essence_element_key[15] = present[sc->index];
2684  PRINT_KEY(s, "track essence element key", sc->track_essence_element_key);
2685 
2686  if (!present[sc->index])
2687  mxf->essence_container_count++;
2688  present[sc->index]++;
2689  }
2690 
2691  if (s->oformat == &ff_mxf_d10_muxer || s->oformat == &ff_mxf_opatom_muxer) {
2692  mxf->essence_container_count = 1;
2693  }
2694 
2695  if (!(s->flags & AVFMT_FLAG_BITEXACT))
2696  mxf_gen_umid(s);
2697 
2698  for (i = 0; i < s->nb_streams; i++) {
2699  MXFStreamContext *sc = s->streams[i]->priv_data;
2700  // update element count
2701  sc->track_essence_element_key[13] = present[sc->index];
2702  if (!memcmp(sc->track_essence_element_key, mxf_essence_container_uls[15].element_ul, 13)) // DV
2703  sc->order = (0x15 << 24) | AV_RB32(sc->track_essence_element_key+13);
2704  else
2705  sc->order = AV_RB32(sc->track_essence_element_key+12);
2706  }
2707 
2708  if (ff_parse_creation_time_metadata(s, &timestamp, 0) > 0)
2709  mxf->timestamp = mxf_parse_timestamp(timestamp);
2710  mxf->duration = -1;
2711 
2712  mxf->timecode_track = av_mallocz(sizeof(*mxf->timecode_track));
2713  if (!mxf->timecode_track)
2714  return AVERROR(ENOMEM);
2716  if (!mxf->timecode_track->priv_data)
2717  return AVERROR(ENOMEM);
2718  mxf->timecode_track->index = -1;
2719 
2720  if (!spf)
2721  spf = ff_mxf_get_samples_per_frame(s, (AVRational){ 1, 25 });
2722 
2723  if (ff_audio_interleave_init(s, spf->samples_per_frame, mxf->time_base) < 0)
2724  return -1;
2725 
2726  return 0;
2727 }
2728 
2729 static const uint8_t system_metadata_pack_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04,0x01,0x01,0x00 };
2730 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 };
2731 
2733 {
2734  MXFContext *mxf = s->priv_data;
2735  AVIOContext *pb = s->pb;
2736  unsigned frame;
2737  uint32_t time_code;
2738  int i, system_item_bitmap = 0x58; // UL, user date/time stamp, picture present
2739 
2740  frame = mxf->last_indexed_edit_unit + mxf->edit_units_count;
2741 
2742  // write system metadata pack
2744  klv_encode_ber4_length(pb, 57);
2745 
2746  for (i = 0; i < s->nb_streams; i++) {
2748  system_item_bitmap |= 0x4;
2749  else if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2750  system_item_bitmap |= 0x2;
2751  }
2752  avio_w8(pb, system_item_bitmap);
2753  avio_w8(pb, mxf->content_package_rate); // content package rate
2754  avio_w8(pb, 0x00); // content package type
2755  avio_wb16(pb, 0x00); // channel handle
2756  avio_wb16(pb, (mxf->tc.start + frame) & 0xFFFF); // continuity count, supposed to overflow
2757  if (mxf->essence_container_count > 1)
2758  avio_write(pb, multiple_desc_ul, 16);
2759  else {
2760  MXFStreamContext *sc = s->streams[0]->priv_data;
2761  avio_write(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
2762  }
2763  avio_w8(pb, 0);
2764  avio_wb64(pb, 0);
2765  avio_wb64(pb, 0); // creation date/time stamp
2766 
2767  avio_w8(pb, 0x81); // SMPTE 12M time code
2768  time_code = av_timecode_get_smpte_from_framenum(&mxf->tc, frame);
2769  avio_wb32(pb, time_code);
2770  avio_wb32(pb, 0); // binary group data
2771  avio_wb64(pb, 0);
2772 
2773  // write system metadata package set
2775  klv_encode_ber4_length(pb, 35);
2776  avio_w8(pb, 0x83); // UMID
2777  avio_wb16(pb, 0x20);
2778  mxf_write_umid(s, 1);
2779 }
2780 
2782 {
2783  MXFContext *mxf = s->priv_data;
2784  AVIOContext *pb = s->pb;
2785  int frame_size = pkt->size / st->codecpar->block_align;
2786  uint8_t *samples = pkt->data;
2787  uint8_t *end = pkt->data + pkt->size;
2788  int i;
2789 
2790  klv_encode_ber4_length(pb, 4 + frame_size*4*8);
2791 
2792  avio_w8(pb, (frame_size == 1920 ? 0 : (mxf->edit_units_count-1) % 5 + 1));
2793  avio_wl16(pb, frame_size);
2794  avio_w8(pb, (1<<st->codecpar->channels)-1);
2795 
2796  while (samples < end) {
2797  for (i = 0; i < st->codecpar->channels; i++) {
2798  uint32_t sample;
2799  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE) {
2800  sample = AV_RL24(samples)<< 4;
2801  samples += 3;
2802  } else {
2803  sample = AV_RL16(samples)<<12;
2804  samples += 2;
2805  }
2806  avio_wl32(pb, sample | i);
2807  }
2808  for (; i < 8; i++)
2809  avio_wl32(pb, i);
2810  }
2811 }
2812 
2814 {
2815  MXFContext *mxf = s->priv_data;
2816  AVIOContext *pb = s->pb;
2817  AVStream *st = s->streams[0];
2818  MXFStreamContext *sc = st->priv_data;
2819  const uint8_t *key = NULL;
2820 
2821  int err;
2822 
2823  if (!mxf->header_written)
2824  key = body_partition_key;
2825 
2826  if ((err = mxf_write_partition(s, 1, 0, key, 0)) < 0)
2827  return err;
2828  mxf_write_klv_fill(s);
2831  return 0;
2832 }
2833 
2835 {
2836  MXFContext *mxf = s->priv_data;
2837  AVIOContext *pb = s->pb;
2838 
2839  int err;
2840 
2841  if (!mxf->header_written) {
2842  if ((err = mxf_write_partition(s, 0, 0, header_open_partition_key, 1)) < 0)
2843  return err;
2844  mxf_write_klv_fill(s);
2845 
2846  if ((err = mxf_write_opatom_body_partition(s)) < 0)
2847  return err;
2848  mxf->header_written = 1;
2849  }
2850 
2851  if (!mxf->edit_unit_byte_count) {
2853  mxf->index_entries[mxf->edit_units_count].flags = ie->flags;
2855  }
2856  mxf->edit_units_count++;
2857  avio_write(pb, pkt->data, pkt->size);
2858  mxf->body_offset += pkt->size;
2859  avio_flush(pb);
2860 
2861  return 0;
2862 }
2863 
2865 {
2866  MXFContext *mxf = s->priv_data;
2867  int i;
2868 
2869  if (s->oformat == &ff_mxf_opatom_muxer) {
2870  MXFStreamContext *sc = s->streams[0]->priv_data;
2871  mxf->edit_unit_byte_count = sc->frame_size;
2872  return;
2873  }
2874 
2875  mxf->edit_unit_byte_count = KAG_SIZE; // system element
2876  for (i = 0; i < s->nb_streams; i++) {
2877  AVStream *st = s->streams[i];
2878  MXFStreamContext *sc = st->priv_data;
2880  mxf->edit_unit_byte_count += 16 + 4 + sc->frame_size;
2882  }
2883 }
2884 
2886 {
2887  MXFContext *mxf = s->priv_data;
2888  AVIOContext *pb = s->pb;
2889  AVStream *st = s->streams[pkt->stream_index];
2890  MXFStreamContext *sc = st->priv_data;
2891  MXFIndexEntry ie = {0};
2892  int err;
2893 
2894  if (!mxf->cbr_index && !mxf->edit_unit_byte_count && !(mxf->edit_units_count % EDIT_UNITS_PER_BODY)) {
2895  if ((err = av_reallocp_array(&mxf->index_entries, mxf->edit_units_count
2896  + EDIT_UNITS_PER_BODY, sizeof(*mxf->index_entries))) < 0) {
2897  mxf->edit_units_count = 0;
2898  av_log(s, AV_LOG_ERROR, "could not allocate index entries\n");
2899  return err;
2900  }
2901  }
2902 
2904  if (!mxf_parse_mpeg2_frame(s, st, pkt, &ie)) {
2905  av_log(s, AV_LOG_ERROR, "could not get mpeg2 profile and level\n");
2906  return -1;
2907  }
2908  } else if (st->codecpar->codec_id == AV_CODEC_ID_DNXHD) {
2909  if (!mxf_parse_dnxhd_frame(s, st, pkt)) {
2910  av_log(s, AV_LOG_ERROR, "could not get dnxhd profile\n");
2911  return -1;
2912  }
2913  } else if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2914  if (!mxf_parse_prores_frame(s, st, pkt)) {
2915  av_log(s, AV_LOG_ERROR, "could not get prores profile\n");
2916  return -1;
2917  }
2918  } else if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO) {
2919  if (!mxf_parse_dv_frame(s, st, pkt)) {
2920  av_log(s, AV_LOG_ERROR, "could not get dv profile\n");
2921  return -1;
2922  }
2923  } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2924  if (!mxf_parse_h264_frame(s, st, pkt, &ie)) {
2925  av_log(s, AV_LOG_ERROR, "could not get h264 profile\n");
2926  return -1;
2927  }
2928  }
2929 
2930  if (mxf->cbr_index) {
2931  if (pkt->size != sc->frame_size && st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2932  av_log(s, AV_LOG_ERROR, "track %d: frame size does not match index unit size, %d != %d\n",
2933  st->index, pkt->size, sc->frame_size);
2934  return -1;
2935  }
2936  if (!mxf->header_written)
2938  }
2939 
2940  if (s->oformat == &ff_mxf_opatom_muxer)
2941  return mxf_write_opatom_packet(s, pkt, &ie);
2942 
2943  if (!mxf->header_written) {
2944  if (mxf->edit_unit_byte_count) {
2945  if ((err = mxf_write_partition(s, 1, 2, header_open_partition_key, 1)) < 0)
2946  return err;
2947  mxf_write_klv_fill(s);
2949  } else {
2950  if ((err = mxf_write_partition(s, 0, 0, header_open_partition_key, 1)) < 0)
2951  return err;
2952  }
2953  mxf->header_written = 1;
2954  }
2955 
2956  if (st->index == 0) {
2957  if (!mxf->edit_unit_byte_count &&
2959  !(ie.flags & 0x33)) { // I-frame, GOP start
2960  mxf_write_klv_fill(s);
2961  if ((err = mxf_write_partition(s, 1, 2, body_partition_key, 0)) < 0)
2962  return err;
2963  mxf_write_klv_fill(s);
2965  }
2966 
2967  mxf_write_klv_fill(s);
2969 
2970  if (!mxf->edit_unit_byte_count) {
2972  mxf->index_entries[mxf->edit_units_count].flags = ie.flags;
2974  mxf->body_offset += KAG_SIZE; // size of system element
2975  }
2976  mxf->edit_units_count++;
2977  } else if (!mxf->edit_unit_byte_count && st->index == 1) {
2978  if (!mxf->edit_units_count) {
2979  av_log(s, AV_LOG_ERROR, "No packets in first stream\n");
2980  return AVERROR_PATCHWELCOME;
2981  }
2983  mxf->body_offset - mxf->index_entries[mxf->edit_units_count-1].offset;
2984  }
2985 
2986  mxf_write_klv_fill(s);
2987  avio_write(pb, sc->track_essence_element_key, 16); // write key
2988  if (s->oformat == &ff_mxf_d10_muxer &&
2990  mxf_write_d10_audio_packet(s, st, pkt);
2991  } else {
2992  klv_encode_ber4_length(pb, pkt->size); // write length
2993  avio_write(pb, pkt->data, pkt->size);
2994  mxf->body_offset += 16+4+pkt->size + klv_fill_size(16+4+pkt->size);
2995  }
2996 
2997  avio_flush(pb);
2998 
2999  return 0;
3000 }
3001 
3003 {
3004  MXFContext *mxf = s->priv_data;
3005  AVIOContext *pb = s->pb;
3006  uint64_t pos = avio_tell(pb);
3007  int i;
3008 
3010  klv_encode_ber_length(pb, 28 + 12LL*mxf->body_partitions_count);
3011 
3012  if (mxf->edit_unit_byte_count && s->oformat != &ff_mxf_opatom_muxer)
3013  avio_wb32(pb, 1); // BodySID of header partition
3014  else
3015  avio_wb32(pb, 0);
3016  avio_wb64(pb, 0); // offset of header partition
3017 
3018  for (i = 0; i < mxf->body_partitions_count; i++) {
3019  avio_wb32(pb, 1); // BodySID
3020  avio_wb64(pb, mxf->body_partition_offset[i]);
3021  }
3022 
3023  avio_wb32(pb, 0); // BodySID of footer partition
3025 
3026  avio_wb32(pb, avio_tell(pb) - pos + 4);
3027 }
3028 
3030 {
3031  MXFContext *mxf = s->priv_data;
3032  AVIOContext *pb = s->pb;
3033  int i, err = 0;
3034 
3035  if (!mxf->header_written ||
3036  (s->oformat == &ff_mxf_opatom_muxer && !mxf->body_partition_offset)) {
3037  /* reason could be invalid options/not supported codec/out of memory */
3038  err = AVERROR_UNKNOWN;
3039  goto end;
3040  }
3041 
3043 
3044  mxf_write_klv_fill(s);
3046  if (mxf->edit_unit_byte_count && s->oformat != &ff_mxf_opatom_muxer) { // no need to repeat index
3047  if ((err = mxf_write_partition(s, 0, 0, footer_partition_key, 0)) < 0)
3048  goto end;
3049  } else {
3050  if ((err = mxf_write_partition(s, 0, 2, footer_partition_key, 0)) < 0)
3051  goto end;
3052  mxf_write_klv_fill(s);
3054  }
3055 
3056  mxf_write_klv_fill(s);
3058 
3059  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
3060  if (s->oformat == &ff_mxf_opatom_muxer) {
3061  /* rewrite body partition to update lengths */
3062  avio_seek(pb, mxf->body_partition_offset[0], SEEK_SET);
3063  if ((err = mxf_write_opatom_body_partition(s)) < 0)
3064  goto end;
3065  }
3066 
3067  avio_seek(pb, 0, SEEK_SET);
3068  if (mxf->edit_unit_byte_count && s->oformat != &ff_mxf_opatom_muxer) {
3069  if ((err = mxf_write_partition(s, 1, 2, header_closed_partition_key, 1)) < 0)
3070  goto end;
3071  mxf_write_klv_fill(s);
3073  } else {
3074  if ((err = mxf_write_partition(s, 0, 0, header_closed_partition_key, 1)) < 0)
3075  goto end;
3076  }
3077  // update footer partition offset
3078  for (i = 0; i < mxf->body_partitions_count; i++) {
3079  avio_seek(pb, mxf->body_partition_offset[i]+44, SEEK_SET);
3081  }
3082  }
3083 
3084 end:
3086 
3087  av_freep(&mxf->index_entries);
3090  av_freep(&mxf->timecode_track);
3091 
3092  mxf_free(s);
3093 
3094  return err < 0 ? err : 0;
3095 }
3096 
3098 {
3099  int i, stream_count = 0;
3100 
3101  for (i = 0; i < s->nb_streams; i++)
3102  stream_count += !!s->streams[i]->last_in_packet_buffer;
3103 
3104  if (stream_count && (s->nb_streams == stream_count || flush)) {
3105  AVPacketList *pktl = s->internal->packet_buffer;
3106  if (s->nb_streams != stream_count) {
3107  AVPacketList *last = NULL;
3108  // find last packet in edit unit
3109  while (pktl) {
3110  if (!stream_count || pktl->pkt.stream_index == 0)
3111  break;
3112  // update last packet in packet buffer
3113  if (s->streams[pktl->pkt.stream_index]->last_in_packet_buffer != pktl)
3114  s->streams[pktl->pkt.stream_index]->last_in_packet_buffer = pktl;
3115  last = pktl;
3116  pktl = pktl->next;
3117  stream_count--;
3118  }
3119  // purge packet queue
3120  while (pktl) {
3121  AVPacketList *next = pktl->next;
3122  av_packet_unref(&pktl->pkt);
3123  av_freep(&pktl);
3124  pktl = next;
3125  }
3126  if (last)
3127  last->next = NULL;
3128  else {
3129  s->internal->packet_buffer = NULL;
3131  goto out;
3132  }
3133  pktl = s->internal->packet_buffer;
3134  }
3135 
3136  *out = pktl->pkt;
3137  av_log(s, AV_LOG_TRACE, "out st:%d dts:%"PRId64"\n", (*out).stream_index, (*out).dts);
3138  s->internal->packet_buffer = pktl->next;
3139  if(s->streams[pktl->pkt.stream_index]->last_in_packet_buffer == pktl)
3141  if(!s->internal->packet_buffer)
3143  av_freep(&pktl);
3144  return 1;
3145  } else {
3146  out:
3147  av_init_packet(out);
3148  return 0;
3149  }
3150 }
3151 
3153 {
3155  MXFStreamContext *sc2 = s->streams[next->stream_index]->priv_data;
3156 
3157  return next->dts > pkt->dts ||
3158  (next->dts == pkt->dts && sc->order < sc2->order);
3159 }
3160 
3162 {
3163  return ff_audio_rechunk_interleave(s, out, pkt, flush,
3165 }
3166 
3167 #define MXF_COMMON_OPTIONS \
3168  { "signal_standard", "Force/set Signal Standard",\
3169  offsetof(MXFContext, signal_standard), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3170  { "bt601", "ITU-R BT.601 and BT.656, also SMPTE 125M (525 and 625 line interlaced)",\
3171  0, AV_OPT_TYPE_CONST, {.i64 = 1}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3172  { "bt1358", "ITU-R BT.1358 and ITU-R BT.799-3, also SMPTE 293M (525 and 625 line progressive)",\
3173  0, AV_OPT_TYPE_CONST, {.i64 = 2}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3174  { "smpte347m", "SMPTE 347M (540 Mbps mappings)",\
3175  0, AV_OPT_TYPE_CONST, {.i64 = 3}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3176  { "smpte274m", "SMPTE 274M (1125 line)",\
3177  0, AV_OPT_TYPE_CONST, {.i64 = 4}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3178  { "smpte296m", "SMPTE 296M (750 line progressive)",\
3179  0, AV_OPT_TYPE_CONST, {.i64 = 5}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3180  { "smpte349m", "SMPTE 349M (1485 Mbps mappings)",\
3181  0, AV_OPT_TYPE_CONST, {.i64 = 6}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3182  { "smpte428", "SMPTE 428-1 DCDM",\
3183  0, AV_OPT_TYPE_CONST, {.i64 = 7}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},
3184 
3185 
3186 
3187 static const AVOption mxf_options[] = {
3189  { "store_user_comments", "",
3190  offsetof(MXFContext, store_user_comments), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
3191  { NULL },
3192 };
3193 
3194 static const AVClass mxf_muxer_class = {
3195  .class_name = "MXF muxer",
3196  .item_name = av_default_item_name,
3197  .option = mxf_options,
3198  .version = LIBAVUTIL_VERSION_INT,
3199 };
3200 
3201 static const AVOption d10_options[] = {
3202  { "d10_channelcount", "Force/set channelcount in generic sound essence descriptor",
3203  offsetof(MXFContext, channel_count), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 8, AV_OPT_FLAG_ENCODING_PARAM},
3205  { "store_user_comments", "",
3206  offsetof(MXFContext, store_user_comments), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
3207  { NULL },
3208 };
3209 
3211  .class_name = "MXF-D10 muxer",
3212  .item_name = av_default_item_name,
3213  .option = d10_options,
3214  .version = LIBAVUTIL_VERSION_INT,
3215 };
3216 
3217 static const AVOption opatom_options[] = {
3218  { "mxf_audio_edit_rate", "Audio edit rate for timecode",
3219  offsetof(MXFContext, audio_edit_rate), AV_OPT_TYPE_RATIONAL, {.dbl=25}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
3221  { "store_user_comments", "",
3222  offsetof(MXFContext, store_user_comments), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
3223  { NULL },
3224 };
3225 
3227  .class_name = "MXF-OPAtom muxer",
3228  .item_name = av_default_item_name,
3229  .option = opatom_options,
3230  .version = LIBAVUTIL_VERSION_INT,
3231 };
3232 
3234  .name = "mxf",
3235  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3236  .mime_type = "application/mxf",
3237  .extensions = "mxf",
3238  .priv_data_size = sizeof(MXFContext),
3239  .audio_codec = AV_CODEC_ID_PCM_S16LE,
3240  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
3246  .priv_class = &mxf_muxer_class,
3247 };
3248 
3249 AVOutputFormat ff_mxf_d10_muxer = {
3250  .name = "mxf_d10",
3251  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format) D-10 Mapping"),
3252  .mime_type = "application/mxf",
3253  .priv_data_size = sizeof(MXFContext),
3254  .audio_codec = AV_CODEC_ID_PCM_S16LE,
3255  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
3261  .priv_class = &mxf_d10_muxer_class,
3262 };
3263 
3264 AVOutputFormat ff_mxf_opatom_muxer = {
3265  .name = "mxf_opatom",
3266  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format) Operational Pattern Atom"),
3267  .mime_type = "application/mxf",
3268  .extensions = "mxf",
3269  .priv_data_size = sizeof(MXFContext),
3270  .audio_codec = AV_CODEC_ID_PCM_S16LE,
3271  .video_codec = AV_CODEC_ID_DNXHD,
3277  .priv_class = &mxf_opatom_muxer_class,
3278 };
int cid
Definition: mxfenc.c:2073
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:689
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:463
uint32_t tagged_value_count
Definition: mxfenc.c:359
#define NULL
Definition: coverity.c:32
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:4034
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:469
MXFMetadataSetType
Definition: mxf.h:30
Bytestream IO Context.
Definition: avio.h:161
enum AVColorTransferCharacteristic color_trc
Definition: avcodec.h:4041
static int mxf_utf16_local_tag_length(const char *utf8_str)
Definition: mxfenc.c:780
int component_depth
Definition: mxfenc.c:89
static const uint8_t header_closed_partition_key[]
Definition: mxfenc.c:379
#define GET_UTF8(val, GET_BYTE, ERROR)
Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
Definition: common.h:385
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:543
int signal_standard
Definition: mxfenc.c:91
const uint8_t * ff_avc_find_startcode(const uint8_t *p, const uint8_t *end)
Definition: avc.c:66
int avio_put_str16be(AVIOContext *s, const char *str)
Convert an UTF-8 string to UTF-16BE and write it.
AVOption.
Definition: opt.h:246
static void flush(AVCodecContext *avctx)
"Linear transfer characteristics"
Definition: pixfmt.h:476
static void mxf_write_index_table_segment(AVFormatContext *s)
Definition: mxfenc.c:1771
enum AVCodecID id
Definition: mxfenc.c:156
uint64_t body_offset
Definition: mxfenc.c:354
static void mxf_write_timecode_component(AVFormatContext *s, AVStream *st, MXFPackage *package)
Definition: mxfenc.c:1001
#define PRINT_KEY(pc, s, x)
Definition: mxf.h:129
static const uint8_t klv_fill_key[]
Definition: mxfenc.c:380
static const UID mxf_mpegvideo_descriptor_key
Definition: mxfenc.c:1154
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
unsigned char * buf_ptr
Current position in the buffer.
Definition: avio.h:228
static void klv_encode_ber9_length(AVIOContext *pb, uint64_t len)
Definition: mxfenc.c:580
void(* write_desc)(AVFormatContext *, AVStream *)
Definition: mxfenc.c:111
int index
index in mxf_essence_container_uls table
Definition: mxfenc.c:84
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4882
UID codec_ul
Definition: mxfenc.c:2037
AVRational sample_aspect_ratio
Video only.
Definition: avcodec.h:4029
unsigned body_partitions_count
Definition: mxfenc.c:346
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3953
const int * samples
current samples per frame, pointer to samples_per_frame
int num
Numerator.
Definition: rational.h:59
static int mxf_init_timecode(AVFormatContext *s, AVStream *st, AVRational rate)
Definition: mxfenc.c:2486
int index
stream index in AVFormatContext
Definition: avformat.h:882
int size
Definition: avcodec.h:1478
Definition: mxf.h:34
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
static const UID mxf_cdci_descriptor_key
Definition: mxfenc.c:1157
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1811
int interlaced
whether picture is interlaced
Definition: mxfenc.c:87
int av_log2(unsigned v)
Definition: intmath.c:26
static const uint8_t body_partition_key[]
Definition: mxfenc.c:381
static int get_trc(UID ul, enum AVColorTransferCharacteristic trc)
Definition: mxfenc.c:1162
static int64_t mxf_write_generic_sound_common(AVFormatContext *s, AVStream *st, const UID key)
Definition: mxfenc.c:1462
AVOutputFormat ff_mxf_muxer
Definition: mxfenc.c:3233
static void mxf_update_klv_size(AVIOContext *pb, int64_t pos)
Definition: mxfenc.c:1363
#define FF_PROFILE_PRORES_LT
Definition: avcodec.h:3000
GLint GLenum type
Definition: opengl_enc.c:104
int avpriv_dnxhd_get_interlaced(int cid)
Definition: dnxhddata.c:1108
static void mxf_write_s436m_anc_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1418
void * priv_data
Definition: avformat.h:896
const char * key
int version
Definition: avisynth_c.h:858
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
static void mxf_write_sequence(AVFormatContext *s, AVStream *st, MXFPackage *package)
Definition: mxfenc.c:974
static AVPacket pkt
struct AVRational time_base
Definition: mxf.h:86
uint8_t level_idc
Definition: avc.h:42
static void mxf_free(AVFormatContext *s)
Definition: mxfenc.c:656
static void mxf_write_uuid(AVIOContext *pb, enum MXFMetadataSetType type, int value)
Definition: mxfenc.c:523
#define sample
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
UID track_essence_element_key
Definition: mxfenc.c:83
static void mxf_write_common_fields(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:950
uint8_t bit_depth_luma
Definition: avc.h:45
#define FF_PROFILE_PRORES_XQ
Definition: avcodec.h:3004
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
int id
Definition: mxf.h:79
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3945
static const UID mxf_s436m_anc_descriptor_key
Definition: mxfenc.c:1153
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:467
static int mxf_write_header(AVFormatContext *s)
Definition: mxfenc.c:2499
static void klv_encode_ber4_length(AVIOContext *pb, int len)
Definition: mxfenc.c:574
static const uint8_t multiple_desc_ul[]
Definition: mxfenc.c:387
Format I/O context.
Definition: avformat.h:1358
int h_chroma_sub_sample
Definition: mxfenc.c:92
uint8_t UID[16]
Definition: mxf.h:28
int temporal_reordering
Definition: mxfenc.c:94
#define gmtime_r
Definition: time_internal.h:34
uint8_t slice_count
index slice count minus 1 (1 if no audio, 0 otherwise)
Definition: mxfenc.c:343
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define AV_WB64(p, v)
Definition: intreadwrite.h:433
static const UID mxf_generic_sound_descriptor_key
Definition: mxfenc.c:1158
static const struct @268 mxf_h264_codec_uls[]
static int klv_encode_ber_length(AVIOContext *pb, uint64_t len)
Definition: mxfenc.c:553
static void mxf_write_klv_fill(AVFormatContext *s)
Definition: mxfenc.c:1917
static void mxf_write_refs_count(AVIOContext *pb, int ref_count)
Definition: mxfenc.c:539
int timecode_base
rounded time code base (25 or 30)
Definition: mxfenc.c:351
int av_timecode_init_from_string(AVTimecode *tc, AVRational rate, const char *str, void *log_ctx)
Parse timecode representation (hh:mm:ss[:;.
Definition: timecode.c:194
static void mxf_write_structural_component(AVFormatContext *s, AVStream *st, MXFPackage *package)
Definition: mxfenc.c:1028
static int mxf_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mxfenc.c:2885
static void mxf_write_avc_subdesc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1372
AVOutputFormat ff_mxf_d10_muxer
Definition: mxfenc.c:3249
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:369
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
static unsigned klv_fill_size(uint64_t size)
Definition: mxfenc.c:1762
uint8_t
const MXFSamplesPerFrame * ff_mxf_get_samples_per_frame(AVFormatContext *s, AVRational time_base)
Definition: mxf.c:155
Opaque data information usually continuous.
Definition: avutil.h:203
int width
Video only.
Definition: avcodec.h:4019
AVOptions.
static const UID mxf_mpeg2_codec_uls[]
Definition: mxfenc.c:2361
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
AVPacket pkt
Definition: avformat.h:2025
timecode is drop frame
Definition: timecode.h:36
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
int frame_size
frame size in bytes
Definition: mxfenc.c:99
also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:472
int ff_audio_interleave_init(AVFormatContext *s, const int *samples_per_frame, AVRational time_base)
#define LIBAVFORMAT_VERSION_MAJOR
Definition: version.h:34
static int64_t mxf_write_generic_desc(AVFormatContext *s, AVStream *st, const UID key)
Definition: mxfenc.c:1115
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
int avpriv_dnxhd_get_frame_size(int cid)
Definition: dnxhddata.c:1087
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1489
uint8_t * data
Definition: avcodec.h:1477
uint64_t duration
Definition: mxfenc.c:348
int start
timecode frame start (first base frame number)
Definition: timecode.h:42
uint32_t tag
Definition: movenc.c:1496
uint64_t offset
Definition: mxfenc.c:76
Definition: ismindex.c:69
enum AVPixelFormat pix_fmt
Definition: dv_profile.h:50
int instance
Definition: mxfenc.c:117
ptrdiff_t size
Definition: opengl_enc.c:100
uint8_t flags
Definition: mxfenc.c:75
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
struct AVPacketList * packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:78
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush)
Interleave an AVPacket correctly so it can be muxed.
Definition: mux.c:1174
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1506
AVRational audio_edit_rate
Definition: mxfenc.c:360
unsigned slice_offset
offset of audio slice
Definition: mxfenc.c:77
enum ULIndex index
Definition: mxfenc.c:157
static const uint8_t index_table_segment_key[]
Definition: mxfenc.c:376
#define av_log(a,...)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:276
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3982
int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx)
Init a timecode struct with the passed parameters.
Definition: timecode.c:184
int store_user_comments
Definition: mxfenc.c:361
AudioInterleaveContext aic
Definition: mxfenc.c:82
int local_tag
Definition: mxfenc.c:70
static const AVClass mxf_opatom_muxer_class
Definition: mxfenc.c:3226
H.264 parameter set handling.
static const uint8_t umid_ul[]
Definition: mxfenc.c:367
static void mxf_write_tape_descriptor(AVFormatContext *s)
Definition: mxfenc.c:1065
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:5649
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1506
ITU-R BT1361 Extended Colour Gamut.
Definition: pixfmt.h:480
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
static void mxf_write_system_item(AVFormatContext *s)
Definition: mxfenc.c:2732
#define EDIT_UNITS_PER_BODY
Definition: mxfenc.c:66
static const uint8_t header_metadata_key[]
partial key for header metadata
Definition: mxfenc.c:386
static const uint8_t mxf_indirect_value_utf16le[]
Definition: mxfenc.c:1542
int profile
Definition: mxfenc.c:2036
Definition: mxf.h:42
static int64_t mxf_write_wav_common(AVFormatContext *s, AVStream *st, const UID key)
Definition: mxfenc.c:1509
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...
int v_chroma_sub_sample
Definition: mxfenc.c:93
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
static const uint8_t header_open_partition_key[]
Definition: mxfenc.c:378
static void mxf_write_preface(AVFormatContext *s)
Definition: mxfenc.c:703
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
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3949
int header_written
Definition: mxfenc.c:339
static void mxf_write_random_index_pack(AVFormatContext *s)
Definition: mxfenc.c:3002
static void mxf_write_cdci_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1396
simple assert() macros that are a bit more flexible than ISO C assert().
static int mxf_write_opatom_body_partition(AVFormatContext *s)
Definition: mxfenc.c:2813
GLsizei GLsizei * length
Definition: opengl_enc.c:114
int cbr_index
use a constant bitrate index
Definition: mxfenc.c:363
static void mxf_write_content_storage(AVFormatContext *s, MXFPackage *packages, int package_count)
Definition: mxfenc.c:875
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:87
static void mxf_write_metadata_key(AVIOContext *pb, unsigned int value)
Definition: mxfenc.c:650
GLsizei count
Definition: opengl_enc.c:108
#define MXF_COMMON_OPTIONS
Definition: mxfenc.c:3167
#define FFMAX(a, b)
Definition: common.h:94
int color_siting
Definition: mxfenc.c:90
#define LIBAVFORMAT_VERSION_MINOR
Definition: version.h:35
int order
interleaving order if dts are equal
Definition: mxfenc.c:86
static void mxf_write_d10_audio_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:2781
static const uint8_t primer_pack_key[]
Definition: mxfenc.c:375
static const uint8_t system_metadata_pack_key[]
Definition: mxfenc.c:2729
static int mxf_get_essence_container_ul_index(enum AVCodecID id)
Definition: mxfenc.c:589
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
Definition: mem.c:205
int intra_only
Definition: mxfenc.c:2219
static int klv_ber_length(uint64_t len)
Definition: mxfenc.c:545
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
int block_align
Audio only.
Definition: avcodec.h:4070
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
static int mxf_parse_h264_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt, MXFIndexEntry *e)
Definition: mxfenc.c:2246
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
static const UID mxf_wav_descriptor_key
Definition: mxfenc.c:1155
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
void ffio_fill(AVIOContext *s, int b, int count)
Definition: aviobuf.c:204
#define KAG_SIZE
Definition: mxfenc.c:67
static const uint8_t op1a_ul[]
complete key for operation pattern, partitions, and primer pack
Definition: mxfenc.c:372
uint8_t frame_mbs_only_flag
Definition: avc.h:46
uint8_t interlaced
Definition: mxfenc.c:2218
static int mxf_parse_dnxhd_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:2098
#define LIBAVFORMAT_VERSION_MICRO
Definition: version.h:36
#define FF_PROFILE_PRORES_STANDARD
Definition: avcodec.h:3001
uint64_t * body_partition_offset
Definition: mxfenc.c:345
struct MXFPackage * ref
Definition: mxfenc.c:118
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:545
static const AVOption mxf_options[]
Definition: mxfenc.c:3187
ULIndex
Definition: mxfenc.c:121
void avio_wb24(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:487
static const AVClass mxf_muxer_class
Definition: mxfenc.c:3194
const char * name
Definition: avformat.h:505
static int mxf_write_partition(AVFormatContext *s, int bodysid, int indexsid, const uint8_t *key, int write_metadata)
Definition: mxfenc.c:1929
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static const struct @267 mxf_dnxhd_codec_uls[]
static void mxf_write_local_tag_utf16(AVIOContext *pb, int tag, const char *value)
Definition: mxfenc.c:799
#define s(width, name)
Definition: cbs_vp9.c:257
static int mxf_write_header_metadata_sets(AVFormatContext *s)
Definition: mxfenc.c:1713
uint8_t constraint_set_flags
Definition: avc.h:43
AVDictionary * metadata
Definition: avformat.h:945
AVStream * timecode_track
Definition: mxfenc.c:350
int slice_offset
Definition: mxfenc.c:98
static const UID mxf_aes3_descriptor_key
Definition: mxfenc.c:1156
enum AVColorRange color_range
Video only.
Definition: avcodec.h:4039
const MXFCodecUL ff_mxf_data_definition_uls[]
SMPTE RP224 http://www.smpte-ra.org/mdd/index.html.
Definition: mxf.c:28
static const uint8_t system_metadata_package_set_key[]
Definition: mxfenc.c:2730
int edit_unit_byte_count
fixed edit unit byte count
Definition: mxfenc.c:352
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
#define FF_ARRAY_ELEMS(a)
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1377
static uint64_t mxf_parse_timestamp(int64_t timestamp64)
Definition: mxfenc.c:2458
if(ret)
AVRational sar
Definition: avc.h:47
Stream structure.
Definition: avformat.h:881
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:103
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int content_package_rate
content package rate in system element, see SMPTE 326M
Definition: mxfenc.c:353
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:467
uint32_t instance_number
Definition: mxfenc.c:355
static int mxf_write_user_comments(AVFormatContext *s, const AVDictionary *m)
Definition: mxfenc.c:1573
#define FF_PROFILE_PRORES_4444
Definition: avcodec.h:3003
int b_picture_count
maximum number of consecutive b pictures, used in mpeg-2 descriptor
Definition: mxfenc.c:102
int signal_standard
Definition: mxfenc.c:358
also ITU-R BT1361
Definition: pixfmt.h:469
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
static void mxf_write_local_tag(AVIOContext *pb, int size, int tag)
Definition: mxfenc.c:644
static void mxf_write_aes3_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1530
int max_gop
maximum gop size, used by mpeg-2 descriptor
Definition: mxfenc.c:101
int frame_size
Definition: mxfenc.c:2216
int last_indexed_edit_unit
Definition: mxfenc.c:344
also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
Definition: pixfmt.h:474
static const AVClass mxf_d10_muxer_class
Definition: mxfenc.c:3210
static int mxf_parse_mpeg2_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt, MXFIndexEntry *e)
Definition: mxfenc.c:2394
uint8_t profile_idc
Definition: avc.h:41
const UID * codec_ul
Definition: mxfenc.c:85
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:118
Timecode helpers header.
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static const struct @265 mxf_essence_mappings[]
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:196
int samples_per_frame[6]
Definition: mxf.h:87
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
static void mxf_write_essence_container_refs(AVFormatContext *s)
Definition: mxfenc.c:681
static unsigned int seed
Definition: videogen.c:78
static const UID * mxf_get_mpeg2_codec_ul(AVCodecParameters *par)
Definition: mxfenc.c:2374
static void mxf_write_package(AVFormatContext *s, MXFPackage *package)
Definition: mxfenc.c:1591
AVRational rate
frame rate in rational form
Definition: timecode.h:44
int seq_closed_gop
all gops in sequence are closed, used in mpeg-2 descriptor
Definition: mxfenc.c:100
void * buf
Definition: avisynth_c.h:766
int closed_gop
gop is closed, used in mpeg-2 frame parsing
Definition: mxfenc.c:96
uint64_t timestamp
timestamp, as year(16),month(8),day(8),hour(8),minutes(8),msec/4(8)
Definition: mxfenc.c:342
int low_delay
low delay, used in mpeg-2 descriptor
Definition: mxfenc.c:103
#define AV_STRINGIFY(s)
Definition: macros.h:36
Describe the class of an AVClass context structure.
Definition: log.h:67
AVRational aspect_ratio
display aspect ratio
Definition: mxfenc.c:95
static const MXFLocalTagPair mxf_local_tag_batch[]
SMPTE RP210 http://www.smpte-ra.org/mdd/index.html https://smpte-ra.org/sites/default/files/Labels.xml.
Definition: mxfenc.c:393
int track_instance_count
Definition: mxfenc.c:362
Rational number (pair of numerator and denominator).
Definition: rational.h:58
static int64_t mxf_write_cdci_common(AVFormatContext *s, AVStream *st, const UID key)
Definition: mxfenc.c:1190
int sample_size
size of one sample all channels included
uint16_t temporal_ref
Definition: mxfenc.c:78
static uint64_t mxf_utf16len(const char *utf8_str)
Definition: mxfenc.c:758
static void mxf_write_primer_pack(AVFormatContext *s)
Definition: mxfenc.c:607
#define FF_PROFILE_PRORES_HQ
Definition: avcodec.h:3002
int avio_put_str16le(AVIOContext *s, const char *str)
Convert an UTF-8 string to UTF-16LE and write it.
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
SMPTE ST 428-1.
Definition: pixfmt.h:486
static void mxf_write_track(AVFormatContext *s, AVStream *st, MXFPackage *package)
Definition: mxfenc.c:902
MXFIndexEntry * index_entries
Definition: mxfenc.c:340
AVRational time_base
Definition: mxfenc.c:338
AVClass * av_class
Definition: mxfenc.c:335
Definition: mxf.h:76
int video_bit_rate
Definition: mxfenc.c:97
static const uint8_t uuid_base[]
Definition: mxfenc.c:366
int channel_count
Definition: mxfenc.c:357
static void mxf_write_h264_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1406
#define LIBAVFORMAT_VERSION
Definition: version.h:41
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:475
#define flags(name, subs,...)
Definition: cbs_av1.c:561
static int mxf_parse_prores_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:2047
static const MXFContainerEssenceEntry mxf_essence_container_uls[]
Definition: mxfenc.c:178
enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:118
static struct @306 state
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:521
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
static const MXFLocalTagPair mxf_user_comments_local_tag[]
Definition: mxfenc.c:517
static int mxf_interleave_get_packet(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
Definition: mxfenc.c:3097
int sample_rate
Audio only.
Definition: avcodec.h:4063
#define DNXHD_VARIABLE
Indicate that a CIDEntry value must be read in the bitstream.
Definition: dnxhddata.h:40
int64_t footer_partition_offset
Definition: mxfenc.c:336
static const uint8_t smpte_12m_timecode_track_data_ul[]
Definition: mxfenc.c:948
Main libavformat public API header.
static void mxf_write_identification(AVFormatContext *s)
Definition: mxfenc.c:828
void ff_audio_interleave_close(AVFormatContext *s)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Definition: mxf.h:37
static int mxf_compare_timestamps(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
Definition: mxfenc.c:3152
H264SequenceParameterSet * ff_avc_decode_sps(const uint8_t *buf, int buf_size)
Definition: avc.c:311
common internal api header.
struct AVPacketList * next
Definition: avformat.h:2026
static const uint8_t footer_partition_key[]
Definition: mxfenc.c:374
static int mxf_write_essence_container_data(AVFormatContext *s)
Definition: mxfenc.c:1691
static void write_metadata(AVFormatContext *s, unsigned int ts)
Definition: flvenc.c:274
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: avcodec.h:4013
static const struct @266 mxf_prores_codec_uls[]
also ITU-R BT470BG
Definition: pixfmt.h:473
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
static const MXFCodecUL * mxf_get_data_definition_ul(int type)
Definition: mxfenc.c:666
int field_dominance
tff=1, bff=2
Definition: mxfenc.c:88
static const UID mxf_avc_subdescriptor_key
Definition: mxfenc.c:1160
static const AVOption d10_options[]
Definition: mxfenc.c:3201
struct AVPacketList * packet_buffer_end
Definition: internal.h:79
#define av_free(p)
int last_key_index
index of last key frame
Definition: mxfenc.c:347
char * value
Definition: dict.h:87
int len
void * priv_data
Format private data.
Definition: avformat.h:1386
int ff_mxf_get_content_package_rate(AVRational time_base)
Definition: mxf.c:180
static void mxf_gen_umid(AVFormatContext *s)
Definition: mxfenc.c:2474
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:337
uint8_t umid[16]
unique material identifier
Definition: mxfenc.c:356
static void mxf_write_multi_descriptor(AVFormatContext *s)
Definition: mxfenc.c:1078
static void mxf_compute_edit_unit_byte_count(AVFormatContext *s)
Definition: mxfenc.c:2864
static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1524
int channels
Audio only.
Definition: avcodec.h:4059
static void mxf_write_local_tags(AVIOContext *pb, const MXFLocalTagPair *local_tags, int count)
Definition: mxfenc.c:598
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1476
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:377
#define FF_PROFILE_PRORES_PROXY
Definition: avcodec.h:2999
FILE * out
Definition: movenc.c:54
Filter the word “frame” indicates either a video frame or a group of audio samples
#define av_freep(p)
static const AVOption opatom_options[]
Definition: mxfenc.c:3217
void INT64 start
Definition: avisynth_c.h:766
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
unsigned edit_units_count
Definition: mxfenc.c:341
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
Definition: random_seed.c:120
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:544
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
UID uid
Definition: mxf.h:77
int stream_index
Definition: avcodec.h:1479
static const uint8_t opatom_ul[]
Definition: mxfenc.c:373
#define DESCRIPTOR_COUNT(essence_container_count)
Definition: mxfenc.c:678
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:910
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
int depth
Number of bits in the component.
Definition: pixdesc.h:58
char * name
Definition: mxfdec.c:236
static int mxf_write_opatom_packet(AVFormatContext *s, AVPacket *pkt, MXFIndexEntry *ie)
Definition: mxfenc.c:2834
uint32_t flags
flags such as drop frame, +24 hours support, ...
Definition: timecode.h:43
exp golomb vlc stuff
static void mxf_write_mpegvideo_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1424
static void mxf_write_umid(AVFormatContext *s, int type)
Definition: mxfenc.c:530
This structure stores compressed data.
Definition: avcodec.h:1454
static int mxf_parse_dv_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:2152
int essence_container_count
Definition: mxfenc.c:337
static void store_version(AVFormatContext *s)
Definition: mxfenc.c:812
static int mxf_write_tagged_value(AVFormatContext *s, const char *name, const char *value)
Definition: mxfenc.c:1544
static const uint8_t random_index_pack_key[]
Definition: mxfenc.c:377
int avpriv_dnxhd_get_hr_frame_size(int cid, int w, int h)
Definition: dnxhddata.c:1095
static void mxf_write_generic_sound_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1536
enum MXFMetadataSetType type
Definition: mxfdec.c:229
static int mxf_interleave(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
Definition: mxfenc.c:3161
struct AVPacketList * last_in_packet_buffer
last packet in packet_buffer for this stream when muxing.
Definition: avformat.h:1105
AVTimecode tc
timecode context
Definition: mxfenc.c:349
static int mxf_write_footer(AVFormatContext *s)
Definition: mxfenc.c:3029
static const MXFLocalTagPair mxf_avc_subdescriptor_local_tags[]
Definition: mxfenc.c:510
const char * name
Definition: opengl_enc.c:102
uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum)
Convert frame number to SMPTE 12M binary representation.
Definition: timecode.c:55
AVOutputFormat ff_mxf_opatom_muxer
Definition: mxfenc.c:3264