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