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  index_byte_count += 16 + 4; // add encoded ber4 length
1948  index_byte_count += klv_fill_size(index_byte_count);
1949  }
1950 
1951  if (key && !memcmp(key, body_partition_key, 16)) {
1953  sizeof(*mxf->body_partition_offset))) < 0) {
1954  mxf->body_partitions_count = 0;
1955  return err;
1956  }
1957  mxf->body_partition_offset[mxf->body_partitions_count++] = partition_offset;
1958  }
1959 
1960  // write klv
1961  if (key)
1962  avio_write(pb, key, 16);
1963  else
1964  avio_write(pb, body_partition_key, 16);
1965 
1967 
1968  // write partition value
1969  avio_wb16(pb, 1); // majorVersion
1970  avio_wb16(pb, 3); // minorVersion
1971  avio_wb32(pb, KAG_SIZE); // KAGSize
1972 
1973  avio_wb64(pb, partition_offset); // ThisPartition
1974 
1975  if (key && !memcmp(key, body_partition_key, 16) && mxf->body_partitions_count > 1)
1976  avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-2]); // PreviousPartition
1977  else if (key && !memcmp(key, footer_partition_key, 16) && mxf->body_partitions_count)
1978  avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-1]); // PreviousPartition
1979  else
1980  avio_wb64(pb, 0);
1981 
1982  avio_wb64(pb, mxf->footer_partition_offset); // footerPartition
1983 
1984  // set offset
1985  header_byte_count_offset = avio_tell(pb);
1986  avio_wb64(pb, 0); // headerByteCount, update later
1987 
1988  // indexTable
1989  avio_wb64(pb, index_byte_count); // indexByteCount
1990  avio_wb32(pb, index_byte_count ? indexsid : 0); // indexSID
1991 
1992  // BodyOffset
1993  if (bodysid && mxf->edit_units_count && mxf->body_partitions_count && s->oformat != &ff_mxf_opatom_muxer)
1994  avio_wb64(pb, mxf->body_offset);
1995  else
1996  avio_wb64(pb, 0);
1997 
1998  avio_wb32(pb, bodysid); // bodySID
1999 
2000  // operational pattern
2001  if (s->oformat == &ff_mxf_opatom_muxer)
2002  avio_write(pb, opatom_ul, 16);
2003  else
2004  avio_write(pb, op1a_ul, 16);
2005 
2006  // essence container
2008 
2009  if (write_metadata) {
2010  // mark the start of the headermetadata and calculate metadata size
2011  int64_t pos, start;
2012  unsigned header_byte_count;
2013 
2014  mxf_write_klv_fill(s);
2015  start = avio_tell(s->pb);
2017  mxf_write_klv_fill(s);
2019  pos = avio_tell(s->pb);
2020  header_byte_count = pos - start + klv_fill_size(pos);
2021 
2022  // update header_byte_count
2023  avio_seek(pb, header_byte_count_offset, SEEK_SET);
2024  avio_wb64(pb, header_byte_count);
2025  avio_seek(pb, pos, SEEK_SET);
2026  }
2027 
2028  if(key)
2029  avio_flush(pb);
2030 
2031  return 0;
2032 }
2033 
2034 static const struct {
2035  int profile;
2037 } mxf_prores_codec_uls[] = {
2038  { FF_PROFILE_PRORES_PROXY, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x01,0x00 } },
2039  { FF_PROFILE_PRORES_LT, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x02,0x00 } },
2040  { FF_PROFILE_PRORES_STANDARD, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x03,0x00 } },
2041  { FF_PROFILE_PRORES_HQ, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x04,0x00 } },
2042  { FF_PROFILE_PRORES_4444, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x05,0x00 } },
2043  { FF_PROFILE_PRORES_XQ, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x06,0x00 } },
2044 };
2045 
2047 {
2048  MXFContext *mxf = s->priv_data;
2049  MXFStreamContext *sc = st->priv_data;
2050  int i, profile;
2051 
2052  if (mxf->header_written)
2053  return 1;
2054 
2055  sc->codec_ul = NULL;
2056  profile = st->codecpar->profile;
2057  for (i = 0; i < FF_ARRAY_ELEMS(mxf_prores_codec_uls); i++) {
2058  if (profile == mxf_prores_codec_uls[i].profile) {
2059  sc->codec_ul = &mxf_prores_codec_uls[i].codec_ul;
2060  break;
2061  }
2062  }
2063  if (!sc->codec_ul)
2064  return 0;
2065 
2066  sc->frame_size = pkt->size;
2067 
2068  return 1;
2069 }
2070 
2071 static const struct {
2072  int cid;
2073  UID codec_ul;
2074 } mxf_dnxhd_codec_uls[] = {
2075  { 1235, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x01,0x00,0x00 } }, // 1080p 10bit HIGH
2076  { 1237, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x03,0x00,0x00 } }, // 1080p 8bit MED
2077  { 1238, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x04,0x00,0x00 } }, // 1080p 8bit HIGH
2078  { 1241, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x07,0x00,0x00 } }, // 1080i 10bit HIGH
2079  { 1242, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x08,0x00,0x00 } }, // 1080i 8bit MED
2080  { 1243, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x09,0x00,0x00 } }, // 1080i 8bit HIGH
2081  { 1244, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x0a,0x00,0x00 } }, // 1080i 8bit TR
2082  { 1250, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x10,0x00,0x00 } }, // 720p 10bit
2083  { 1251, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x11,0x00,0x00 } }, // 720p 8bit HIGH
2084  { 1252, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x12,0x00,0x00 } }, // 720p 8bit MED
2085  { 1253, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x13,0x00,0x00 } }, // 720p 8bit LOW
2086  { 1256, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x16,0x00,0x00 } }, // 1080p 10bit 444
2087  { 1258, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x18,0x00,0x00 } }, // 720p 8bit TR
2088  { 1259, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x19,0x00,0x00 } }, // 1080p 8bit TR
2089  { 1260, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x1a,0x00,0x00 } }, // 1080i 8bit TR MBAFF
2090  { 1270, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x24,0x00,0x00 } }, // DNXHR 444
2091  { 1271, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x25,0x00,0x00 } }, // DNXHR HQX
2092  { 1272, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x26,0x00,0x00 } }, // DNXHR HQ
2093  { 1273, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x27,0x00,0x00 } }, // DNXHR SQ
2094  { 1274, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x28,0x00,0x00 } }, // DNXHR LB
2095 };
2096 
2098 {
2099  MXFContext *mxf = s->priv_data;
2100  MXFStreamContext *sc = st->priv_data;
2101  int i, cid, frame_size = 0;
2102 
2103  if (mxf->header_written)
2104  return 1;
2105 
2106  if (pkt->size < 43)
2107  return 0;
2108 
2109  sc->codec_ul = NULL;
2110  cid = AV_RB32(pkt->data + 0x28);
2111  for (i = 0; i < FF_ARRAY_ELEMS(mxf_dnxhd_codec_uls); i++) {
2112  if (cid == mxf_dnxhd_codec_uls[i].cid) {
2113  sc->codec_ul = &mxf_dnxhd_codec_uls[i].codec_ul;
2114  break;
2115  }
2116  }
2117  if (!sc->codec_ul)
2118  return 0;
2119 
2120  sc->component_depth = 0;
2121  switch (pkt->data[0x21] >> 5) {
2122  case 1: sc->component_depth = 8; break;
2123  case 2: sc->component_depth = 10; break;
2124  case 3: sc->component_depth = 12; break;
2125  }
2126  if (!sc->component_depth)
2127  return 0;
2128 
2129  if ((frame_size = avpriv_dnxhd_get_frame_size(cid)) == DNXHD_VARIABLE) {
2130  frame_size = avpriv_dnxhd_get_hr_frame_size(cid, st->codecpar->width, st->codecpar->height);
2131  }
2132  if (frame_size < 0)
2133  return 0;
2134 
2135  if ((sc->interlaced = avpriv_dnxhd_get_interlaced(cid)) < 0)
2136  return 0;
2137 
2138  if (cid >= 1270) { // RI raster
2140  st->codecpar->width, st->codecpar->height,
2141  INT_MAX);
2142  } else {
2143  sc->aspect_ratio = (AVRational){ 16, 9 };
2144  }
2145 
2146  sc->frame_size = pkt->size;
2147 
2148  return 1;
2149 }
2150 
2152 {
2153  MXFContext *mxf = s->priv_data;
2154  MXFStreamContext *sc = st->priv_data;
2155  uint8_t *vs_pack, *vsc_pack;
2156  int ul_index, stype, pal;
2157  const AVDVProfile *profile;
2158 
2159  if (mxf->header_written)
2160  return 1;
2161 
2162  // Check for minimal frame size
2163  if (pkt->size < 120000)
2164  return -1;
2165 
2166  profile = av_dv_frame_profile(NULL, pkt->data, pkt->size);
2167 
2168  vs_pack = pkt->data + 80*5 + 48;
2169  vsc_pack = pkt->data + 80*5 + 53;
2170  stype = vs_pack[3] & 0x1f;
2171  pal = (vs_pack[3] >> 5) & 0x1;
2172 
2173  if ((vsc_pack[2] & 0x07) == 0x02) {
2174  sc->aspect_ratio = (AVRational){ 16, 9 };
2175  } else {
2176  sc->aspect_ratio = (AVRational){ 4, 3 };
2177  }
2178 
2179  sc->interlaced = (vsc_pack[3] >> 4) & 0x01;
2180  // TODO: fix dv encoder to set proper FF/FS value in VSC pack
2181  // and set field dominance accordingly
2182  // av_log(s, AV_LOG_DEBUG, "DV vsc pack ff/ss = %x\n", vsc_pack[2] >> 6);
2183 
2184  switch (stype) {
2185  case 0x18: // DV100 720p
2186  ul_index = INDEX_DV100_720_50 + pal;
2187  if (sc->interlaced) {
2188  av_log(s, AV_LOG_ERROR, "source marked as interlaced but codec profile is progressive\n");
2189  sc->interlaced = 0;
2190  }
2191  break;
2192  case 0x14: // DV100 1080i
2193  ul_index = INDEX_DV100_1080_50 + pal;
2194  break;
2195  case 0x04: // DV50
2196  ul_index = INDEX_DV50_525_60 + pal;
2197  break;
2198  default: // DV25
2199  if (profile && profile->pix_fmt == AV_PIX_FMT_YUV420P && pal) {
2200  ul_index = INDEX_DV25_525_60_IEC + pal;
2201  break;
2202  }
2203  ul_index = INDEX_DV25_525_60 + pal;
2204  }
2205 
2206  sc->index = ul_index;
2207  sc->codec_ul = &mxf_essence_container_uls[sc->index].codec_ul;
2208  sc->frame_size = pkt->size;
2209 
2210  return 1;
2211 }
2212 
2213 static const struct {
2216  int profile;
2218  int intra_only; // 1 or 0 when there are separate UIDs for Long GOP and Intra, -1 when Intra/LGOP detection can be ignored
2219 } mxf_h264_codec_uls[] = {
2220  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x11,0x01 }, 0, 66, 0, -1 }, // AVC Baseline
2221  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x20,0x01 }, 0, 77, 0, -1 }, // AVC Main
2222  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x30,0x01 }, 0, 88, 0, -1 }, // AVC Extended
2223  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x40,0x01 }, 0, 100, 0, -1 }, // AVC High
2224  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x50,0x01 }, 0, 110, 0, 0 }, // AVC High 10
2225  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x60,0x01 }, 0, 122, 0, 0 }, // AVC High 422
2226  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x70,0x01 }, 0, 244, 0, 0 }, // AVC High 444
2227  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x20,0x01 }, 0, 110, 0, 1 }, // AVC High 10 Intra
2228  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 232960, 110, 1, 1 }, // AVC High 10 Intra RP2027 Class 50 1080/59.94i
2229  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 281088, 110, 1, 1 }, // AVC High 10 Intra RP2027 Class 50 1080/50i
2230  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 232960, 110, 0, 1 }, // AVC High 10 Intra RP2027 Class 50 1080/29.97p
2231  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 281088, 110, 0, 1 }, // AVC High 10 Intra RP2027 Class 50 1080/25p
2232  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x08 }, 116736, 110, 0, 1 }, // AVC High 10 Intra RP2027 Class 50 720/59.94p
2233  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x09 }, 140800, 110, 0, 1 }, // AVC High 10 Intra RP2027 Class 50 720/50p
2234  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x30,0x01 }, 0, 122, 0, 1 }, // AVC High 422 Intra
2235  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x31,0x01 }, 472576, 122, 1, 1 }, // AVC High 422 Intra RP2027 Class 100 1080/59.94i
2236  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x31,0x02 }, 568832, 122, 1, 1 }, // AVC High 422 Intra RP2027 Class 100 1080/50i
2237  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x31,0x03 }, 472576, 122, 0, 1 }, // AVC High 422 Intra RP2027 Class 100 1080/29.97p
2238  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x31,0x04 }, 568832, 122, 0, 1 }, // AVC High 422 Intra RP2027 Class 100 1080/25p
2239  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x31,0x08 }, 236544, 122, 0, 1 }, // AVC High 422 Intra RP2027 Class 100 720/59.94p
2240  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x31,0x09 }, 284672, 122, 0, 1 }, // AVC High 422 Intra RP2027 Class 100 720/50p
2241  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x01,0x32,0x40,0x01 }, 0, 244, 0, 1 }, // AVC High 444 Intra
2242  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x01,0x32,0x50,0x01 }, 0, 44, 0, -1 }, // AVC CAVLC 444
2243 };
2244 
2246  AVPacket *pkt, MXFIndexEntry *e)
2247 {
2248  MXFContext *mxf = s->priv_data;
2249  MXFStreamContext *sc = st->priv_data;
2251  GetBitContext gb;
2252  const uint8_t *buf = pkt->data;
2253  const uint8_t *buf_end = pkt->data + pkt->size;
2254  const uint8_t *nal_end;
2255  uint32_t state = -1;
2256  int extra_size = 512; // support AVC Intra files without SPS/PPS header
2257  int i, frame_size, slice_type, intra_only = 0;
2258 
2259  for (;;) {
2260  buf = avpriv_find_start_code(buf, buf_end, &state);
2261  if (buf >= buf_end)
2262  break;
2263 
2264  switch (state & 0x1f) {
2265  case H264_NAL_SPS:
2266  e->flags |= 0x40;
2267 
2268  if (mxf->header_written)
2269  break;
2270 
2271  nal_end = ff_avc_find_startcode(buf, buf_end);
2272  sps = ff_avc_decode_sps(buf, nal_end - buf);
2273  if (!sps) {
2274  av_log(s, AV_LOG_ERROR, "error parsing sps\n");
2275  return 0;
2276  }
2277 
2278  sc->aspect_ratio.num = st->codecpar->width * sps->sar.num;
2279  sc->aspect_ratio.den = st->codecpar->height * sps->sar.den;
2281  sc->aspect_ratio.num, sc->aspect_ratio.den, 1024*1024);
2282  intra_only = (sps->constraint_set_flags >> 3) & 1;
2283  sc->interlaced = !sps->frame_mbs_only_flag;
2284  sc->component_depth = sps->bit_depth_luma;
2285 
2286  buf = nal_end;
2287  break;
2288  case H264_NAL_PPS:
2289  if (e->flags & 0x40) { // sequence header present
2290  e->flags |= 0x80; // random access
2291  extra_size = 0;
2292  }
2293  break;
2294  case H264_NAL_IDR_SLICE:
2295  e->flags |= 0x04; // IDR Picture
2296  buf = buf_end;
2297  break;
2298  case H264_NAL_SLICE:
2299  init_get_bits8(&gb, buf, buf_end - buf);
2300  get_ue_golomb_long(&gb); // skip first_mb_in_slice
2301  slice_type = get_ue_golomb_31(&gb);
2302  switch (slice_type % 5) {
2303  case 0:
2304  e->flags |= 0x20; // P Picture
2305  e->flags |= 0x06; // P Picture
2306  break;
2307  case 1:
2308  e->flags |= 0x30; // B Picture
2309  e->flags |= 0x03; // non-referenced B Picture
2310  break;
2311  }
2312  buf = buf_end;
2313  break;
2314  default:
2315  break;
2316  }
2317  }
2318 
2319  if (mxf->header_written)
2320  return 1;
2321 
2322  if (!sps)
2323  sc->interlaced = st->codecpar->field_order != AV_FIELD_PROGRESSIVE ? 1 : 0;
2324  sc->codec_ul = NULL;
2325  frame_size = pkt->size + extra_size;
2326 
2327  for (i = 0; i < FF_ARRAY_ELEMS(mxf_h264_codec_uls); i++) {
2328  if (frame_size == mxf_h264_codec_uls[i].frame_size && sc->interlaced == mxf_h264_codec_uls[i].interlaced) {
2329  sc->codec_ul = &mxf_h264_codec_uls[i].uid;
2330  sc->component_depth = 10; // AVC Intra is always 10 Bit
2331  sc->aspect_ratio = (AVRational){ 16, 9 }; // 16:9 is mandatory for broadcast HD
2332  st->codecpar->profile = mxf_h264_codec_uls[i].profile;
2333  sc->avc_intra = 1;
2334  mxf->cbr_index = 1;
2335  sc->frame_size = pkt->size;
2336  if (sc->interlaced)
2337  sc->field_dominance = 1; // top field first is mandatory for AVC Intra
2338  break;
2339  } else if (sps && mxf_h264_codec_uls[i].frame_size == 0 &&
2340  mxf_h264_codec_uls[i].profile == sps->profile_idc &&
2341  (mxf_h264_codec_uls[i].intra_only < 0 ||
2342  mxf_h264_codec_uls[i].intra_only == intra_only)) {
2343  sc->codec_ul = &mxf_h264_codec_uls[i].uid;
2344  st->codecpar->profile = sps->profile_idc;
2345  st->codecpar->level = sps->level_idc;
2346  // continue to check for avc intra
2347  }
2348  }
2349 
2350  av_free(sps);
2351 
2352  if (!sc->codec_ul) {
2353  av_log(s, AV_LOG_ERROR, "h264 profile not supported\n");
2354  return 0;
2355  }
2356 
2357  return 1;
2358 }
2359 
2360 static const UID mxf_mpeg2_codec_uls[] = {
2361  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x10,0x00 }, // MP-ML I-Frame
2362  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x11,0x00 }, // MP-ML Long GOP
2363  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x02,0x00 }, // 422P-ML I-Frame
2364  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x03,0x00 }, // 422P-ML Long GOP
2365  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x02,0x00 }, // MP-HL I-Frame
2366  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x03,0x00 }, // MP-HL Long GOP
2367  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x02,0x00 }, // 422P-HL I-Frame
2368  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x03,0x00 }, // 422P-HL Long GOP
2369  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x05,0x02,0x00 }, // MP@H-14 I-Frame
2370  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x05,0x03,0x00 }, // MP@H-14 Long GOP
2371 };
2372 
2374 {
2375  int long_gop = 1;
2376 
2377  if (par->profile == 4) { // Main
2378  if (par->level == 8) // Main
2379  return &mxf_mpeg2_codec_uls[0+long_gop];
2380  else if (par->level == 4) // High
2381  return &mxf_mpeg2_codec_uls[4+long_gop];
2382  else if (par->level == 6) // High 14
2383  return &mxf_mpeg2_codec_uls[8+long_gop];
2384  } else if (par->profile == 0) { // 422
2385  if (par->level == 5) // Main
2386  return &mxf_mpeg2_codec_uls[2+long_gop];
2387  else if (par->level == 2) // High
2388  return &mxf_mpeg2_codec_uls[6+long_gop];
2389  }
2390  return NULL;
2391 }
2392 
2394  AVPacket *pkt, MXFIndexEntry *e)
2395 {
2396  MXFStreamContext *sc = st->priv_data;
2397  uint32_t c = -1;
2398  int i;
2399 
2400  for(i = 0; i < pkt->size - 4; i++) {
2401  c = (c<<8) + pkt->data[i];
2402  if (c == 0x1b5) {
2403  if ((pkt->data[i+1] & 0xf0) == 0x10) { // seq ext
2404  st->codecpar->profile = pkt->data[i+1] & 0x07;
2405  st->codecpar->level = pkt->data[i+2] >> 4;
2406  sc->low_delay = pkt->data[i+6] >> 7;
2407  } else if (i + 5 < pkt->size && (pkt->data[i+1] & 0xf0) == 0x80) { // pict coding ext
2408  sc->interlaced = !(pkt->data[i+5] & 0x80); // progressive frame
2409  if (sc->interlaced)
2410  sc->field_dominance = 1 + !(pkt->data[i+4] & 0x80); // top field first
2411  break;
2412  }
2413  } else if (c == 0x1b8) { // gop
2414  if (pkt->data[i+4]>>6 & 0x01) { // closed
2415  if (sc->seq_closed_gop == -1)
2416  sc->seq_closed_gop = 1;
2417  sc->closed_gop = 1;
2418  if (e->flags & 0x40) // sequence header present
2419  e->flags |= 0x80; // random access
2420  } else {
2421  sc->seq_closed_gop = 0;
2422  sc->closed_gop = 0;
2423  }
2424  } else if (c == 0x1b3) { // seq
2425  e->flags |= 0x40;
2426  switch ((pkt->data[i+4]>>4) & 0xf) {
2427  case 2: sc->aspect_ratio = (AVRational){ 4, 3}; break;
2428  case 3: sc->aspect_ratio = (AVRational){ 16, 9}; break;
2429  case 4: sc->aspect_ratio = (AVRational){221,100}; break;
2430  default:
2432  st->codecpar->width, st->codecpar->height, 1024*1024);
2433  }
2434  } else if (c == 0x100) { // pic
2435  int pict_type = (pkt->data[i+2]>>3) & 0x07;
2436  e->temporal_ref = (pkt->data[i+1]<<2) | (pkt->data[i+2]>>6);
2437  if (pict_type == 2) { // P-frame
2438  e->flags |= 0x22;
2439  sc->closed_gop = 0; // reset closed GOP, don't matter anymore
2440  } else if (pict_type == 3) { // B-frame
2441  if (sc->closed_gop)
2442  e->flags |= 0x13; // only backward prediction
2443  else
2444  e->flags |= 0x33;
2445  sc->temporal_reordering = -1;
2446  } else if (!pict_type) {
2447  av_log(s, AV_LOG_ERROR, "error parsing mpeg2 frame\n");
2448  return 0;
2449  }
2450  }
2451  }
2452  if (s->oformat != &ff_mxf_d10_muxer)
2454  return !!sc->codec_ul;
2455 }
2456 
2457 static uint64_t mxf_parse_timestamp(int64_t timestamp64)
2458 {
2459  time_t timestamp = timestamp64 / 1000000;
2460  struct tm tmbuf;
2461  struct tm *time = gmtime_r(&timestamp, &tmbuf);
2462  if (!time)
2463  return 0;
2464  return (uint64_t)(time->tm_year+1900) << 48 |
2465  (uint64_t)(time->tm_mon+1) << 40 |
2466  (uint64_t) time->tm_mday << 32 |
2467  time->tm_hour << 24 |
2468  time->tm_min << 16 |
2469  time->tm_sec << 8 |
2470  (timestamp64 % 1000000) / 4000;
2471 }
2472 
2474 {
2475  MXFContext *mxf = s->priv_data;
2476  uint32_t seed = av_get_random_seed();
2477  uint64_t umid = seed + 0x5294713400000000LL;
2478 
2479  AV_WB64(mxf->umid , umid);
2480  AV_WB64(mxf->umid+8, umid>>8);
2481 
2482  mxf->instance_number = seed & 0xFFFFFF;
2483 }
2484 
2486 {
2487  MXFContext *mxf = s->priv_data;
2488  AVDictionaryEntry *tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
2489  if (!tcr)
2490  tcr = av_dict_get(st->metadata, "timecode", NULL, 0);
2491 
2492  if (tcr)
2493  return av_timecode_init_from_string(&mxf->tc, rate, tcr->value, s);
2494  else
2495  return av_timecode_init(&mxf->tc, rate, 0, 0, s);
2496 }
2497 
2499 {
2500  MXFContext *mxf = s->priv_data;
2501  int i, ret;
2502  uint8_t present[FF_ARRAY_ELEMS(mxf_essence_container_uls)] = {0};
2503  const MXFSamplesPerFrame *spf = NULL;
2504  int64_t timestamp = 0;
2505 
2506  if (!s->nb_streams)
2507  return -1;
2508 
2509  if (s->oformat == &ff_mxf_opatom_muxer && s->nb_streams !=1) {
2510  av_log(s, AV_LOG_ERROR, "there must be exactly one stream for mxf opatom\n");
2511  return -1;
2512  }
2513 
2514  if (!av_dict_get(s->metadata, "comment_", NULL, AV_DICT_IGNORE_SUFFIX))
2515  mxf->store_user_comments = 0;
2516 
2517  for (i = 0; i < s->nb_streams; i++) {
2518  AVStream *st = s->streams[i];
2519  MXFStreamContext *sc = av_mallocz(sizeof(*sc));
2520  if (!sc)
2521  return AVERROR(ENOMEM);
2522  st->priv_data = sc;
2523 
2524  if (((i == 0) ^ (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)) && s->oformat != &ff_mxf_opatom_muxer) {
2525  av_log(s, AV_LOG_ERROR, "there must be exactly one video stream and it must be the first one\n");
2526  return -1;
2527  }
2528 
2529  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2530  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(st->codecpar->format);
2531  // TODO: should be avg_frame_rate
2532  AVRational rate, tbc = st->time_base;
2533  // Default component depth to 8
2534  sc->component_depth = 8;
2535  sc->h_chroma_sub_sample = 2;
2536  sc->v_chroma_sub_sample = 2;
2537  sc->color_siting = 0xFF;
2538 
2541  av_make_q(st->codecpar->width, st->codecpar->height));
2542  }
2543 
2544  if (pix_desc) {
2545  sc->component_depth = pix_desc->comp[0].depth;
2546  sc->h_chroma_sub_sample = 1 << pix_desc->log2_chroma_w;
2547  sc->v_chroma_sub_sample = 1 << pix_desc->log2_chroma_h;
2548  }
2549  switch (ff_choose_chroma_location(s, st)) {
2550  case AVCHROMA_LOC_TOPLEFT: sc->color_siting = 0; break;
2551  case AVCHROMA_LOC_LEFT: sc->color_siting = 6; break;
2552  case AVCHROMA_LOC_TOP: sc->color_siting = 1; break;
2553  case AVCHROMA_LOC_CENTER: sc->color_siting = 3; break;
2554  }
2555 
2556  mxf->timecode_base = (tbc.den + tbc.num/2) / tbc.num;
2557  spf = ff_mxf_get_samples_per_frame(s, tbc);
2558  if (!spf) {
2559  av_log(s, AV_LOG_ERROR, "Unsupported video frame rate %d/%d\n",
2560  tbc.den, tbc.num);
2561  return AVERROR(EINVAL);
2562  }
2564  mxf->time_base = spf->time_base;
2565  rate = av_inv_q(mxf->time_base);
2566  avpriv_set_pts_info(st, 64, mxf->time_base.num, mxf->time_base.den);
2567  if((ret = mxf_init_timecode(s, st, rate)) < 0)
2568  return ret;
2569 
2571  sc->seq_closed_gop = -1; // unknown yet
2572  }
2573 
2574  sc->video_bit_rate = st->codecpar->bit_rate;
2575 
2576  if (s->oformat == &ff_mxf_d10_muxer ||
2579  mxf->cbr_index = 1;
2580 
2581  if (s->oformat == &ff_mxf_d10_muxer) {
2583  av_log(s, AV_LOG_ERROR, "error MXF D-10 only support MPEG-2 Video\n");
2584  return AVERROR(EINVAL);
2585  }
2586  if ((sc->video_bit_rate == 50000000) && (mxf->time_base.den == 25)) {
2588  } else if ((sc->video_bit_rate == 49999840 || sc->video_bit_rate == 50000000) && (mxf->time_base.den != 25)) {
2590  } else if (sc->video_bit_rate == 40000000) {
2591  if (mxf->time_base.den == 25) sc->index = INDEX_D10_625_50_40_VIDEO;
2592  else sc->index = INDEX_D10_525_60_40_VIDEO;
2593  } else if (sc->video_bit_rate == 30000000) {
2594  if (mxf->time_base.den == 25) sc->index = INDEX_D10_625_50_30_VIDEO;
2595  else sc->index = INDEX_D10_525_60_30_VIDEO;
2596  } else {
2597  av_log(s, AV_LOG_ERROR, "error MXF D-10 only support 30/40/50 mbit/s\n");
2598  return -1;
2599  }
2600 
2601  sc->signal_standard = 1;
2602  sc->color_siting = 0;
2603  sc->frame_size = (int64_t)sc->video_bit_rate *
2604  mxf->time_base.num / (8*mxf->time_base.den);
2605  }
2606  if (mxf->signal_standard >= 0)
2607  sc->signal_standard = mxf->signal_standard;
2608  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2609  if (st->codecpar->sample_rate != 48000) {
2610  av_log(s, AV_LOG_ERROR, "only 48khz is implemented\n");
2611  return -1;
2612  }
2613  avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
2614  if (s->oformat == &ff_mxf_d10_muxer) {
2615  if (st->index != 1) {
2616  av_log(s, AV_LOG_ERROR, "MXF D-10 only support one audio track\n");
2617  return -1;
2618  }
2619  if (st->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE &&
2621  av_log(s, AV_LOG_ERROR, "MXF D-10 only support 16 or 24 bits le audio\n");
2622  }
2623  sc->index = ((MXFStreamContext*)s->streams[0]->priv_data)->index + 1;
2624  sc->frame_size = 4 + 8 * spf[0].samples_per_frame[0] * 4;
2625  } else if (s->oformat == &ff_mxf_opatom_muxer) {
2626  AVRational tbc = av_inv_q(mxf->audio_edit_rate);
2627 
2628  if (st->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE &&
2630  av_log(s, AV_LOG_ERROR, "Only pcm_s16le and pcm_s24le audio codecs are implemented\n");
2631  return AVERROR_PATCHWELCOME;
2632  }
2633  if (st->codecpar->channels != 1) {
2634  av_log(s, AV_LOG_ERROR, "MXF OPAtom only supports single channel audio\n");
2635  return AVERROR(EINVAL);
2636  }
2637 
2638  spf = ff_mxf_get_samples_per_frame(s, tbc);
2639  if (!spf) {
2640  av_log(s, AV_LOG_ERROR, "Unsupported timecode frame rate %d/%d\n", tbc.den, tbc.num);
2641  return AVERROR(EINVAL);
2642  }
2643 
2644  mxf->time_base = st->time_base;
2645  if((ret = mxf_init_timecode(s, st, av_inv_q(spf->time_base))) < 0)
2646  return ret;
2647 
2648  mxf->timecode_base = (tbc.den + tbc.num/2) / tbc.num;
2650  sc->index = INDEX_WAV;
2651  } else {
2652  mxf->slice_count = 1;
2653  sc->frame_size = (st->codecpar->channels * spf[0].samples_per_frame[0] *
2655  }
2656  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2657  AVDictionaryEntry *e = av_dict_get(st->metadata, "data_type", NULL, 0);
2658  if (e && !strcmp(e->value, "vbi_vanc_smpte_436M")) {
2659  sc->index = INDEX_S436M;
2660  } else {
2661  av_log(s, AV_LOG_ERROR, "track %d: unsupported data type\n", i);
2662  return -1;
2663  }
2664  if (st->index != s->nb_streams - 1) {
2665  av_log(s, AV_LOG_ERROR, "data track must be placed last\n");
2666  return -1;
2667  }
2668  }
2669 
2670  if (!sc->index) {
2672  if (sc->index == -1) {
2673  av_log(s, AV_LOG_ERROR, "track %d: could not find essence container ul, "
2674  "codec not currently supported in container\n", i);
2675  return -1;
2676  }
2677  }
2678 
2679  sc->codec_ul = &mxf_essence_container_uls[sc->index].codec_ul;
2680 
2681  memcpy(sc->track_essence_element_key, mxf_essence_container_uls[sc->index].element_ul, 15);
2682  sc->track_essence_element_key[15] = present[sc->index];
2683  PRINT_KEY(s, "track essence element key", sc->track_essence_element_key);
2684 
2685  if (!present[sc->index])
2686  mxf->essence_container_count++;
2687  present[sc->index]++;
2688  }
2689 
2690  if (s->oformat == &ff_mxf_d10_muxer || s->oformat == &ff_mxf_opatom_muxer) {
2691  mxf->essence_container_count = 1;
2692  }
2693 
2694  if (!(s->flags & AVFMT_FLAG_BITEXACT))
2695  mxf_gen_umid(s);
2696 
2697  for (i = 0; i < s->nb_streams; i++) {
2698  MXFStreamContext *sc = s->streams[i]->priv_data;
2699  // update element count
2700  sc->track_essence_element_key[13] = present[sc->index];
2701  if (!memcmp(sc->track_essence_element_key, mxf_essence_container_uls[15].element_ul, 13)) // DV
2702  sc->order = (0x15 << 24) | AV_RB32(sc->track_essence_element_key+13);
2703  else
2704  sc->order = AV_RB32(sc->track_essence_element_key+12);
2705  }
2706 
2707  if (ff_parse_creation_time_metadata(s, &timestamp, 0) > 0)
2708  mxf->timestamp = mxf_parse_timestamp(timestamp);
2709  mxf->duration = -1;
2710 
2711  mxf->timecode_track = av_mallocz(sizeof(*mxf->timecode_track));
2712  if (!mxf->timecode_track)
2713  return AVERROR(ENOMEM);
2715  if (!mxf->timecode_track->priv_data)
2716  return AVERROR(ENOMEM);
2717  mxf->timecode_track->index = -1;
2718 
2719  if (!spf)
2720  spf = ff_mxf_get_samples_per_frame(s, (AVRational){ 1, 25 });
2721 
2722  if (ff_audio_interleave_init(s, spf->samples_per_frame, mxf->time_base) < 0)
2723  return -1;
2724 
2725  return 0;
2726 }
2727 
2728 static const uint8_t system_metadata_pack_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04,0x01,0x01,0x00 };
2729 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 };
2730 
2732 {
2733  MXFContext *mxf = s->priv_data;
2734  AVIOContext *pb = s->pb;
2735  unsigned frame;
2736  uint32_t time_code;
2737  int i, system_item_bitmap = 0x58; // UL, user date/time stamp, picture present
2738 
2739  frame = mxf->last_indexed_edit_unit + mxf->edit_units_count;
2740 
2741  // write system metadata pack
2743  klv_encode_ber4_length(pb, 57);
2744 
2745  for (i = 0; i < s->nb_streams; i++) {
2747  system_item_bitmap |= 0x4;
2748  else if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2749  system_item_bitmap |= 0x2;
2750  }
2751  avio_w8(pb, system_item_bitmap);
2752  avio_w8(pb, mxf->content_package_rate); // content package rate
2753  avio_w8(pb, 0x00); // content package type
2754  avio_wb16(pb, 0x00); // channel handle
2755  avio_wb16(pb, (mxf->tc.start + frame) & 0xFFFF); // continuity count, supposed to overflow
2756  if (mxf->essence_container_count > 1)
2757  avio_write(pb, multiple_desc_ul, 16);
2758  else {
2759  MXFStreamContext *sc = s->streams[0]->priv_data;
2760  avio_write(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
2761  }
2762  avio_w8(pb, 0);
2763  avio_wb64(pb, 0);
2764  avio_wb64(pb, 0); // creation date/time stamp
2765 
2766  avio_w8(pb, 0x81); // SMPTE 12M time code
2767  time_code = av_timecode_get_smpte_from_framenum(&mxf->tc, frame);
2768  avio_wb32(pb, time_code);
2769  avio_wb32(pb, 0); // binary group data
2770  avio_wb64(pb, 0);
2771 
2772  // write system metadata package set
2774  klv_encode_ber4_length(pb, 35);
2775  avio_w8(pb, 0x83); // UMID
2776  avio_wb16(pb, 0x20);
2777  mxf_write_umid(s, 1);
2778 }
2779 
2781 {
2782  MXFContext *mxf = s->priv_data;
2783  AVIOContext *pb = s->pb;
2784  int frame_size = pkt->size / st->codecpar->block_align;
2785  uint8_t *samples = pkt->data;
2786  uint8_t *end = pkt->data + pkt->size;
2787  int i;
2788 
2789  klv_encode_ber4_length(pb, 4 + frame_size*4*8);
2790 
2791  avio_w8(pb, (frame_size == 1920 ? 0 : (mxf->edit_units_count-1) % 5 + 1));
2792  avio_wl16(pb, frame_size);
2793  avio_w8(pb, (1<<st->codecpar->channels)-1);
2794 
2795  while (samples < end) {
2796  for (i = 0; i < st->codecpar->channels; i++) {
2797  uint32_t sample;
2798  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE) {
2799  sample = AV_RL24(samples)<< 4;
2800  samples += 3;
2801  } else {
2802  sample = AV_RL16(samples)<<12;
2803  samples += 2;
2804  }
2805  avio_wl32(pb, sample | i);
2806  }
2807  for (; i < 8; i++)
2808  avio_wl32(pb, i);
2809  }
2810 }
2811 
2813 {
2814  MXFContext *mxf = s->priv_data;
2815  AVIOContext *pb = s->pb;
2816  AVStream *st = s->streams[0];
2817  MXFStreamContext *sc = st->priv_data;
2818  const uint8_t *key = NULL;
2819 
2820  int err;
2821 
2822  if (!mxf->header_written)
2823  key = body_partition_key;
2824 
2825  if ((err = mxf_write_partition(s, 1, 0, key, 0)) < 0)
2826  return err;
2827  mxf_write_klv_fill(s);
2830  return 0;
2831 }
2832 
2834 {
2835  MXFContext *mxf = s->priv_data;
2836  AVIOContext *pb = s->pb;
2837 
2838  int err;
2839 
2840  if (!mxf->header_written) {
2841  if ((err = mxf_write_partition(s, 0, 0, header_open_partition_key, 1)) < 0)
2842  return err;
2843  mxf_write_klv_fill(s);
2844 
2845  if ((err = mxf_write_opatom_body_partition(s)) < 0)
2846  return err;
2847  mxf->header_written = 1;
2848  }
2849 
2850  if (!mxf->edit_unit_byte_count) {
2852  mxf->index_entries[mxf->edit_units_count].flags = ie->flags;
2854  }
2855  mxf->edit_units_count++;
2856  avio_write(pb, pkt->data, pkt->size);
2857  mxf->body_offset += pkt->size;
2858  avio_flush(pb);
2859 
2860  return 0;
2861 }
2862 
2864 {
2865  MXFContext *mxf = s->priv_data;
2866  int i;
2867 
2868  if (s->oformat == &ff_mxf_opatom_muxer) {
2869  MXFStreamContext *sc = s->streams[0]->priv_data;
2870  mxf->edit_unit_byte_count = sc->frame_size;
2871  return;
2872  }
2873 
2874  mxf->edit_unit_byte_count = KAG_SIZE; // system element
2875  for (i = 0; i < s->nb_streams; i++) {
2876  AVStream *st = s->streams[i];
2877  MXFStreamContext *sc = st->priv_data;
2879  mxf->edit_unit_byte_count += 16 + 4 + sc->frame_size;
2881  }
2882 }
2883 
2885 {
2886  MXFContext *mxf = s->priv_data;
2887  AVIOContext *pb = s->pb;
2888  AVStream *st = s->streams[pkt->stream_index];
2889  MXFStreamContext *sc = st->priv_data;
2890  MXFIndexEntry ie = {0};
2891  int err;
2892 
2893  if (!mxf->cbr_index && !mxf->edit_unit_byte_count && !(mxf->edit_units_count % EDIT_UNITS_PER_BODY)) {
2894  if ((err = av_reallocp_array(&mxf->index_entries, mxf->edit_units_count
2895  + EDIT_UNITS_PER_BODY, sizeof(*mxf->index_entries))) < 0) {
2896  mxf->edit_units_count = 0;
2897  av_log(s, AV_LOG_ERROR, "could not allocate index entries\n");
2898  return err;
2899  }
2900  }
2901 
2903  if (!mxf_parse_mpeg2_frame(s, st, pkt, &ie)) {
2904  av_log(s, AV_LOG_ERROR, "could not get mpeg2 profile and level\n");
2905  return -1;
2906  }
2907  } else if (st->codecpar->codec_id == AV_CODEC_ID_DNXHD) {
2908  if (!mxf_parse_dnxhd_frame(s, st, pkt)) {
2909  av_log(s, AV_LOG_ERROR, "could not get dnxhd profile\n");
2910  return -1;
2911  }
2912  } else if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2913  if (!mxf_parse_prores_frame(s, st, pkt)) {
2914  av_log(s, AV_LOG_ERROR, "could not get prores profile\n");
2915  return -1;
2916  }
2917  } else if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO) {
2918  if (!mxf_parse_dv_frame(s, st, pkt)) {
2919  av_log(s, AV_LOG_ERROR, "could not get dv profile\n");
2920  return -1;
2921  }
2922  } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2923  if (!mxf_parse_h264_frame(s, st, pkt, &ie)) {
2924  av_log(s, AV_LOG_ERROR, "could not get h264 profile\n");
2925  return -1;
2926  }
2927  }
2928 
2929  if (mxf->cbr_index) {
2930  if (pkt->size != sc->frame_size && st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2931  av_log(s, AV_LOG_ERROR, "track %d: frame size does not match index unit size, %d != %d\n",
2932  st->index, pkt->size, sc->frame_size);
2933  return -1;
2934  }
2935  if (!mxf->header_written)
2937  }
2938 
2939  if (s->oformat == &ff_mxf_opatom_muxer)
2940  return mxf_write_opatom_packet(s, pkt, &ie);
2941 
2942  if (!mxf->header_written) {
2943  if (mxf->edit_unit_byte_count) {
2944  if ((err = mxf_write_partition(s, 1, 2, header_open_partition_key, 1)) < 0)
2945  return err;
2946  mxf_write_klv_fill(s);
2948  } else {
2949  if ((err = mxf_write_partition(s, 0, 0, header_open_partition_key, 1)) < 0)
2950  return err;
2951  }
2952  mxf->header_written = 1;
2953  }
2954 
2955  if (st->index == 0) {
2956  if (!mxf->edit_unit_byte_count &&
2958  !(ie.flags & 0x33)) { // I-frame, GOP start
2959  mxf_write_klv_fill(s);
2960  if ((err = mxf_write_partition(s, 1, 2, body_partition_key, 0)) < 0)
2961  return err;
2962  mxf_write_klv_fill(s);
2964  }
2965 
2966  mxf_write_klv_fill(s);
2968 
2969  if (!mxf->edit_unit_byte_count) {
2971  mxf->index_entries[mxf->edit_units_count].flags = ie.flags;
2973  mxf->body_offset += KAG_SIZE; // size of system element
2974  }
2975  mxf->edit_units_count++;
2976  } else if (!mxf->edit_unit_byte_count && st->index == 1) {
2977  if (!mxf->edit_units_count) {
2978  av_log(s, AV_LOG_ERROR, "No packets in first stream\n");
2979  return AVERROR_PATCHWELCOME;
2980  }
2982  mxf->body_offset - mxf->index_entries[mxf->edit_units_count-1].offset;
2983  }
2984 
2985  mxf_write_klv_fill(s);
2986  avio_write(pb, sc->track_essence_element_key, 16); // write key
2987  if (s->oformat == &ff_mxf_d10_muxer &&
2989  mxf_write_d10_audio_packet(s, st, pkt);
2990  } else {
2991  klv_encode_ber4_length(pb, pkt->size); // write length
2992  avio_write(pb, pkt->data, pkt->size);
2993  mxf->body_offset += 16+4+pkt->size + klv_fill_size(16+4+pkt->size);
2994  }
2995 
2996  avio_flush(pb);
2997 
2998  return 0;
2999 }
3000 
3002 {
3003  MXFContext *mxf = s->priv_data;
3004  AVIOContext *pb = s->pb;
3005  uint64_t pos = avio_tell(pb);
3006  int i;
3007 
3009  klv_encode_ber_length(pb, 28 + 12LL*mxf->body_partitions_count);
3010 
3011  if (mxf->edit_unit_byte_count && s->oformat != &ff_mxf_opatom_muxer)
3012  avio_wb32(pb, 1); // BodySID of header partition
3013  else
3014  avio_wb32(pb, 0);
3015  avio_wb64(pb, 0); // offset of header partition
3016 
3017  for (i = 0; i < mxf->body_partitions_count; i++) {
3018  avio_wb32(pb, 1); // BodySID
3019  avio_wb64(pb, mxf->body_partition_offset[i]);
3020  }
3021 
3022  avio_wb32(pb, 0); // BodySID of footer partition
3024 
3025  avio_wb32(pb, avio_tell(pb) - pos + 4);
3026 }
3027 
3029 {
3030  MXFContext *mxf = s->priv_data;
3031  AVIOContext *pb = s->pb;
3032  int i, err = 0;
3033 
3034  if (!mxf->header_written ||
3035  (s->oformat == &ff_mxf_opatom_muxer && !mxf->body_partition_offset)) {
3036  /* reason could be invalid options/not supported codec/out of memory */
3037  err = AVERROR_UNKNOWN;
3038  goto end;
3039  }
3040 
3042 
3043  mxf_write_klv_fill(s);
3045  if (mxf->edit_unit_byte_count && s->oformat != &ff_mxf_opatom_muxer) { // no need to repeat index
3046  if ((err = mxf_write_partition(s, 0, 0, footer_partition_key, 0)) < 0)
3047  goto end;
3048  } else {
3049  if ((err = mxf_write_partition(s, 0, 2, footer_partition_key, 0)) < 0)
3050  goto end;
3051  mxf_write_klv_fill(s);
3053  }
3054 
3055  mxf_write_klv_fill(s);
3057 
3058  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
3059  if (s->oformat == &ff_mxf_opatom_muxer) {
3060  /* rewrite body partition to update lengths */
3061  avio_seek(pb, mxf->body_partition_offset[0], SEEK_SET);
3062  if ((err = mxf_write_opatom_body_partition(s)) < 0)
3063  goto end;
3064  }
3065 
3066  avio_seek(pb, 0, SEEK_SET);
3067  if (mxf->edit_unit_byte_count && s->oformat != &ff_mxf_opatom_muxer) {
3068  if ((err = mxf_write_partition(s, 1, 2, header_closed_partition_key, 1)) < 0)
3069  goto end;
3070  mxf_write_klv_fill(s);
3072  } else {
3073  if ((err = mxf_write_partition(s, 0, 0, header_closed_partition_key, 1)) < 0)
3074  goto end;
3075  }
3076  // update footer partition offset
3077  for (i = 0; i < mxf->body_partitions_count; i++) {
3078  avio_seek(pb, mxf->body_partition_offset[i]+44, SEEK_SET);
3080  }
3081  }
3082 
3083 end:
3085 
3086  av_freep(&mxf->index_entries);
3089  av_freep(&mxf->timecode_track);
3090 
3091  mxf_free(s);
3092 
3093  return err < 0 ? err : 0;
3094 }
3095 
3097 {
3098  int i, stream_count = 0;
3099 
3100  for (i = 0; i < s->nb_streams; i++)
3101  stream_count += !!s->streams[i]->last_in_packet_buffer;
3102 
3103  if (stream_count && (s->nb_streams == stream_count || flush)) {
3104  AVPacketList *pktl = s->internal->packet_buffer;
3105  if (s->nb_streams != stream_count) {
3106  AVPacketList *last = NULL;
3107  // find last packet in edit unit
3108  while (pktl) {
3109  if (!stream_count || pktl->pkt.stream_index == 0)
3110  break;
3111  // update last packet in packet buffer
3112  if (s->streams[pktl->pkt.stream_index]->last_in_packet_buffer != pktl)
3113  s->streams[pktl->pkt.stream_index]->last_in_packet_buffer = pktl;
3114  last = pktl;
3115  pktl = pktl->next;
3116  stream_count--;
3117  }
3118  // purge packet queue
3119  while (pktl) {
3120  AVPacketList *next = pktl->next;
3121  av_packet_unref(&pktl->pkt);
3122  av_freep(&pktl);
3123  pktl = next;
3124  }
3125  if (last)
3126  last->next = NULL;
3127  else {
3128  s->internal->packet_buffer = NULL;
3130  goto out;
3131  }
3132  pktl = s->internal->packet_buffer;
3133  }
3134 
3135  *out = pktl->pkt;
3136  av_log(s, AV_LOG_TRACE, "out st:%d dts:%"PRId64"\n", (*out).stream_index, (*out).dts);
3137  s->internal->packet_buffer = pktl->next;
3138  if(s->streams[pktl->pkt.stream_index]->last_in_packet_buffer == pktl)
3140  if(!s->internal->packet_buffer)
3142  av_freep(&pktl);
3143  return 1;
3144  } else {
3145  out:
3146  av_init_packet(out);
3147  return 0;
3148  }
3149 }
3150 
3152  const AVPacket *pkt)
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:2072
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:466
uint32_t tagged_value_count
Definition: mxfenc.c:359
#define NULL
Definition: coverity.c:32
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:4038
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:472
MXFMetadataSetType
Definition: mxf.h:30
Bytestream IO Context.
Definition: avio.h:161
enum AVColorTransferCharacteristic color_trc
Definition: avcodec.h:4045
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:4892
UID codec_ul
Definition: mxfenc.c:2036
AVRational sample_aspect_ratio
Video only.
Definition: avcodec.h:4033
unsigned body_partitions_count
Definition: mxfenc.c:346
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3957
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:2485
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:3004
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:3008
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:3949
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:2498
static struct @315 state
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 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:2884
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:372
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
static unsigned klv_fill_size(uint64_t size)
Definition: mxfenc.c: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:4023
AVOptions.
static const UID mxf_mpeg2_codec_uls[]
Definition: mxfenc.c:2360
#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
static const struct @276 mxf_dnxhd_codec_uls[]
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
static const struct @277 mxf_h264_codec_uls[]
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:1181
#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:3986
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:5659
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1514
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:2731
#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:2035
Definition: mxf.h:42
static int64_t mxf_write_wav_common(AVFormatContext *s, AVStream *st, const UID key)
Definition: mxfenc.c:1509
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:3953
int header_written
Definition: mxfenc.c:339
static void mxf_write_random_index_pack(AVFormatContext *s)
Definition: mxfenc.c:3001
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:2812
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:2780
static const uint8_t primer_pack_key[]
Definition: mxfenc.c:375
static const uint8_t system_metadata_pack_key[]
Definition: mxfenc.c:2728
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:2218
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:4074
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:2245
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:2217
static int mxf_parse_dnxhd_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:2097
#define LIBAVFORMAT_VERSION_MICRO
Definition: version.h:36
#define FF_PROFILE_PRORES_STANDARD
Definition: avcodec.h:3005
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:490
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 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:4043
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:2729
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:2457
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:105
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int content_package_rate
content package rate in system element, see SMPTE 326M
Definition: mxfenc.c: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:3007
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:2215
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:2393
uint8_t profile_idc
Definition: avc.h:41
const UID * codec_ul
Definition: mxfenc.c:85
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
Timecode helpers header.
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:196
int samples_per_frame[6]
Definition: mxf.h:87
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
static const struct @275 mxf_prores_codec_uls[]
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:2373
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:3006
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
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:478
#define flags(name, subs,...)
Definition: cbs_av1.c:561
static int mxf_parse_prores_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:2046
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 const struct @274 mxf_essence_mappings[]
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:3096
int sample_rate
Audio only.
Definition: avcodec.h:4067
#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
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:4017
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
static int mxf_compare_timestamps(AVFormatContext *s, const AVPacket *next, const AVPacket *pkt)
Definition: mxfenc.c:3151
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
int ff_audio_rechunk_interleave(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush, int(*get_packet)(AVFormatContext *, AVPacket *, AVPacket *, int), int(*compare_ts)(AVFormatContext *, const AVPacket *, const AVPacket *))
Rechunk audio PCM packets per AudioInterleaveContext->samples_per_frame and interleave them correctly...
char * value
Definition: dict.h:87
int len
void * priv_data
Format private data.
Definition: avformat.h: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:2473
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:2863
static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1524
int channels
Audio only.
Definition: avcodec.h:4063
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:380
#define FF_PROFILE_PRORES_PROXY
Definition: avcodec.h:3003
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:2833
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:2151
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:3028
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