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