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 <math.h>
42 #include <time.h>
43 
44 #include "libavutil/opt.h"
45 #include "libavutil/random_seed.h"
46 #include "libavutil/timecode.h"
47 #include "libavutil/avassert.h"
48 #include "libavutil/mastering_display_metadata.h"
49 #include "libavutil/pixdesc.h"
50 #include "libavutil/time_internal.h"
51 #include "libavcodec/bytestream.h"
52 #include "libavcodec/dv_profile.h"
53 #include "libavcodec/h264_ps.h"
54 #include "libavcodec/golomb.h"
55 #include "libavcodec/internal.h"
56 #include "libavcodec/packet_internal.h"
57 #include "avformat.h"
58 #include "avio_internal.h"
59 #include "internal.h"
60 #include "avc.h"
61 #include "mxf.h"
62 #include "config.h"
63 
64 extern const AVOutputFormat ff_mxf_d10_muxer;
65 extern const AVOutputFormat ff_mxf_opatom_muxer;
66 
67 #define EDIT_UNITS_PER_BODY 250
68 #define KAG_SIZE 512
69 
70 typedef struct MXFIndexEntry {
71  uint64_t offset;
72  unsigned slice_offset; ///< offset of audio slice
73  uint16_t temporal_ref;
74  uint8_t flags;
75 } MXFIndexEntry;
76 
77 typedef struct MXFStreamContext {
78  int64_t pkt_cnt; ///< pkt counter for muxed packets
79  UID track_essence_element_key;
80  int index; ///< index in mxf_essence_container_uls table
81  const UID *codec_ul;
82  const UID *container_ul;
83  int order; ///< interleaving order if dts are equal
84  int interlaced; ///< whether picture is interlaced
85  int field_dominance; ///< tff=1, bff=2
86  int component_depth;
87  int color_siting;
88  int signal_standard;
89  int h_chroma_sub_sample;
90  int v_chroma_sub_sample;
91  int temporal_reordering;
92  AVRational aspect_ratio; ///< display aspect ratio
93  int closed_gop; ///< gop is closed, used in mpeg-2 frame parsing
94  int video_bit_rate;
95  int slice_offset;
96  int frame_size; ///< frame size in bytes
97  int seq_closed_gop; ///< all gops in sequence are closed, used in mpeg-2 descriptor
98  int max_gop; ///< maximum gop size, used by mpeg-2 descriptor
99  int b_picture_count; ///< maximum number of consecutive b pictures, used in mpeg-2 descriptor
100  int low_delay; ///< low delay, used in mpeg-2 descriptor
101  int avc_intra;
102 } MXFStreamContext;
103 
104 typedef struct MXFContainerEssenceEntry {
105  UID container_ul;
106  UID element_ul;
107  UID codec_ul;
108  void (*write_desc)(AVFormatContext *, AVStream *);
109 } MXFContainerEssenceEntry;
110 
111 typedef struct MXFPackage {
112  char *name;
113  enum MXFMetadataSetType type;
114  int instance;
115  struct MXFPackage *ref;
116 } MXFPackage;
117 
118 enum ULIndex {
119  INDEX_MPEG2 = 0,
120  INDEX_AES3,
121  INDEX_WAV,
122  INDEX_D10_VIDEO,
123  INDEX_D10_AUDIO,
124  INDEX_DV,
125  INDEX_DNXHD,
126  INDEX_JPEG2000,
127  INDEX_H264,
128  INDEX_S436M,
129  INDEX_PRORES,
130 };
131 
132 static const struct {
133  enum AVCodecID id;
134  enum ULIndex index;
135 } mxf_essence_mappings[] = {
136  { AV_CODEC_ID_MPEG2VIDEO, INDEX_MPEG2 },
137  { AV_CODEC_ID_PCM_S24LE, INDEX_AES3 },
138  { AV_CODEC_ID_PCM_S16LE, INDEX_AES3 },
139  { AV_CODEC_ID_DVVIDEO, INDEX_DV },
140  { AV_CODEC_ID_DNXHD, INDEX_DNXHD },
141  { AV_CODEC_ID_JPEG2000, INDEX_JPEG2000 },
142  { AV_CODEC_ID_H264, INDEX_H264 },
143  { AV_CODEC_ID_PRORES, INDEX_PRORES },
144  { AV_CODEC_ID_NONE }
145 };
146 
147 static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st);
148 static void mxf_write_aes3_desc(AVFormatContext *s, AVStream *st);
149 static void mxf_write_mpegvideo_desc(AVFormatContext *s, AVStream *st);
150 static void mxf_write_h264_desc(AVFormatContext *s, AVStream *st);
151 static void mxf_write_cdci_desc(AVFormatContext *s, AVStream *st);
152 static void mxf_write_generic_sound_desc(AVFormatContext *s, AVStream *st);
153 static void mxf_write_s436m_anc_desc(AVFormatContext *s, AVStream *st);
154 
155 static const MXFContainerEssenceEntry mxf_essence_container_uls[] = {
156  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x60,0x01 },
157  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x15,0x01,0x05,0x00 },
158  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x00,0x00,0x00 },
159  mxf_write_mpegvideo_desc },
160  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x03,0x00 },
161  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x16,0x01,0x03,0x00 },
162  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
163  mxf_write_aes3_desc },
164  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x01,0x00 },
165  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x16,0x01,0x01,0x00 },
166  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
167  mxf_write_wav_desc },
168  // D-10 Video
169  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 },
170  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x05,0x01,0x01,0x00 },
171  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x01 },
172  mxf_write_cdci_desc },
173  // D-10 Audio
174  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 },
175  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x06,0x01,0x10,0x00 },
176  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 },
177  mxf_write_generic_sound_desc },
178  // DV
179  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x7F,0x01 },
180  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x18,0x01,0x01,0x00 },
181  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x00,0x00,0x00 },
182  mxf_write_cdci_desc },
183  // DNxHD
184  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0A,0x0D,0x01,0x03,0x01,0x02,0x11,0x01,0x00 },
185  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x15,0x01,0x0C,0x00 },
186  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x71,0x01,0x00,0x00 },
187  mxf_write_cdci_desc },
188  // JPEG2000
189  { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 },
190  { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01,0x15,0x01,0x08,0x00 },
191  { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 },
192  mxf_write_cdci_desc },
193  // H.264
194  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x0D,0x01,0x03,0x01,0x02,0x10,0x60,0x01 },
195  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x15,0x01,0x05,0x00 },
196  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x00,0x00,0x00 },
197  mxf_write_h264_desc },
198  // S436M ANC
199  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x0D,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 },
200  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x17,0x01,0x02,0x00 },
201  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x01,0x5C,0x00 },
202  mxf_write_s436m_anc_desc },
203  // ProRes
204  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x0d,0x01,0x03,0x01,0x02,0x1c,0x01,0x00 },
205  { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01,0x15,0x01,0x17,0x00 },
206  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x03,0x00 },
207  mxf_write_cdci_desc },
208  { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
209  { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
210  { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
211  NULL },
212 };
213 
214 static const UID mxf_d10_codec_uls[] = {
215  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x01 }, // D-10 625/50 PAL 50mb/s
216  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x02 }, // D-10 525/50 NTSC 50mb/s
217  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x03 }, // D-10 625/50 PAL 40mb/s
218  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x04 }, // D-10 525/50 NTSC 40mb/s
219  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x05 }, // D-10 625/50 PAL 30mb/s
220  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x01,0x02,0x01,0x06 }, // D-10 525/50 NTSC 30mb/s
221 };
222 
223 static const UID mxf_d10_container_uls[] = {
224  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, // D-10 625/50 PAL 50mb/s
225  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x02,0x01 }, // D-10 525/50 NTSC 50mb/s
226  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x03,0x01 }, // D-10 625/50 PAL 40mb/s
227  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x04,0x01 }, // D-10 525/50 NTSC 40mb/s
228  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x05,0x01 }, // D-10 625/50 PAL 30mb/s
229  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x06,0x01 }, // D-10 525/50 NTSC 30mb/s
230 };
231 
232 static const uint8_t uuid_base[] = { 0xAD,0xAB,0x44,0x24,0x2f,0x25,0x4d,0xc7,0x92,0xff,0x29,0xbd };
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, 12);
430  avio_wb16(pb, type);
431  avio_wb16(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  mxf_write_uuid(pb, Identification, 2);
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) && (st->codecpar->channels != 4) && (st->codecpar->channels != 8))
1459  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");
1460  avio_wb32(pb, st->codecpar->channels);
1461  } else if (s->oformat == &ff_mxf_d10_muxer) {
1462  if (show_warnings && (mxf->channel_count < st->codecpar->channels))
1463  av_log(s, AV_LOG_WARNING, "d10_channelcount < actual number of audio channels : some channels will be discarded\n");
1464  if (show_warnings && (mxf->channel_count != 4) && (mxf->channel_count != 8))
1465  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");
1466  avio_wb32(pb, mxf->channel_count);
1467  } else {
1468  avio_wb32(pb, st->codecpar->channels);
1469  }
1470 
1471  mxf_write_local_tag(s, 4, 0x3D01);
1472  avio_wb32(pb, av_get_bits_per_sample(st->codecpar->codec_id));
1473 
1474  return pos;
1475 }
1476 
1477 static int64_t mxf_write_wav_common(AVFormatContext *s, AVStream *st, const UID key)
1478 {
1479  AVIOContext *pb = s->pb;
1480  int64_t pos = mxf_write_generic_sound_common(s, st, key);
1481 
1482  mxf_write_local_tag(s, 2, 0x3D0A);
1483  avio_wb16(pb, st->codecpar->block_align);
1484 
1485  // avg bytes per sec
1486  mxf_write_local_tag(s, 4, 0x3D09);
1487  avio_wb32(pb, st->codecpar->block_align*st->codecpar->sample_rate);
1488 
1489  return pos;
1490 }
1491 
1492 static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st)
1493 {
1494  int64_t pos = mxf_write_wav_common(s, st, mxf_wav_descriptor_key);
1495  mxf_update_klv_size(s->pb, pos);
1496 }
1497 
1498 static void mxf_write_aes3_desc(AVFormatContext *s, AVStream *st)
1499 {
1500  int64_t pos = mxf_write_wav_common(s, st, mxf_aes3_descriptor_key);
1501  mxf_update_klv_size(s->pb, pos);
1502 }
1503 
1504 static void mxf_write_generic_sound_desc(AVFormatContext *s, AVStream *st)
1505 {
1506  int64_t pos = mxf_write_generic_sound_common(s, st, mxf_generic_sound_descriptor_key);
1507  mxf_update_klv_size(s->pb, pos);
1508 }
1509 
1510 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 };
1511 
1512 static int mxf_write_tagged_value(AVFormatContext *s, const char* name, const char* value)
1513 {
1514  MXFContext *mxf = s->priv_data;
1515  AVIOContext *pb = s->pb;
1516  int name_size = mxf_utf16_local_tag_length(name);
1517  int indirect_value_size = 13 + mxf_utf16_local_tag_length(value);
1518 
1519  if (!name_size || indirect_value_size == 13)
1520  return 1;
1521 
1522  mxf_write_metadata_key(pb, 0x013f00);
1523  klv_encode_ber_length(pb, 24 + name_size + indirect_value_size);
1524 
1525  // write instance UID
1526  mxf_write_local_tag(s, 16, 0x3C0A);
1527  mxf_write_uuid(pb, TaggedValue, mxf->tagged_value_count);
1528 
1529  // write name
1530  mxf_write_local_tag_utf16(s, 0x5001, name); // Name
1531 
1532  // write indirect value
1533  mxf_write_local_tag(s, indirect_value_size, 0x5003);
1534  avio_write(pb, mxf_indirect_value_utf16le, 17);
1535  avio_put_str16le(pb, value);
1536 
1537  mxf->tagged_value_count++;
1538  return 0;
1539 }
1540 
1541 static int mxf_write_user_comments(AVFormatContext *s, const AVDictionary *m)
1542 {
1543  MXFContext *mxf = s->priv_data;
1544  AVDictionaryEntry *t = NULL;
1545  int count = 0;
1546 
1547  while ((t = av_dict_get(m, "comment_", t, AV_DICT_IGNORE_SUFFIX))) {
1548  if (mxf->tagged_value_count >= UINT16_MAX) {
1549  av_log(s, AV_LOG_ERROR, "too many tagged values, ignoring remaining\n");
1550  return count;
1551  }
1552 
1553  if (mxf_write_tagged_value(s, t->key + 8, t->value) == 0)
1554  count++;
1555  }
1556  return count;
1557 }
1558 
1559 static void mxf_write_package(AVFormatContext *s, MXFPackage *package)
1560 {
1561  MXFContext *mxf = s->priv_data;
1562  AVIOContext *pb = s->pb;
1563  int i, track_count = s->nb_streams+1;
1564  int name_size = mxf_utf16_local_tag_length(package->name);
1565  int user_comment_count = 0;
1566 
1567  if (package->type == MaterialPackage) {
1568  if (mxf->store_user_comments)
1569  user_comment_count = mxf_write_user_comments(s, s->metadata);
1570  mxf_write_metadata_key(pb, 0x013600);
1571  PRINT_KEY(s, "Material Package key", pb->buf_ptr - 16);
1572  klv_encode_ber_length(pb, 92 + name_size + (16*track_count) + (16*user_comment_count) + 12LL*mxf->store_user_comments);
1573  } else {
1574  mxf_write_metadata_key(pb, 0x013700);
1575  PRINT_KEY(s, "Source Package key", pb->buf_ptr - 16);
1576  klv_encode_ber_length(pb, 112 + name_size + (16*track_count) + 12LL*mxf->store_user_comments); // 20 bytes length for descriptor reference
1577  }
1578 
1579  // write uid
1580  mxf_write_local_tag(s, 16, 0x3C0A);
1581  mxf_write_uuid(pb, package->type, package->instance);
1582  av_log(s, AV_LOG_DEBUG, "package type:%d\n", package->type);
1583  PRINT_KEY(s, "package uid", pb->buf_ptr - 16);
1584 
1585  // write package umid
1586  mxf_write_local_tag(s, 32, 0x4401);
1587  mxf_write_umid(s, package->instance);
1588  PRINT_KEY(s, "package umid second part", pb->buf_ptr - 16);
1589 
1590  // package name
1591  if (name_size)
1592  mxf_write_local_tag_utf16(s, 0x4402, package->name);
1593 
1594  // package creation date
1595  mxf_write_local_tag(s, 8, 0x4405);
1596  avio_wb64(pb, mxf->timestamp);
1597 
1598  // package modified date
1599  mxf_write_local_tag(s, 8, 0x4404);
1600  avio_wb64(pb, mxf->timestamp);
1601 
1602  // write track refs
1603  mxf_write_local_tag(s, track_count*16 + 8, 0x4403);
1604  mxf_write_refs_count(pb, track_count);
1605  // these are the uuids of the tracks the will be written in mxf_write_track
1606  for (i = 0; i < track_count; i++)
1607  mxf_write_uuid(pb, Track, mxf->track_instance_count + i);
1608 
1609  // write user comment refs
1610  if (mxf->store_user_comments) {
1611  mxf_write_local_tag(s, user_comment_count*16 + 8, 0x4406);
1612  mxf_write_refs_count(pb, user_comment_count);
1613  for (i = 0; i < user_comment_count; i++)
1614  mxf_write_uuid(pb, TaggedValue, mxf->tagged_value_count - user_comment_count + i);
1615  }
1616 
1617  // write multiple descriptor reference
1618  if (package->type == SourcePackage && package->instance == 1) {
1619  mxf_write_local_tag(s, 16, 0x4701);
1620  if (s->nb_streams > 1) {
1621  mxf_write_uuid(pb, MultipleDescriptor, 0);
1622  mxf_write_multi_descriptor(s);
1623  } else
1624  mxf_write_uuid(pb, SubDescriptor, 0);
1625  } else if (package->type == SourcePackage && package->instance == 2) {
1626  mxf_write_local_tag(s, 16, 0x4701);
1627  mxf_write_uuid(pb, TapeDescriptor, 0);
1628  mxf_write_tape_descriptor(s);
1629  }
1630 
1631  /*
1632  * for every 1 track in a package there is 1 sequence and 1 component.
1633  * all 3 of these elements share the same instance number for generating
1634  * there instance uuids. mxf->track_instance_count stores this value.
1635  * mxf->track_instance_count is incremented after a group of all 3 of
1636  * these elements are written.
1637  */
1638 
1639  // write timecode track
1640  mxf_write_track(s, mxf->timecode_track, package);
1641  mxf_write_sequence(s, mxf->timecode_track, package);
1642  mxf_write_timecode_component(s, mxf->timecode_track, package);
1643  mxf->track_instance_count++;
1644 
1645  for (i = 0; i < s->nb_streams; i++) {
1646  AVStream *st = s->streams[i];
1647  mxf_write_track(s, st, package);
1648  mxf_write_sequence(s, st, package);
1649  mxf_write_structural_component(s, st, package);
1650  mxf->track_instance_count++;
1651 
1652  if (package->type == SourcePackage && package->instance == 1) {
1653  MXFStreamContext *sc = st->priv_data;
1654  mxf_essence_container_uls[sc->index].write_desc(s, st);
1655  }
1656  }
1657 }
1658 
1659 static int mxf_write_essence_container_data(AVFormatContext *s)
1660 {
1661  AVIOContext *pb = s->pb;
1662 
1663  mxf_write_metadata_key(pb, 0x012300);
1664  klv_encode_ber_length(pb, 72);
1665 
1666  mxf_write_local_tag(s, 16, 0x3C0A); // Instance UID
1667  mxf_write_uuid(pb, EssenceContainerData, 0);
1668 
1669  mxf_write_local_tag(s, 32, 0x2701); // Linked Package UID
1670  mxf_write_umid(s, 1);
1671 
1672  mxf_write_local_tag(s, 4, 0x3F07); // BodySID
1673  avio_wb32(pb, 1);
1674 
1675  mxf_write_local_tag(s, 4, 0x3F06); // IndexSID
1676  avio_wb32(pb, 2);
1677 
1678  return 0;
1679 }
1680 
1681 static int mxf_write_header_metadata_sets(AVFormatContext *s)
1682 {
1683  MXFContext *mxf = s->priv_data;
1684  AVDictionaryEntry *entry = NULL;
1685  AVStream *st = NULL;
1686  int i;
1687  MXFPackage packages[3] = {{0}};
1688  int package_count = 2;
1689  packages[0].type = MaterialPackage;
1690  packages[1].type = SourcePackage;
1691  packages[1].instance = 1;
1692  packages[0].ref = &packages[1];
1693 
1694 
1695  if (entry = av_dict_get(s->metadata, "material_package_name", NULL, 0))
1696  packages[0].name = entry->value;
1697 
1698  if (entry = av_dict_get(s->metadata, "file_package_name", NULL, 0)) {
1699  packages[1].name = entry->value;
1700  } else {
1701  /* check if any of the streams contain a file_package_name */
1702  for (i = 0; i < s->nb_streams; i++) {
1703  st = s->streams[i];
1704  if (entry = av_dict_get(st->metadata, "file_package_name", NULL, 0)) {
1705  packages[1].name = entry->value;
1706  break;
1707  }
1708  }
1709  }
1710 
1711  entry = av_dict_get(s->metadata, "reel_name", NULL, 0);
1712  if (entry) {
1713  packages[2].name = entry->value;
1714  packages[2].type = SourcePackage;
1715  packages[2].instance = 2;
1716  packages[1].ref = &packages[2];
1717  package_count = 3;
1718  }
1719 
1720  mxf_write_preface(s);
1721  mxf_write_identification(s);
1722  mxf_write_content_storage(s, packages, package_count);
1723  mxf->track_instance_count = 0;
1724  for (i = 0; i < package_count; i++)
1725  mxf_write_package(s, &packages[i]);
1726  mxf_write_essence_container_data(s);
1727  return 0;
1728 }
1729 
1730 static unsigned klv_fill_size(uint64_t size)
1731 {
1732  unsigned pad = KAG_SIZE - (size & (KAG_SIZE-1));
1733  if (pad < 20) // smallest fill item possible
1734  return pad + KAG_SIZE;
1735  else
1736  return pad & (KAG_SIZE-1);
1737 }
1738 
1739 static void mxf_write_index_table_segment(AVFormatContext *s)
1740 {
1741  MXFContext *mxf = s->priv_data;
1742  AVIOContext *pb = s->pb;
1743  int i, j, temporal_reordering = 0;
1744  int key_index = mxf->last_key_index;
1745  int prev_non_b_picture = 0;
1746  int audio_frame_size = 0;
1747  int64_t pos;
1748 
1749  av_log(s, AV_LOG_DEBUG, "edit units count %d\n", mxf->edit_units_count);
1750 
1751  if (!mxf->edit_units_count && !mxf->edit_unit_byte_count)
1752  return;
1753 
1754  avio_write(pb, index_table_segment_key, 16);
1755 
1756  klv_encode_ber4_length(pb, 0);
1757  pos = avio_tell(pb);
1758 
1759  // instance id
1760  mxf_write_local_tag(s, 16, 0x3C0A);
1761  mxf_write_uuid(pb, IndexTableSegment, 0);
1762 
1763  // index edit rate
1764  mxf_write_local_tag(s, 8, 0x3F0B);
1765  avio_wb32(pb, mxf->time_base.den);
1766  avio_wb32(pb, mxf->time_base.num);
1767 
1768  // index start position
1769  mxf_write_local_tag(s, 8, 0x3F0C);
1770  avio_wb64(pb, mxf->last_indexed_edit_unit);
1771 
1772  // index duration
1773  mxf_write_local_tag(s, 8, 0x3F0D);
1774  if (mxf->edit_unit_byte_count)
1775  avio_wb64(pb, 0); // index table covers whole container
1776  else
1777  avio_wb64(pb, mxf->edit_units_count);
1778 
1779  // edit unit byte count
1780  mxf_write_local_tag(s, 4, 0x3F05);
1781  avio_wb32(pb, mxf->edit_unit_byte_count);
1782 
1783  // index sid
1784  mxf_write_local_tag(s, 4, 0x3F06);
1785  avio_wb32(pb, 2);
1786 
1787  // body sid
1788  mxf_write_local_tag(s, 4, 0x3F07);
1789  avio_wb32(pb, 1);
1790 
1791  // real slice count - 1
1792  mxf_write_local_tag(s, 1, 0x3F08);
1793  avio_w8(pb, !mxf->edit_unit_byte_count); // only one slice for CBR
1794 
1795  // delta entry array
1796  mxf_write_local_tag(s, 8 + (s->nb_streams+1)*6, 0x3F09);
1797  avio_wb32(pb, s->nb_streams+1); // num of entries
1798  avio_wb32(pb, 6); // size of one entry
1799  // write system item delta entry
1800  avio_w8(pb, 0);
1801  avio_w8(pb, 0); // slice entry
1802  avio_wb32(pb, 0); // element delta
1803  // write each stream delta entry
1804  for (i = 0; i < s->nb_streams; i++) {
1805  AVStream *st = s->streams[i];
1806  MXFStreamContext *sc = st->priv_data;
1807  avio_w8(pb, sc->temporal_reordering);
1808  if (sc->temporal_reordering)
1809  temporal_reordering = 1;
1810  if (mxf->edit_unit_byte_count) {
1811  avio_w8(pb, 0); // slice number
1812  avio_wb32(pb, sc->slice_offset);
1813  } else if (i == 0) { // video track
1814  avio_w8(pb, 0); // slice number
1815  avio_wb32(pb, KAG_SIZE); // system item size including klv fill
1816  } else { // audio or data track
1817  if (!audio_frame_size) {
1818  audio_frame_size = sc->frame_size;
1819  audio_frame_size += klv_fill_size(audio_frame_size);
1820  }
1821  avio_w8(pb, 1);
1822  avio_wb32(pb, (i-1)*audio_frame_size); // element delta
1823  }
1824  }
1825 
1826  if (!mxf->edit_unit_byte_count) {
1827  MXFStreamContext *sc = s->streams[0]->priv_data;
1828  mxf_write_local_tag(s, 8 + mxf->edit_units_count*15, 0x3F0A);
1829  avio_wb32(pb, mxf->edit_units_count); // num of entries
1830  avio_wb32(pb, 15); // size of one entry
1831 
1832  for (i = 0; i < mxf->edit_units_count; i++) {
1833  int temporal_offset = 0;
1834 
1835  if (!(mxf->index_entries[i].flags & 0x33)) { // I-frame
1836  sc->max_gop = FFMAX(sc->max_gop, i - mxf->last_key_index);
1837  mxf->last_key_index = key_index;
1838  key_index = i;
1839  }
1840 
1841  if (temporal_reordering) {
1842  int pic_num_in_gop = i - key_index;
1843  if (pic_num_in_gop != mxf->index_entries[i].temporal_ref) {
1844  for (j = key_index; j < mxf->edit_units_count; j++) {
1845  if (pic_num_in_gop == mxf->index_entries[j].temporal_ref)
1846  break;
1847  }
1848  if (j == mxf->edit_units_count)
1849  av_log(s, AV_LOG_WARNING, "missing frames\n");
1850  temporal_offset = j - key_index - pic_num_in_gop;
1851  }
1852  }
1853  avio_w8(pb, temporal_offset);
1854 
1855  if ((mxf->index_entries[i].flags & 0x30) == 0x30) { // back and forward prediction
1856  sc->b_picture_count = FFMAX(sc->b_picture_count, i - prev_non_b_picture);
1857  avio_w8(pb, mxf->last_key_index - i);
1858  } else {
1859  avio_w8(pb, key_index - i); // key frame offset
1860  if ((mxf->index_entries[i].flags & 0x20) == 0x20) // only forward
1861  mxf->last_key_index = key_index;
1862  prev_non_b_picture = i;
1863  }
1864 
1865  if (!(mxf->index_entries[i].flags & 0x33) && // I-frame
1866  mxf->index_entries[i].flags & 0x40 && !temporal_offset)
1867  mxf->index_entries[i].flags |= 0x80; // random access
1868  avio_w8(pb, mxf->index_entries[i].flags);
1869  // stream offset
1870  avio_wb64(pb, mxf->index_entries[i].offset);
1871  if (s->nb_streams > 1)
1872  avio_wb32(pb, mxf->index_entries[i].slice_offset);
1873  else
1874  avio_wb32(pb, 0);
1875  }
1876 
1877  mxf->last_key_index = key_index - mxf->edit_units_count;
1878  mxf->last_indexed_edit_unit += mxf->edit_units_count;
1879  mxf->edit_units_count = 0;
1880  }
1881 
1882  mxf_update_klv_size(pb, pos);
1883 }
1884 
1885 static void mxf_write_klv_fill(AVFormatContext *s)
1886 {
1887  unsigned pad = klv_fill_size(avio_tell(s->pb));
1888  if (pad) {
1889  avio_write(s->pb, klv_fill_key, 16);
1890  pad -= 16 + 4;
1891  klv_encode_ber4_length(s->pb, pad);
1892  ffio_fill(s->pb, 0, pad);
1893  av_assert1(!(avio_tell(s->pb) & (KAG_SIZE-1)));
1894  }
1895 }
1896 
1897 static int mxf_write_partition(AVFormatContext *s, int bodysid,
1898  int indexsid,
1899  const uint8_t *key, int write_metadata)
1900 {
1901  MXFContext *mxf = s->priv_data;
1902  AVIOContext *pb = s->pb;
1903  int64_t header_byte_count_offset;
1904  unsigned index_byte_count = 0;
1905  uint64_t partition_offset = avio_tell(pb);
1906  int err;
1907 
1908  if (!mxf->edit_unit_byte_count && mxf->edit_units_count)
1909  index_byte_count = 85 + 12+(s->nb_streams+1)*6 +
1910  12+mxf->edit_units_count*15;
1911  else if (mxf->edit_unit_byte_count && indexsid)
1912  index_byte_count = 80;
1913 
1914  if (index_byte_count) {
1915  index_byte_count += 16 + 4; // add encoded ber4 length
1916  index_byte_count += klv_fill_size(index_byte_count);
1917  }
1918 
1919  if (key && !memcmp(key, body_partition_key, 16)) {
1920  if ((err = av_reallocp_array(&mxf->body_partition_offset, mxf->body_partitions_count + 1,
1921  sizeof(*mxf->body_partition_offset))) < 0) {
1922  mxf->body_partitions_count = 0;
1923  return err;
1924  }
1925  mxf->body_partition_offset[mxf->body_partitions_count++] = partition_offset;
1926  }
1927 
1928  // write klv
1929  if (key)
1930  avio_write(pb, key, 16);
1931  else
1932  avio_write(pb, body_partition_key, 16);
1933 
1934  klv_encode_ber4_length(pb, 88 + 16LL * DESCRIPTOR_COUNT(mxf->essence_container_count));
1935 
1936  // write partition value
1937  avio_wb16(pb, 1); // majorVersion
1938  avio_wb16(pb, 3); // minorVersion
1939  avio_wb32(pb, KAG_SIZE); // KAGSize
1940 
1941  avio_wb64(pb, partition_offset); // ThisPartition
1942 
1943  if (key && !memcmp(key, body_partition_key, 16) && mxf->body_partitions_count > 1)
1944  avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-2]); // PreviousPartition
1945  else if (key && !memcmp(key, footer_partition_key, 16) && mxf->body_partitions_count)
1946  avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-1]); // PreviousPartition
1947  else
1948  avio_wb64(pb, 0);
1949 
1950  avio_wb64(pb, mxf->footer_partition_offset); // footerPartition
1951 
1952  // set offset
1953  header_byte_count_offset = avio_tell(pb);
1954  avio_wb64(pb, 0); // headerByteCount, update later
1955 
1956  // indexTable
1957  avio_wb64(pb, index_byte_count); // indexByteCount
1958  avio_wb32(pb, index_byte_count ? indexsid : 0); // indexSID
1959 
1960  // BodyOffset
1961  if (bodysid && mxf->edit_units_count && mxf->body_partitions_count && s->oformat != &ff_mxf_opatom_muxer)
1962  avio_wb64(pb, mxf->body_offset);
1963  else
1964  avio_wb64(pb, 0);
1965 
1966  avio_wb32(pb, bodysid); // bodySID
1967 
1968  // operational pattern
1969  if (s->oformat == &ff_mxf_opatom_muxer)
1970  avio_write(pb, opatom_ul, 16);
1971  else
1972  avio_write(pb, op1a_ul, 16);
1973 
1974  // essence container
1975  mxf_write_essence_container_refs(s);
1976 
1977  if (write_metadata) {
1978  // mark the start of the headermetadata and calculate metadata size
1979  int64_t pos, start;
1980  unsigned header_byte_count;
1981 
1982  mxf_write_klv_fill(s);
1983  start = avio_tell(s->pb);
1984  mxf_write_primer_pack(s);
1985  mxf_write_klv_fill(s);
1986  mxf_write_header_metadata_sets(s);
1987  pos = avio_tell(s->pb);
1988  header_byte_count = pos - start + klv_fill_size(pos);
1989 
1990  // update header_byte_count
1991  avio_seek(pb, header_byte_count_offset, SEEK_SET);
1992  avio_wb64(pb, header_byte_count);
1993  avio_seek(pb, pos, SEEK_SET);
1994  }
1995 
1996  if(key)
1997  avio_write_marker(pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_FLUSH_POINT);
1998 
1999  return 0;
2000 }
2001 
2002 static const struct {
2003  int profile;
2004  UID codec_ul;
2005 } mxf_prores_codec_uls[] = {
2006  { FF_PROFILE_PRORES_PROXY, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x01,0x00 } },
2007  { FF_PROFILE_PRORES_LT, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x02,0x00 } },
2008  { FF_PROFILE_PRORES_STANDARD, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x03,0x00 } },
2009  { FF_PROFILE_PRORES_HQ, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x04,0x00 } },
2010  { FF_PROFILE_PRORES_4444, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x05,0x00 } },
2011  { FF_PROFILE_PRORES_XQ, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x06,0x00 } },
2012 };
2013 
2014 static int mxf_parse_prores_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
2015 {
2016  MXFContext *mxf = s->priv_data;
2017  MXFStreamContext *sc = st->priv_data;
2018  int i, profile;
2019 
2020  if (mxf->header_written)
2021  return 1;
2022 
2023  profile = st->codecpar->profile;
2024  for (i = 0; i < FF_ARRAY_ELEMS(mxf_prores_codec_uls); i++) {
2025  if (profile == mxf_prores_codec_uls[i].profile) {
2026  sc->codec_ul = &mxf_prores_codec_uls[i].codec_ul;
2027  break;
2028  }
2029  }
2030  if (i == FF_ARRAY_ELEMS(mxf_prores_codec_uls))
2031  return 0;
2032 
2033  sc->frame_size = pkt->size;
2034 
2035  return 1;
2036 }
2037 
2038 static const struct {
2039  uint16_t cid;
2040  uint8_t interlaced;
2041  UID codec_ul;
2042 } mxf_dnxhd_codec_uls[] = {
2043  { 1235, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x01,0x00,0x00 } }, // 1080p 10bit HIGH
2044  { 1237, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x03,0x00,0x00 } }, // 1080p 8bit MED
2045  { 1238, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x04,0x00,0x00 } }, // 1080p 8bit HIGH
2046  { 1241, 1, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x07,0x00,0x00 } }, // 1080i 10bit HIGH
2047  { 1242, 1, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x08,0x00,0x00 } }, // 1080i 8bit MED
2048  { 1243, 1, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x09,0x00,0x00 } }, // 1080i 8bit HIGH
2049  { 1244, 1, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x0a,0x00,0x00 } }, // 1080i 8bit TR
2050  { 1250, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x10,0x00,0x00 } }, // 720p 10bit
2051  { 1251, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x11,0x00,0x00 } }, // 720p 8bit HIGH
2052  { 1252, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x12,0x00,0x00 } }, // 720p 8bit MED
2053  { 1253, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x13,0x00,0x00 } }, // 720p 8bit LOW
2054  { 1256, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x16,0x00,0x00 } }, // 1080p 10bit 444
2055  { 1258, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x18,0x00,0x00 } }, // 720p 8bit TR
2056  { 1259, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x19,0x00,0x00 } }, // 1080p 8bit TR
2057  { 1260, 1, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x1a,0x00,0x00 } }, // 1080i 8bit TR MBAFF
2058  { 1270, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x24,0x00,0x00 } }, // DNXHR 444
2059  { 1271, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x25,0x00,0x00 } }, // DNXHR HQX
2060  { 1272, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x26,0x00,0x00 } }, // DNXHR HQ
2061  { 1273, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x27,0x00,0x00 } }, // DNXHR SQ
2062  { 1274, 0, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x71,0x28,0x00,0x00 } }, // DNXHR LB
2063 };
2064 
2065 static int mxf_parse_dnxhd_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
2066 {
2067  MXFContext *mxf = s->priv_data;
2068  MXFStreamContext *sc = st->priv_data;
2069  int i, cid;
2070 
2071  if (mxf->header_written)
2072  return 1;
2073 
2074  if (pkt->size < 43)
2075  return 0;
2076 
2077  cid = AV_RB32(pkt->data + 0x28);
2078  for (i = 0; i < FF_ARRAY_ELEMS(mxf_dnxhd_codec_uls); i++) {
2079  if (cid == mxf_dnxhd_codec_uls[i].cid) {
2080  sc->codec_ul = &mxf_dnxhd_codec_uls[i].codec_ul;
2081  sc->interlaced = mxf_dnxhd_codec_uls[i].interlaced;
2082  break;
2083  }
2084  }
2085  if (i == FF_ARRAY_ELEMS(mxf_dnxhd_codec_uls))
2086  return 0;
2087 
2088  sc->component_depth = 0;
2089  switch (pkt->data[0x21] >> 5) {
2090  case 1: sc->component_depth = 8; break;
2091  case 2: sc->component_depth = 10; break;
2092  case 3: sc->component_depth = 12; break;
2093  }
2094  if (!sc->component_depth)
2095  return 0;
2096 
2097  if (cid >= 1270) { // RI raster
2098  av_reduce(&sc->aspect_ratio.num, &sc->aspect_ratio.den,
2099  st->codecpar->width, st->codecpar->height,
2100  INT_MAX);
2101  } else {
2102  sc->aspect_ratio = (AVRational){ 16, 9 };
2103  }
2104 
2105  sc->frame_size = pkt->size;
2106 
2107  return 1;
2108 }
2109 
2110 static const struct {
2111  const UID container_ul;
2112  const UID codec_ul;
2113 } mxf_dv_uls[] = {
2114  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x01,0x01 }, // IEC DV25 525/60
2115  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x01,0x01,0x00 } },
2116  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x02,0x01 }, // IEC DV25 626/50
2117  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x01,0x02,0x00 } },
2118  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x40,0x01 }, // DV25 525/60
2119  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x01,0x00 }, },
2120  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, // DV25 625/50
2121  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x02,0x00 }, },
2122  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x50,0x01 }, // DV50 525/60
2123  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x03,0x00 }, },
2124  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x51,0x01 }, // DV50 625/50
2125  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x04,0x00 }, },
2126  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x60,0x01 }, // DV100 1080/60
2127  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x05,0x00 }, },
2128  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x61,0x01 }, // DV100 1080/50
2129  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x06,0x00 }, },
2130  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x62,0x01 }, // DV100 720/60
2131  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x07,0x00 }, },
2132  { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x63,0x01 }, // DV100 720/50
2133  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x08,0x00 }, },
2134 };
2135 
2136 static int mxf_parse_dv_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
2137 {
2138  MXFContext *mxf = s->priv_data;
2139  MXFStreamContext *sc = st->priv_data;
2140  uint8_t *vs_pack, *vsc_pack;
2141  int apt, ul_index, stype, pal;
2142 
2143  if (mxf->header_written)
2144  return 1;
2145 
2146  // Check for minimal frame size
2147  if (pkt->size < 120000)
2148  return -1;
2149 
2150  apt = pkt->data[4] & 0x7;
2151  vs_pack = pkt->data + 80*5 + 48;
2152  vsc_pack = pkt->data + 80*5 + 53;
2153  stype = vs_pack[3] & 0x1f;
2154  pal = (vs_pack[3] >> 5) & 0x1;
2155 
2156  if ((vsc_pack[2] & 0x07) == 0x02) {
2157  sc->aspect_ratio = (AVRational){ 16, 9 };
2158  } else {
2159  sc->aspect_ratio = (AVRational){ 4, 3 };
2160  }
2161 
2162  sc->interlaced = (vsc_pack[3] >> 4) & 0x01;
2163  // TODO: fix dv encoder to set proper FF/FS value in VSC pack
2164  // and set field dominance accordingly
2165  // av_log(s, AV_LOG_DEBUG, "DV vsc pack ff/ss = %x\n", vsc_pack[2] >> 6);
2166 
2167  switch (stype) {
2168  case 0x18: // DV100 720p
2169  ul_index = 8+pal;
2170  if (sc->interlaced) {
2171  av_log(s, AV_LOG_ERROR, "source marked as interlaced but codec profile is progressive\n");
2172  sc->interlaced = 0;
2173  }
2174  break;
2175  case 0x14: // DV100 1080i
2176  ul_index = 6+pal;
2177  break;
2178  case 0x04: // DV50
2179  ul_index = 4+pal;
2180  break;
2181  default: // DV25
2182  if (!apt) { // IEC
2183  ul_index = 0+pal;
2184  } else {
2185  ul_index = 2+pal;
2186  }
2187  }
2188 
2189  sc->container_ul = &mxf_dv_uls[ul_index].container_ul;
2190  sc->codec_ul = &mxf_dv_uls[ul_index].codec_ul;
2191 
2192  sc->frame_size = pkt->size;
2193 
2194  return 1;
2195 }
2196 
2197 static const struct {
2198  UID uid;
2199  int frame_size;
2200  uint8_t profile;
2201  uint8_t interlaced;
2202  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
2203 } mxf_h264_codec_uls[] = {
2204  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x11,0x01 }, 0, 66, 0, -1 }, // AVC Baseline
2205  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x20,0x01 }, 0, 77, 0, -1 }, // AVC Main
2206  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x30,0x01 }, 0, 88, 0, -1 }, // AVC Extended
2207  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x40,0x01 }, 0, 100, 0, -1 }, // AVC High
2208  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x50,0x01 }, 0, 110, 0, 0 }, // AVC High 10
2209  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x60,0x01 }, 0, 122, 0, 0 }, // AVC High 422
2210  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x31,0x70,0x01 }, 0, 244, 0, 0 }, // AVC High 444
2211  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x20,0x01 }, 0, 110, 0, 1 }, // AVC High 10 Intra
2212  {{ 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
2213  {{ 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
2214  {{ 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
2215  {{ 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
2216  {{ 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
2217  {{ 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
2218  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0a,0x04,0x01,0x02,0x02,0x01,0x32,0x30,0x01 }, 0, 122, 0, 1 }, // AVC High 422 Intra
2219  {{ 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
2220  {{ 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
2221  {{ 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
2222  {{ 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
2223  {{ 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
2224  {{ 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
2225  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x01,0x32,0x40,0x01 }, 0, 244, 0, 1 }, // AVC High 444 Intra
2226  {{ 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x01,0x32,0x50,0x01 }, 0, 44, 0, -1 }, // AVC CAVLC 444
2227 };
2228 
2229 static int mxf_parse_h264_frame(AVFormatContext *s, AVStream *st,
2230  AVPacket *pkt, MXFIndexEntry *e)
2231 {
2232  MXFContext *mxf = s->priv_data;
2233  MXFStreamContext *sc = st->priv_data;
2234  H264SPS seq, *const sps = &seq;
2235  GetBitContext gb;
2236  const uint8_t *buf = pkt->data;
2237  const uint8_t *buf_end = pkt->data + pkt->size;
2238  const uint8_t *nal_end;
2239  const UID *codec_ul = NULL;
2240  uint32_t state = -1;
2241  int extra_size = 512; // support AVC Intra files without SPS/PPS header
2242  int i, frame_size, slice_type, has_sps = 0, intra_only = 0, ret;
2243 
2244  for (;;) {
2245  buf = avpriv_find_start_code(buf, buf_end, &state);
2246  if (buf >= buf_end)
2247  break;
2248 
2249  switch (state & 0x1f) {
2250  case H264_NAL_SPS:
2251  e->flags |= 0x40;
2252 
2253  if (mxf->header_written)
2254  break;
2255 
2256  nal_end = ff_avc_find_startcode(buf, buf_end);
2257  ret = ff_avc_decode_sps(sps, buf, nal_end - buf);
2258  if (ret < 0) {
2259  av_log(s, AV_LOG_ERROR, "error parsing sps\n");
2260  return 0;
2261  }
2262  has_sps = 1;
2263 
2264  sc->aspect_ratio.num = st->codecpar->width * sps->sar.num;
2265  sc->aspect_ratio.den = st->codecpar->height * sps->sar.den;
2266  av_reduce(&sc->aspect_ratio.num, &sc->aspect_ratio.den,
2267  sc->aspect_ratio.num, sc->aspect_ratio.den, 1024*1024);
2268  intra_only = (sps->constraint_set_flags >> 3) & 1;
2269  sc->interlaced = !sps->frame_mbs_only_flag;
2270  sc->component_depth = sps->bit_depth_luma;
2271 
2272  buf = nal_end;
2273  break;
2274  case H264_NAL_PPS:
2275  if (e->flags & 0x40) { // sequence header present
2276  e->flags |= 0x80; // random access
2277  extra_size = 0;
2278  }
2279  break;
2280  case H264_NAL_IDR_SLICE:
2281  e->flags |= 0x04; // IDR Picture
2282  buf = buf_end;
2283  break;
2284  case H264_NAL_SLICE:
2285  init_get_bits8(&gb, buf, buf_end - buf);
2286  get_ue_golomb_long(&gb); // skip first_mb_in_slice
2287  slice_type = get_ue_golomb_31(&gb);
2288  switch (slice_type % 5) {
2289  case 0:
2290  e->flags |= 0x20; // P Picture
2291  e->flags |= 0x06; // P Picture
2292  break;
2293  case 1:
2294  e->flags |= 0x30; // B Picture
2295  e->flags |= 0x03; // non-referenced B Picture
2296  break;
2297  }
2298  buf = buf_end;
2299  break;
2300  default:
2301  break;
2302  }
2303  }
2304 
2305  if (mxf->header_written)
2306  return 1;
2307 
2308  if (!has_sps)
2309  sc->interlaced = st->codecpar->field_order != AV_FIELD_PROGRESSIVE ? 1 : 0;
2310  frame_size = pkt->size + extra_size;
2311 
2312  for (i = 0; i < FF_ARRAY_ELEMS(mxf_h264_codec_uls); i++) {
2313  if (frame_size == mxf_h264_codec_uls[i].frame_size && sc->interlaced == mxf_h264_codec_uls[i].interlaced) {
2314  codec_ul = &mxf_h264_codec_uls[i].uid;
2315  sc->component_depth = 10; // AVC Intra is always 10 Bit
2316  sc->aspect_ratio = (AVRational){ 16, 9 }; // 16:9 is mandatory for broadcast HD
2317  st->codecpar->profile = mxf_h264_codec_uls[i].profile;
2318  sc->avc_intra = 1;
2319  mxf->cbr_index = 1;
2320  sc->frame_size = pkt->size;
2321  if (sc->interlaced)
2322  sc->field_dominance = 1; // top field first is mandatory for AVC Intra
2323  break;
2324  } else if (has_sps && mxf_h264_codec_uls[i].frame_size == 0 &&
2325  mxf_h264_codec_uls[i].profile == sps->profile_idc &&
2326  (mxf_h264_codec_uls[i].intra_only < 0 ||
2327  mxf_h264_codec_uls[i].intra_only == intra_only)) {
2328  codec_ul = &mxf_h264_codec_uls[i].uid;
2329  st->codecpar->profile = sps->profile_idc;
2330  st->codecpar->level = sps->level_idc;
2331  // continue to check for avc intra
2332  }
2333  }
2334 
2335  if (!codec_ul) {
2336  av_log(s, AV_LOG_ERROR, "h264 profile not supported\n");
2337  return 0;
2338  }
2339  sc->codec_ul = codec_ul;
2340 
2341  return 1;
2342 }
2343 
2344 static const UID mxf_mpeg2_codec_uls[] = {
2345  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x10,0x00 }, // MP-ML I-Frame
2346  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x01,0x11,0x00 }, // MP-ML Long GOP
2347  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x02,0x00 }, // 422P-ML I-Frame
2348  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x02,0x03,0x00 }, // 422P-ML Long GOP
2349  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x02,0x00 }, // MP-HL I-Frame
2350  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x03,0x03,0x00 }, // MP-HL Long GOP
2351  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x02,0x00 }, // 422P-HL I-Frame
2352  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x04,0x03,0x00 }, // 422P-HL Long GOP
2353  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x05,0x02,0x00 }, // MP@H-14 I-Frame
2354  { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x03,0x04,0x01,0x02,0x02,0x01,0x05,0x03,0x00 }, // MP@H-14 Long GOP
2355 };
2356 
2357 static const UID *mxf_get_mpeg2_codec_ul(AVCodecParameters *par)
2358 {
2359  int long_gop = 1;
2360 
2361  if (par->profile == 4) { // Main
2362  if (par->level == 8) // Main
2363  return &mxf_mpeg2_codec_uls[0+long_gop];
2364  else if (par->level == 4) // High
2365  return &mxf_mpeg2_codec_uls[4+long_gop];
2366  else if (par->level == 6) // High 14
2367  return &mxf_mpeg2_codec_uls[8+long_gop];
2368  } else if (par->profile == 0) { // 422
2369  if (par->level == 5) // Main
2370  return &mxf_mpeg2_codec_uls[2+long_gop];
2371  else if (par->level == 2) // High
2372  return &mxf_mpeg2_codec_uls[6+long_gop];
2373  }
2374  return NULL;
2375 }
2376 
2377 static int mxf_parse_mpeg2_frame(AVFormatContext *s, AVStream *st,
2378  AVPacket *pkt, MXFIndexEntry *e)
2379 {
2380  MXFStreamContext *sc = st->priv_data;
2381  uint32_t c = -1;
2382  int i;
2383 
2384  for(i = 0; i < pkt->size - 4; i++) {
2385  c = (c<<8) + pkt->data[i];
2386  if (c == 0x1b5) {
2387  if ((pkt->data[i+1] & 0xf0) == 0x10) { // seq ext
2388  st->codecpar->profile = pkt->data[i+1] & 0x07;
2389  st->codecpar->level = pkt->data[i+2] >> 4;
2390  sc->low_delay = pkt->data[i+6] >> 7;
2391  } else if (i + 5 < pkt->size && (pkt->data[i+1] & 0xf0) == 0x80) { // pict coding ext
2392  sc->interlaced = !(pkt->data[i+5] & 0x80); // progressive frame
2393  if (sc->interlaced)
2394  sc->field_dominance = 1 + !(pkt->data[i+4] & 0x80); // top field first
2395  break;
2396  }
2397  } else if (c == 0x1b8) { // gop
2398  if (pkt->data[i+4]>>6 & 0x01) { // closed
2399  if (sc->seq_closed_gop == -1)
2400  sc->seq_closed_gop = 1;
2401  sc->closed_gop = 1;
2402  if (e->flags & 0x40) // sequence header present
2403  e->flags |= 0x80; // random access
2404  } else {
2405  sc->seq_closed_gop = 0;
2406  sc->closed_gop = 0;
2407  }
2408  } else if (c == 0x1b3) { // seq
2409  e->flags |= 0x40;
2410  switch ((pkt->data[i+4]>>4) & 0xf) {
2411  case 2: sc->aspect_ratio = (AVRational){ 4, 3}; break;
2412  case 3: sc->aspect_ratio = (AVRational){ 16, 9}; break;
2413  case 4: sc->aspect_ratio = (AVRational){221,100}; break;
2414  default:
2415  av_reduce(&sc->aspect_ratio.num, &sc->aspect_ratio.den,
2416  st->codecpar->width, st->codecpar->height, 1024*1024);
2417  }
2418  } else if (c == 0x100) { // pic
2419  int pict_type = (pkt->data[i+2]>>3) & 0x07;
2420  e->temporal_ref = (pkt->data[i+1]<<2) | (pkt->data[i+2]>>6);
2421  if (pict_type == 2) { // P-frame
2422  e->flags |= 0x22;
2423  sc->closed_gop = 0; // reset closed GOP, don't matter anymore
2424  } else if (pict_type == 3) { // B-frame
2425  if (sc->closed_gop)
2426  e->flags |= 0x13; // only backward prediction
2427  else
2428  e->flags |= 0x33;
2429  sc->temporal_reordering = -1;
2430  } else if (!pict_type) {
2431  av_log(s, AV_LOG_ERROR, "error parsing mpeg2 frame\n");
2432  return 0;
2433  }
2434  }
2435  }
2436  if (s->oformat != &ff_mxf_d10_muxer) {
2437  const UID *codec_ul = mxf_get_mpeg2_codec_ul(st->codecpar);
2438  if (!codec_ul)
2439  return 0;
2440  sc->codec_ul = codec_ul;
2441  }
2442  return 1;
2443 }
2444 
2445 static uint64_t mxf_parse_timestamp(int64_t timestamp64)
2446 {
2447  time_t timestamp = timestamp64 / 1000000;
2448  struct tm tmbuf;
2449  struct tm *time = gmtime_r(&timestamp, &tmbuf);
2450  if (!time)
2451  return 0;
2452  return (uint64_t)(time->tm_year+1900) << 48 |
2453  (uint64_t)(time->tm_mon+1) << 40 |
2454  (uint64_t) time->tm_mday << 32 |
2455  time->tm_hour << 24 |
2456  time->tm_min << 16 |
2457  time->tm_sec << 8 |
2458  (timestamp64 % 1000000) / 4000;
2459 }
2460 
2461 static void mxf_gen_umid(AVFormatContext *s)
2462 {
2463  MXFContext *mxf = s->priv_data;
2464  uint32_t seed = av_get_random_seed();
2465  uint64_t umid = seed + 0x5294713400000000LL;
2466 
2467  AV_WB64(mxf->umid , umid);
2468  AV_WB64(mxf->umid+8, umid>>8);
2469 
2470  mxf->instance_number = seed & 0xFFFFFF;
2471 }
2472 
2473 static int mxf_init_timecode(AVFormatContext *s, AVStream *st, AVRational tbc)
2474 {
2475  MXFContext *mxf = s->priv_data;
2476  AVDictionaryEntry *tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
2477 
2478  if (!ff_mxf_get_content_package_rate(tbc)) {
2479  if (s->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
2480  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);
2481  return AVERROR(EINVAL);
2482  } else {
2483  av_log(s, AV_LOG_WARNING, "Unofficial frame rate %d/%d.\n", tbc.den, tbc.num);
2484  }
2485  }
2486 
2487  mxf->timecode_base = (tbc.den + tbc.num/2) / tbc.num;
2488  if (!tcr)
2489  tcr = av_dict_get(st->metadata, "timecode", NULL, 0);
2490 
2491  if (tcr)
2492  return av_timecode_init_from_string(&mxf->tc, av_inv_q(tbc), tcr->value, s);
2493  else
2494  return av_timecode_init(&mxf->tc, av_inv_q(tbc), 0, 0, s);
2495 }
2496 
2497 static int mxf_init(AVFormatContext *s)
2498 {
2499  MXFContext *mxf = s->priv_data;
2500  int i, ret;
2501  uint8_t present[FF_ARRAY_ELEMS(mxf_essence_container_uls)] = {0};
2502  int64_t timestamp = 0;
2503 
2504  if (s->oformat == &ff_mxf_opatom_muxer && s->nb_streams !=1) {
2505  av_log(s, AV_LOG_ERROR, "there must be exactly one stream for mxf opatom\n");
2506  return -1;
2507  }
2508 
2509  if (!av_dict_get(s->metadata, "comment_", NULL, AV_DICT_IGNORE_SUFFIX))
2510  mxf->store_user_comments = 0;
2511 
2512  for (i = 0; i < s->nb_streams; i++) {
2513  AVStream *st = s->streams[i];
2514  MXFStreamContext *sc = av_mallocz(sizeof(*sc));
2515  if (!sc)
2516  return AVERROR(ENOMEM);
2517  st->priv_data = sc;
2518  sc->index = -1;
2519 
2520  if (((i == 0) ^ (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)) && s->oformat != &ff_mxf_opatom_muxer) {
2521  av_log(s, AV_LOG_ERROR, "there must be exactly one video stream and it must be the first one\n");
2522  return -1;
2523  }
2524 
2525  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2526  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(st->codecpar->format);
2527  // TODO: should be avg_frame_rate
2528  AVRational tbc = st->time_base;
2529  // Default component depth to 8
2530  sc->component_depth = 8;
2531  sc->h_chroma_sub_sample = 2;
2532  sc->v_chroma_sub_sample = 2;
2533  sc->color_siting = 0xFF;
2534 
2535  if (st->codecpar->sample_aspect_ratio.num && st->codecpar->sample_aspect_ratio.den) {
2536  sc->aspect_ratio = av_mul_q(st->codecpar->sample_aspect_ratio,
2537  av_make_q(st->codecpar->width, st->codecpar->height));
2538  }
2539 
2540  if (pix_desc) {
2541  sc->component_depth = pix_desc->comp[0].depth;
2542  sc->h_chroma_sub_sample = 1 << pix_desc->log2_chroma_w;
2543  sc->v_chroma_sub_sample = 1 << pix_desc->log2_chroma_h;
2544  }
2545  switch (ff_choose_chroma_location(s, st)) {
2546  case AVCHROMA_LOC_TOPLEFT: sc->color_siting = 0; break;
2547  case AVCHROMA_LOC_LEFT: sc->color_siting = 6; break;
2548  case AVCHROMA_LOC_TOP: sc->color_siting = 1; break;
2549  case AVCHROMA_LOC_CENTER: sc->color_siting = 3; break;
2550  }
2551 
2552  mxf->content_package_rate = ff_mxf_get_content_package_rate(tbc);
2553  mxf->time_base = tbc;
2554  avpriv_set_pts_info(st, 64, mxf->time_base.num, mxf->time_base.den);
2555  if((ret = mxf_init_timecode(s, st, tbc)) < 0)
2556  return ret;
2557 
2558  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2559  sc->seq_closed_gop = -1; // unknown yet
2560  }
2561 
2562  sc->video_bit_rate = st->codecpar->bit_rate;
2563 
2564  if (s->oformat == &ff_mxf_d10_muxer ||
2565  st->codecpar->codec_id == AV_CODEC_ID_DNXHD ||
2566  st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO)
2567  mxf->cbr_index = 1;
2568 
2569  if (s->oformat == &ff_mxf_d10_muxer) {
2570  int ntsc = mxf->time_base.den != 25;
2571  int ul_index;
2572 
2573  if (st->codecpar->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
2574  av_log(s, AV_LOG_ERROR, "error MXF D-10 only support MPEG-2 Video\n");
2575  return AVERROR(EINVAL);
2576  }
2577  if ((sc->video_bit_rate == 50000000) && (mxf->time_base.den == 25)) {
2578  ul_index = 0;
2579  } else if ((sc->video_bit_rate == 49999840 || sc->video_bit_rate == 50000000) && ntsc) {
2580  ul_index = 1;
2581  } else if (sc->video_bit_rate == 40000000) {
2582  ul_index = 2+ntsc;
2583  } else if (sc->video_bit_rate == 30000000) {
2584  ul_index = 4+ntsc;
2585  } else {
2586  av_log(s, AV_LOG_ERROR, "error MXF D-10 only support 30/40/50 mbit/s\n");
2587  return -1;
2588  }
2589 
2590  sc->codec_ul = &mxf_d10_codec_uls[ul_index];
2591  sc->container_ul = &mxf_d10_container_uls[ul_index];
2592  sc->index = INDEX_D10_VIDEO;
2593  sc->signal_standard = 1;
2594  sc->color_siting = 0;
2595  sc->frame_size = (int64_t)sc->video_bit_rate *
2596  mxf->time_base.num / (8*mxf->time_base.den);
2597  }
2598  if (mxf->signal_standard >= 0)
2599  sc->signal_standard = mxf->signal_standard;
2600  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2601  char bsf_arg[32];
2602  if (st->codecpar->sample_rate != 48000) {
2603  av_log(s, AV_LOG_ERROR, "only 48khz is implemented\n");
2604  return -1;
2605  }
2606  avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
2607  if (s->oformat == &ff_mxf_d10_muxer) {
2608  if (st->index != 1) {
2609  av_log(s, AV_LOG_ERROR, "MXF D-10 only support one audio track\n");
2610  return -1;
2611  }
2612  if (st->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE &&
2613  st->codecpar->codec_id != AV_CODEC_ID_PCM_S24LE) {
2614  av_log(s, AV_LOG_ERROR, "MXF D-10 only support 16 or 24 bits le audio\n");
2615  }
2616  sc->index = INDEX_D10_AUDIO;
2617  sc->container_ul = ((MXFStreamContext*)s->streams[0]->priv_data)->container_ul;
2618  sc->frame_size = 4 + 8 * av_rescale_rnd(st->codecpar->sample_rate, mxf->time_base.num, mxf->time_base.den, AV_ROUND_UP) * 4;
2619  } else if (s->oformat == &ff_mxf_opatom_muxer) {
2620  AVRational tbc = av_inv_q(mxf->audio_edit_rate);
2621 
2622  if (st->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE &&
2623  st->codecpar->codec_id != AV_CODEC_ID_PCM_S24LE) {
2624  av_log(s, AV_LOG_ERROR, "Only pcm_s16le and pcm_s24le audio codecs are implemented\n");
2625  return AVERROR_PATCHWELCOME;
2626  }
2627  if (st->codecpar->channels != 1) {
2628  av_log(s, AV_LOG_ERROR, "MXF OPAtom only supports single channel audio\n");
2629  return AVERROR(EINVAL);
2630  }
2631 
2632  mxf->time_base = st->time_base;
2633  if((ret = mxf_init_timecode(s, st, tbc)) < 0)
2634  return ret;
2635 
2636  mxf->edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
2637  sc->index = INDEX_WAV;
2638  } else {
2639  mxf->slice_count = 1;
2640  sc->frame_size = st->codecpar->channels *
2641  av_rescale_rnd(st->codecpar->sample_rate, mxf->time_base.num, mxf->time_base.den, AV_ROUND_UP) *
2642  av_get_bits_per_sample(st->codecpar->codec_id) / 8;
2643  }
2644  snprintf(bsf_arg, sizeof(bsf_arg), "r=%d/%d", mxf->tc.rate.num, mxf->tc.rate.den);
2645  ret = ff_stream_add_bitstream_filter(st, "pcm_rechunk", bsf_arg);
2646  if (ret < 0)
2647  return ret;
2648  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2649  AVDictionaryEntry *e = av_dict_get(st->metadata, "data_type", NULL, 0);
2650  if (e && !strcmp(e->value, "vbi_vanc_smpte_436M")) {
2651  sc->index = INDEX_S436M;
2652  } else {
2653  av_log(s, AV_LOG_ERROR, "track %d: unsupported data type\n", i);
2654  return -1;
2655  }
2656  if (st->index != s->nb_streams - 1) {
2657  av_log(s, AV_LOG_ERROR, "data track must be placed last\n");
2658  return -1;
2659  }
2660  }
2661 
2662  if (sc->index == -1) {
2663  sc->index = mxf_get_essence_container_ul_index(st->codecpar->codec_id);
2664  if (sc->index == -1) {
2665  av_log(s, AV_LOG_ERROR, "track %d: could not find essence container ul, "
2666  "codec not currently supported in container\n", i);
2667  return -1;
2668  }
2669  }
2670 
2671  if (!sc->codec_ul)
2672  sc->codec_ul = &mxf_essence_container_uls[sc->index].codec_ul;
2673  if (!sc->container_ul)
2674  sc->container_ul = &mxf_essence_container_uls[sc->index].container_ul;
2675 
2676  memcpy(sc->track_essence_element_key, mxf_essence_container_uls[sc->index].element_ul, 15);
2677  sc->track_essence_element_key[15] = present[sc->index];
2678  if (s->oformat == &ff_mxf_opatom_muxer && st->codecpar->codec_id == AV_CODEC_ID_DNXHD) {
2679  // clip-wrapping requires 0x0D per ST2019-4:2009 or 0x06 per previous version ST2019-4:2008
2680  // we choose to use 0x06 instead 0x0D to be compatible with AVID systems
2681  // and produce mxf files with the most relevant flavour for opatom
2682  sc->track_essence_element_key[14] = 0x06;
2683  }
2684  PRINT_KEY(s, "track essence element key", sc->track_essence_element_key);
2685 
2686  if (!present[sc->index])
2687  mxf->essence_container_count++;
2688  present[sc->index]++;
2689  }
2690 
2691  if (s->oformat == &ff_mxf_d10_muxer || s->oformat == &ff_mxf_opatom_muxer) {
2692  mxf->essence_container_count = 1;
2693  }
2694 
2695  if (!(s->flags & AVFMT_FLAG_BITEXACT))
2696  mxf_gen_umid(s);
2697 
2698  for (i = 0; i < s->nb_streams; i++) {
2699  MXFStreamContext *sc = s->streams[i]->priv_data;
2700  // update element count
2701  sc->track_essence_element_key[13] = present[sc->index];
2702  if (!memcmp(sc->track_essence_element_key, mxf_essence_container_uls[INDEX_DV].element_ul, 13)) // DV
2703  sc->order = (0x15 << 24) | AV_RB32(sc->track_essence_element_key+13);
2704  else
2705  sc->order = AV_RB32(sc->track_essence_element_key+12);
2706  }
2707 
2708  if (ff_parse_creation_time_metadata(s, &timestamp, 0) > 0)
2709  mxf->timestamp = mxf_parse_timestamp(timestamp);
2710  mxf->duration = -1;
2711 
2712  mxf->timecode_track = av_mallocz(sizeof(*mxf->timecode_track));
2713  if (!mxf->timecode_track)
2714  return AVERROR(ENOMEM);
2715  mxf->timecode_track->priv_data = &mxf->timecode_track_priv;
2716  mxf->timecode_track->index = -1;
2717 
2718  return 0;
2719 }
2720 
2721 static const uint8_t system_metadata_pack_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04,0x01,0x01,0x00 };
2722 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 };
2723 
2724 static void mxf_write_system_item(AVFormatContext *s)
2725 {
2726  MXFContext *mxf = s->priv_data;
2727  AVIOContext *pb = s->pb;
2728  unsigned frame;
2729  uint32_t time_code;
2730  int i, system_item_bitmap = 0x58; // UL, user date/time stamp, picture present
2731 
2732  frame = mxf->last_indexed_edit_unit + mxf->edit_units_count;
2733 
2734  // write system metadata pack
2735  avio_write(pb, system_metadata_pack_key, 16);
2736  klv_encode_ber4_length(pb, 57);
2737 
2738  for (i = 0; i < s->nb_streams; i++) {
2739  if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2740  system_item_bitmap |= 0x4;
2741  else if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2742  system_item_bitmap |= 0x2;
2743  }
2744  avio_w8(pb, system_item_bitmap);
2745  avio_w8(pb, mxf->content_package_rate); // content package rate
2746  avio_w8(pb, 0x00); // content package type
2747  avio_wb16(pb, 0x00); // channel handle
2748  avio_wb16(pb, frame & 0xFFFF); // continuity count, supposed to overflow
2749  if (mxf->essence_container_count > 1)
2750  avio_write(pb, multiple_desc_ul, 16);
2751  else {
2752  MXFStreamContext *sc = s->streams[0]->priv_data;
2753  avio_write(pb, *sc->container_ul, 16);
2754  }
2755  avio_w8(pb, 0);
2756  avio_wb64(pb, 0);
2757  avio_wb64(pb, 0); // creation date/time stamp
2758 
2759  avio_w8(pb, 0x81); // SMPTE 12M time code
2760  time_code = av_timecode_get_smpte_from_framenum(&mxf->tc, frame);
2761  avio_wb32(pb, time_code);
2762  avio_wb32(pb, 0); // binary group data
2763  avio_wb64(pb, 0);
2764 
2765  // write system metadata package set
2766  avio_write(pb, system_metadata_package_set_key, 16);
2767  klv_encode_ber4_length(pb, 35);
2768  avio_w8(pb, 0x83); // UMID
2769  avio_wb16(pb, 0x20);
2770  mxf_write_umid(s, 1);
2771 }
2772 
2773 static void mxf_write_d10_audio_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
2774 {
2775  MXFContext *mxf = s->priv_data;
2776  AVIOContext *pb = s->pb;
2777  int frame_size = pkt->size / st->codecpar->block_align;
2778  uint8_t *samples = pkt->data;
2779  uint8_t *end = pkt->data + pkt->size;
2780  int i;
2781 
2782  klv_encode_ber4_length(pb, 4 + frame_size*4*8);
2783 
2784  avio_w8(pb, (frame_size == 1920 ? 0 : (mxf->edit_units_count-1) % 5 + 1));
2785  avio_wl16(pb, frame_size);
2786  avio_w8(pb, (1<<st->codecpar->channels)-1);
2787 
2788  while (samples < end) {
2789  for (i = 0; i < st->codecpar->channels; i++) {
2790  uint32_t sample;
2791  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE) {
2792  sample = AV_RL24(samples)<< 4;
2793  samples += 3;
2794  } else {
2795  sample = AV_RL16(samples)<<12;
2796  samples += 2;
2797  }
2798  avio_wl32(pb, sample | i);
2799  }
2800  for (; i < 8; i++)
2801  avio_wl32(pb, i);
2802  }
2803 }
2804 
2805 static int mxf_write_opatom_body_partition(AVFormatContext *s)
2806 {
2807  MXFContext *mxf = s->priv_data;
2808  AVIOContext *pb = s->pb;
2809  AVStream *st = s->streams[0];
2810  MXFStreamContext *sc = st->priv_data;
2811  const uint8_t *key = NULL;
2812 
2813  int err;
2814 
2815  if (!mxf->header_written)
2816  key = body_partition_key;
2817 
2818  if ((err = mxf_write_partition(s, 1, 0, key, 0)) < 0)
2819  return err;
2820  mxf_write_klv_fill(s);
2821  avio_write(pb, sc->track_essence_element_key, 16);
2822  klv_encode_ber9_length(pb, mxf->body_offset);
2823  return 0;
2824 }
2825 
2826 static int mxf_write_opatom_packet(AVFormatContext *s, AVPacket *pkt, MXFIndexEntry *ie)
2827 {
2828  MXFContext *mxf = s->priv_data;
2829  AVIOContext *pb = s->pb;
2830 
2831  int err;
2832 
2833  if (!mxf->header_written) {
2834  if ((err = mxf_write_partition(s, 0, 0, header_open_partition_key, 1)) < 0)
2835  return err;
2836  mxf_write_klv_fill(s);
2837 
2838  if ((err = mxf_write_opatom_body_partition(s)) < 0)
2839  return err;
2840  mxf->header_written = 1;
2841  }
2842 
2843  if (!mxf->edit_unit_byte_count) {
2844  mxf->index_entries[mxf->edit_units_count].offset = mxf->body_offset;
2845  mxf->index_entries[mxf->edit_units_count].flags = ie->flags;
2846  mxf->index_entries[mxf->edit_units_count].temporal_ref = ie->temporal_ref;
2847  }
2848  mxf->edit_units_count++;
2849  avio_write(pb, pkt->data, pkt->size);
2850  mxf->body_offset += pkt->size;
2851 
2852  return 0;
2853 }
2854 
2855 static void mxf_compute_edit_unit_byte_count(AVFormatContext *s)
2856 {
2857  MXFContext *mxf = s->priv_data;
2858  int i;
2859 
2860  if (s->oformat == &ff_mxf_opatom_muxer) {
2861  MXFStreamContext *sc = s->streams[0]->priv_data;
2862  mxf->edit_unit_byte_count = sc->frame_size;
2863  return;
2864  }
2865 
2866  mxf->edit_unit_byte_count = KAG_SIZE; // system element
2867  for (i = 0; i < s->nb_streams; i++) {
2868  AVStream *st = s->streams[i];
2869  MXFStreamContext *sc = st->priv_data;
2870  sc->slice_offset = mxf->edit_unit_byte_count;
2871  mxf->edit_unit_byte_count += 16 + 4 + sc->frame_size;
2872  mxf->edit_unit_byte_count += klv_fill_size(mxf->edit_unit_byte_count);
2873  }
2874 }
2875 
2876 static int mxf_write_packet(AVFormatContext *s, AVPacket *pkt)
2877 {
2878  MXFContext *mxf = s->priv_data;
2879  AVIOContext *pb = s->pb;
2880  AVStream *st = s->streams[pkt->stream_index];
2881  MXFStreamContext *sc = st->priv_data;
2882  MXFIndexEntry ie = {0};
2883  int err;
2884 
2885  if (!mxf->header_written && pkt->stream_index != 0 &&
2886  s->oformat != &ff_mxf_opatom_muxer) {
2887  av_log(s, AV_LOG_ERROR, "Received non-video packet before "
2888  "header has been written\n");
2889  return AVERROR_INVALIDDATA;
2890  }
2891 
2892  if (!mxf->cbr_index && !mxf->edit_unit_byte_count && !(mxf->edit_units_count % EDIT_UNITS_PER_BODY)) {
2893  if ((err = av_reallocp_array(&mxf->index_entries, mxf->edit_units_count
2894  + EDIT_UNITS_PER_BODY, sizeof(*mxf->index_entries))) < 0) {
2895  mxf->edit_units_count = 0;
2896  av_log(s, AV_LOG_ERROR, "could not allocate index entries\n");
2897  return err;
2898  }
2899  }
2900 
2901  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2902  if (!mxf_parse_mpeg2_frame(s, st, pkt, &ie)) {
2903  av_log(s, AV_LOG_ERROR, "could not get mpeg2 profile and level\n");
2904  return -1;
2905  }
2906  } else if (st->codecpar->codec_id == AV_CODEC_ID_DNXHD) {
2907  if (!mxf_parse_dnxhd_frame(s, st, pkt)) {
2908  av_log(s, AV_LOG_ERROR, "could not get dnxhd profile\n");
2909  return -1;
2910  }
2911  } else if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2912  if (!mxf_parse_prores_frame(s, st, pkt)) {
2913  av_log(s, AV_LOG_ERROR, "could not get prores profile\n");
2914  return -1;
2915  }
2916  } else if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO) {
2917  if (!mxf_parse_dv_frame(s, st, pkt)) {
2918  av_log(s, AV_LOG_ERROR, "could not get dv profile\n");
2919  return -1;
2920  }
2921  } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2922  if (!mxf_parse_h264_frame(s, st, pkt, &ie)) {
2923  av_log(s, AV_LOG_ERROR, "could not get h264 profile\n");
2924  return -1;
2925  }
2926  }
2927 
2928  if (mxf->cbr_index) {
2929  if (pkt->size != sc->frame_size && st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2930  av_log(s, AV_LOG_ERROR, "track %d: frame size does not match index unit size, %d != %d\n",
2931  st->index, pkt->size, sc->frame_size);
2932  return -1;
2933  }
2934  if (!mxf->header_written)
2935  mxf_compute_edit_unit_byte_count(s);
2936  }
2937 
2938  if (s->oformat == &ff_mxf_opatom_muxer)
2939  return mxf_write_opatom_packet(s, pkt, &ie);
2940 
2941  if (!mxf->header_written) {
2942  if (mxf->edit_unit_byte_count) {
2943  if ((err = mxf_write_partition(s, 1, 2, header_open_partition_key, 1)) < 0)
2944  return err;
2945  mxf_write_klv_fill(s);
2946  mxf_write_index_table_segment(s);
2947  } else {
2948  if ((err = mxf_write_partition(s, 0, 0, header_open_partition_key, 1)) < 0)
2949  return err;
2950  }
2951  mxf->header_written = 1;
2952  }
2953 
2954  if (st->index == 0) {
2955  if (!mxf->edit_unit_byte_count &&
2956  (!mxf->edit_units_count || mxf->edit_units_count > EDIT_UNITS_PER_BODY) &&
2957  !(ie.flags & 0x33)) { // I-frame, GOP start
2958  mxf_write_klv_fill(s);
2959  if ((err = mxf_write_partition(s, 1, 2, body_partition_key, 0)) < 0)
2960  return err;
2961  mxf_write_klv_fill(s);
2962  mxf_write_index_table_segment(s);
2963  }
2964 
2965  mxf_write_klv_fill(s);
2966  mxf_write_system_item(s);
2967 
2968  if (!mxf->edit_unit_byte_count) {
2969  mxf->index_entries[mxf->edit_units_count].offset = mxf->body_offset;
2970  mxf->index_entries[mxf->edit_units_count].flags = ie.flags;
2971  mxf->index_entries[mxf->edit_units_count].temporal_ref = ie.temporal_ref;
2972  mxf->body_offset += KAG_SIZE; // size of system element
2973  }
2974  mxf->edit_units_count++;
2975  } else if (!mxf->edit_unit_byte_count && st->index == 1) {
2976  if (!mxf->edit_units_count) {
2977  av_log(s, AV_LOG_ERROR, "No packets in first stream\n");
2978  return AVERROR_PATCHWELCOME;
2979  }
2980  mxf->index_entries[mxf->edit_units_count-1].slice_offset =
2981  mxf->body_offset - mxf->index_entries[mxf->edit_units_count-1].offset;
2982  }
2983 
2984  mxf_write_klv_fill(s);
2985  avio_write(pb, sc->track_essence_element_key, 16); // write key
2986  if (s->oformat == &ff_mxf_d10_muxer &&
2987  st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2988  mxf_write_d10_audio_packet(s, st, pkt);
2989  } else {
2990  klv_encode_ber4_length(pb, pkt->size); // write length
2991  avio_write(pb, pkt->data, pkt->size);
2992  mxf->body_offset += 16+4+pkt->size + klv_fill_size(16+4+pkt->size);
2993  }
2994 
2995  return 0;
2996 }
2997 
2998 static void mxf_write_random_index_pack(AVFormatContext *s)
2999 {
3000  MXFContext *mxf = s->priv_data;
3001  AVIOContext *pb = s->pb;
3002  uint64_t pos = avio_tell(pb);
3003  int i;
3004 
3005  avio_write(pb, ff_mxf_random_index_pack_key, 16);
3006  klv_encode_ber_length(pb, 28 + 12LL*mxf->body_partitions_count);
3007 
3008  if (mxf->edit_unit_byte_count && s->oformat != &ff_mxf_opatom_muxer)
3009  avio_wb32(pb, 1); // BodySID of header partition
3010  else
3011  avio_wb32(pb, 0);
3012  avio_wb64(pb, 0); // offset of header partition
3013 
3014  for (i = 0; i < mxf->body_partitions_count; i++) {
3015  avio_wb32(pb, 1); // BodySID
3016  avio_wb64(pb, mxf->body_partition_offset[i]);
3017  }
3018 
3019  avio_wb32(pb, 0); // BodySID of footer partition
3020  avio_wb64(pb, mxf->footer_partition_offset);
3021 
3022  avio_wb32(pb, avio_tell(pb) - pos + 4);
3023 }
3024 
3025 static int mxf_write_footer(AVFormatContext *s)
3026 {
3027  MXFContext *mxf = s->priv_data;
3028  AVIOContext *pb = s->pb;
3029  int i, err;
3030 
3031  if (!mxf->header_written ||
3032  (s->oformat == &ff_mxf_opatom_muxer && !mxf->body_partition_offset)) {
3033  /* reason could be invalid options/not supported codec/out of memory */
3034  return AVERROR_UNKNOWN;
3035  }
3036 
3037  mxf->duration = mxf->last_indexed_edit_unit + mxf->edit_units_count;
3038 
3039  mxf_write_klv_fill(s);
3040  mxf->footer_partition_offset = avio_tell(pb);
3041  if (mxf->edit_unit_byte_count && s->oformat != &ff_mxf_opatom_muxer) { // no need to repeat index
3042  if ((err = mxf_write_partition(s, 0, 0, footer_partition_key, 0)) < 0)
3043  return err;
3044  } else {
3045  if ((err = mxf_write_partition(s, 0, 2, footer_partition_key, 0)) < 0)
3046  return err;
3047  mxf_write_klv_fill(s);
3048  mxf_write_index_table_segment(s);
3049  }
3050 
3051  mxf_write_klv_fill(s);
3052  mxf_write_random_index_pack(s);
3053 
3054  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
3055  if (s->oformat == &ff_mxf_opatom_muxer) {
3056  /* rewrite body partition to update lengths */
3057  avio_seek(pb, mxf->body_partition_offset[0], SEEK_SET);
3058  if ((err = mxf_write_opatom_body_partition(s)) < 0)
3059  return err;
3060  }
3061 
3062  avio_seek(pb, 0, SEEK_SET);
3063  if (mxf->edit_unit_byte_count && s->oformat != &ff_mxf_opatom_muxer) {
3064  if ((err = mxf_write_partition(s, 1, 2, header_closed_partition_key, 1)) < 0)
3065  return err;
3066  mxf_write_klv_fill(s);
3067  mxf_write_index_table_segment(s);
3068  } else {
3069  if ((err = mxf_write_partition(s, 0, 0, header_closed_partition_key, 1)) < 0)
3070  return err;
3071  }
3072  // update footer partition offset
3073  for (i = 0; i < mxf->body_partitions_count; i++) {
3074  avio_seek(pb, mxf->body_partition_offset[i]+44, SEEK_SET);
3075  avio_wb64(pb, mxf->footer_partition_offset);
3076  }
3077  }
3078 
3079  return 0;
3080 }
3081 
3082 static void mxf_deinit(AVFormatContext *s)
3083 {
3084  MXFContext *mxf = s->priv_data;
3085 
3086  av_freep(&mxf->index_entries);
3087  av_freep(&mxf->body_partition_offset);
3088  av_freep(&mxf->timecode_track);
3089 }
3090 
3091 static int mxf_interleave_get_packet(AVFormatContext *s, AVPacket *out, int flush)
3092 {
3093  FFFormatContext *const si = ffformatcontext(s);
3094  int i, stream_count = 0;
3095 
3096  for (i = 0; i < s->nb_streams; i++)
3097  stream_count += !!ffstream(s->streams[i])->last_in_packet_buffer;
3098 
3099  if (stream_count && (s->nb_streams == stream_count || flush)) {
3100  PacketListEntry *pktl = si->packet_buffer.head;
3101  if (s->nb_streams != stream_count) {
3102  PacketListEntry *last = NULL;
3103  // find last packet in edit unit
3104  while (pktl) {
3105  if (!stream_count || pktl->pkt.stream_index == 0)
3106  break;
3107  // update last packet in packet buffer
3108  if (ffstream(s->streams[pktl->pkt.stream_index])->last_in_packet_buffer != pktl)
3109  ffstream(s->streams[pktl->pkt.stream_index])->last_in_packet_buffer = pktl;
3110  last = pktl;
3111  pktl = pktl->next;
3112  stream_count--;
3113  }
3114  // purge packet queue
3115  while (pktl) {
3116  PacketListEntry *next = pktl->next;
3117  av_packet_unref(&pktl->pkt);
3118  av_freep(&pktl);
3119  pktl = next;
3120  }
3121  if (last)
3122  last->next = NULL;
3123  else {
3124  si->packet_buffer.head = NULL;
3125  si->packet_buffer.tail = NULL;
3126  goto out;
3127  }
3128  pktl = si->packet_buffer.head;
3129  }
3130 
3131  if (ffstream(s->streams[pktl->pkt.stream_index])->last_in_packet_buffer == pktl)
3132  ffstream(s->streams[pktl->pkt.stream_index])->last_in_packet_buffer = NULL;
3133  avpriv_packet_list_get(&si->packet_buffer, out);
3134  av_log(s, AV_LOG_TRACE, "out st:%d dts:%"PRId64"\n", out->stream_index, out->dts);
3135  return 1;
3136  } else {
3137  out:
3138  return 0;
3139  }
3140 }
3141 
3142 static int mxf_compare_timestamps(AVFormatContext *s, const AVPacket *next,
3143  const AVPacket *pkt)
3144 {
3145  MXFStreamContext *sc = s->streams[pkt ->stream_index]->priv_data;
3146  MXFStreamContext *sc2 = s->streams[next->stream_index]->priv_data;
3147 
3148  return next->dts > pkt->dts ||
3149  (next->dts == pkt->dts && sc->order < sc2->order);
3150 }
3151 
3152 static int mxf_interleave(AVFormatContext *s, AVPacket *pkt,
3153  int flush, int has_packet)
3154 {
3155  int ret;
3156  if (has_packet) {
3157  MXFStreamContext *sc = s->streams[pkt->stream_index]->priv_data;
3158  pkt->pts = pkt->dts = sc->pkt_cnt++;
3159  if ((ret = ff_interleave_add_packet(s, pkt, mxf_compare_timestamps)) < 0)
3160  return ret;
3161  }
3162  return mxf_interleave_get_packet(s, pkt, flush);
3163 }
3164 
3165 #define MXF_COMMON_OPTIONS \
3166  { "signal_standard", "Force/set Signal Standard",\
3167  offsetof(MXFContext, signal_standard), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3168  { "bt601", "ITU-R BT.601 and BT.656, also SMPTE 125M (525 and 625 line interlaced)",\
3169  0, AV_OPT_TYPE_CONST, {.i64 = 1}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3170  { "bt1358", "ITU-R BT.1358 and ITU-R BT.799-3, also SMPTE 293M (525 and 625 line progressive)",\
3171  0, AV_OPT_TYPE_CONST, {.i64 = 2}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3172  { "smpte347m", "SMPTE 347M (540 Mbps mappings)",\
3173  0, AV_OPT_TYPE_CONST, {.i64 = 3}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3174  { "smpte274m", "SMPTE 274M (1125 line)",\
3175  0, AV_OPT_TYPE_CONST, {.i64 = 4}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3176  { "smpte296m", "SMPTE 296M (750 line progressive)",\
3177  0, AV_OPT_TYPE_CONST, {.i64 = 5}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3178  { "smpte349m", "SMPTE 349M (1485 Mbps mappings)",\
3179  0, AV_OPT_TYPE_CONST, {.i64 = 6}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},\
3180  { "smpte428", "SMPTE 428-1 DCDM",\
3181  0, AV_OPT_TYPE_CONST, {.i64 = 7}, -1, 7, AV_OPT_FLAG_ENCODING_PARAM, "signal_standard"},
3182 
3183 
3184 
3185 static const AVOption mxf_options[] = {
3186  MXF_COMMON_OPTIONS
3187  { "store_user_comments", "",
3188  offsetof(MXFContext, store_user_comments), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
3189  { NULL },
3190 };
3191 
3192 static const AVClass mxf_muxer_class = {
3193  .class_name = "MXF muxer",
3194  .item_name = av_default_item_name,
3195  .option = mxf_options,
3196  .version = LIBAVUTIL_VERSION_INT,
3197 };
3198 
3199 static const AVOption d10_options[] = {
3200  { "d10_channelcount", "Force/set channelcount in generic sound essence descriptor",
3201  offsetof(MXFContext, channel_count), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 8, AV_OPT_FLAG_ENCODING_PARAM},
3202  MXF_COMMON_OPTIONS
3203  { "store_user_comments", "",
3204  offsetof(MXFContext, store_user_comments), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
3205  { NULL },
3206 };
3207 
3208 static const AVClass mxf_d10_muxer_class = {
3209  .class_name = "MXF-D10 muxer",
3210  .item_name = av_default_item_name,
3211  .option = d10_options,
3212  .version = LIBAVUTIL_VERSION_INT,
3213 };
3214 
3215 static const AVOption opatom_options[] = {
3216  { "mxf_audio_edit_rate", "Audio edit rate for timecode",
3217  offsetof(MXFContext, audio_edit_rate), AV_OPT_TYPE_RATIONAL, {.dbl=25}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
3218  MXF_COMMON_OPTIONS
3219  { "store_user_comments", "",
3220  offsetof(MXFContext, store_user_comments), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
3221  { NULL },
3222 };
3223 
3224 static const AVClass mxf_opatom_muxer_class = {
3225  .class_name = "MXF-OPAtom muxer",
3226  .item_name = av_default_item_name,
3227  .option = opatom_options,
3228  .version = LIBAVUTIL_VERSION_INT,
3229 };
3230 
3231 const AVOutputFormat ff_mxf_muxer = {
3232  .name = "mxf",
3233  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3234  .mime_type = "application/mxf",
3235  .extensions = "mxf",
3236  .priv_data_size = sizeof(MXFContext),
3237  .audio_codec = AV_CODEC_ID_PCM_S16LE,
3238  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
3239  .init = mxf_init,
3240  .write_packet = mxf_write_packet,
3241  .write_trailer = mxf_write_footer,
3242  .deinit = mxf_deinit,
3243  .flags = AVFMT_NOTIMESTAMPS,
3244  .interleave_packet = mxf_interleave,
3245  .priv_class = &mxf_muxer_class,
3246 };
3247 
3248 const AVOutputFormat ff_mxf_d10_muxer = {
3249  .name = "mxf_d10",
3250  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format) D-10 Mapping"),
3251  .mime_type = "application/mxf",
3252  .priv_data_size = sizeof(MXFContext),
3253  .audio_codec = AV_CODEC_ID_PCM_S16LE,
3254  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
3255  .init = mxf_init,
3256  .write_packet = mxf_write_packet,
3257  .write_trailer = mxf_write_footer,
3258  .deinit = mxf_deinit,
3259  .flags = AVFMT_NOTIMESTAMPS,
3260  .interleave_packet = mxf_interleave,
3261  .priv_class = &mxf_d10_muxer_class,
3262 };
3263 
3264 const AVOutputFormat ff_mxf_opatom_muxer = {
3265  .name = "mxf_opatom",
3266  .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format) Operational Pattern Atom"),
3267  .mime_type = "application/mxf",
3268  .extensions = "mxf",
3269  .priv_data_size = sizeof(MXFContext),
3270  .audio_codec = AV_CODEC_ID_PCM_S16LE,
3271  .video_codec = AV_CODEC_ID_DNXHD,
3272  .init = mxf_init,
3273  .write_packet = mxf_write_packet,
3274  .write_trailer = mxf_write_footer,
3275  .deinit = mxf_deinit,
3276  .flags = AVFMT_NOTIMESTAMPS,
3277  .interleave_packet = mxf_interleave,
3278  .priv_class = &mxf_opatom_muxer_class,
3279 };
ff_mxf_muxer
const AVOutputFormat ff_mxf_muxer
Definition: mxfenc.c:3231
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:314
H264SPS
Definition: avc.h:68
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:77
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:424
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:1638
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:577
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
ff_mxf_color_primaries_uls
const MXFCodecUL ff_mxf_color_primaries_uls[]
Definition: mxf.c:92
AVOutputFormat::name
const char * name
Definition: avformat.h:504
d10_options
static const AVOption d10_options[]
Definition: mxfenc.c:3199
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
uid
UID uid
Definition: mxfenc.c:2198
opt.h
Track
Definition: ismindex.c:69
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
out
FILE * out
Definition: movenc.c:54
mxf_write_random_index_pack
static void mxf_write_random_index_pack(AVFormatContext *s)
Definition: mxfenc.c:2998
mxf_utf16len
static uint64_t mxf_utf16len(const char *utf8_str)
Definition: mxfenc.c:687
color
Definition: vf_paletteuse.c:600
state
static struct @322 state
MXFContext::tc
AVTimecode tc
timecode context
Definition: mxfenc.c:408
FF_MXF_MasteringDisplayMinimumLuminance
#define FF_MXF_MasteringDisplayMinimumLuminance
Definition: mxf.h:97
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
INDEX_H264
@ INDEX_H264
Definition: mxfenc.c:127
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:188
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:149
AVStream::priv_data
void * priv_data
Definition: avformat.h:951
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2660
mxf_write_opatom_body_partition
static int mxf_write_opatom_body_partition(AVFormatContext *s)
Definition: mxfenc.c:2805
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:50
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:475
MXF_COMMON_OPTIONS
#define MXF_COMMON_OPTIONS
Definition: mxfenc.c:3165
mxf_write_d10_audio_packet
static void mxf_write_d10_audio_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:2773
FF_MXF_MasteringDisplayPrimaries
#define FF_MXF_MasteringDisplayPrimaries
Definition: mxf.h:94
MXFPackage::type
enum MXFMetadataSetType type
Definition: mxfenc.c:113
DESCRIPTOR_COUNT
#define DESCRIPTOR_COUNT(essence_container_count)
Definition: mxfenc.c:607
pixdesc.h
deinit
static void deinit(AVFormatContext *s)
Definition: chromaprint.c:50
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
header_metadata_key
static const uint8_t header_metadata_key[]
partial key for header metadata
Definition: mxfenc.c:251
ContentStorage
@ ContentStorage
Definition: mxf.h:45
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
SourceClip
@ SourceClip
Definition: mxf.h:35
mxf_dv_uls
static const struct @278 mxf_dv_uls[]
AVOption
AVOption.
Definition: opt.h:247
MXFPackage::instance
int instance
Definition: mxfenc.c:114
AVTimecode::flags
uint32_t flags
flags such as drop frame, +24 hours support, ...
Definition: timecode.h:43
MXFContext::body_offset
uint64_t body_offset
Definition: mxfenc.c:413
MXFStreamContext::frame_size
int frame_size
frame size in bytes
Definition: mxfenc.c:96
ff_parse_creation_time_metadata
int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
Parse creation_time in AVFormatContext metadata if exists and warn if the parsing fails.
Definition: utils.c:1865
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:70
mxf_parse_dnxhd_frame
static int mxf_parse_dnxhd_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:2065
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
LIBAVFORMAT_VERSION_MICRO
#define LIBAVFORMAT_VERSION_MICRO
Definition: version.h:36
MXFStreamContext::index
int index
index in mxf_essence_container_uls table
Definition: mxfenc.c:80
avpriv_find_start_code
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
AVDictionary
Definition: dict.c:30
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
MXFStreamContext::signal_standard
int signal_standard
Definition: mxfenc.c:88
mxf_write_content_storage
static void mxf_write_content_storage(AVFormatContext *s, MXFPackage *packages, int package_count)
Definition: mxfenc.c:812
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
ff_choose_chroma_location
enum AVChromaLocation ff_choose_chroma_location(AVFormatContext *s, AVStream *st)
Chooses a timebase for muxing the specified stream.
Definition: mux.c:106
AV_OPT_TYPE_RATIONAL
@ AV_OPT_TYPE_RATIONAL
Definition: opt.h:229
rescale_mastering_luma
static uint32_t rescale_mastering_luma(AVRational q)
Definition: mxfenc.c:1102
ff_mxf_opatom_muxer
const AVOutputFormat ff_mxf_opatom_muxer
Definition: mxfenc.c:3264
mxf_muxer_class
static const AVClass mxf_muxer_class
Definition: mxfenc.c:3192
MXFContext
Definition: mxfdec.c:287
ff_mxf_color_trc_uls
const MXFCodecUL ff_mxf_color_trc_uls[]
Definition: mxf.c:107
TimecodeComponent
@ TimecodeComponent
Definition: mxf.h:36
MXFContainerEssenceEntry::codec_ul
UID codec_ul
Definition: mxfenc.c:107
INDEX_MPEG2
@ INDEX_MPEG2
Definition: mxfenc.c:119
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:1284
AV_WB64
#define AV_WB64(p, v)
Definition: intreadwrite.h:433
MXFStreamContext::interlaced
int interlaced
whether picture is interlaced
Definition: mxfenc.c:84
mxf_get_essence_container_ul_index
static int mxf_get_essence_container_ul_index(enum AVCodecID id)
Definition: mxfenc.c:492
mxf_avc_subdescriptor_key
static const UID mxf_avc_subdescriptor_key
Definition: mxfenc.c:1095
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:125
init
static int init
Definition: av_tx.c:47
MXFContainerEssenceEntry::write_desc
void(* write_desc)(AVFormatContext *, AVStream *)
Definition: mxfenc.c:108
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:147
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:51
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:2202
INDEX_JPEG2000
@ INDEX_JPEG2000
Definition: mxfenc.c:126
mxf.h
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
store_version
static void store_version(AVFormatContext *s)
Definition: mxfenc.c:742
KAG_SIZE
#define KAG_SIZE
Definition: mxfenc.c:68
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:1504
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:431
header_open_partition_key
static const uint8_t header_open_partition_key[]
Definition: mxfenc.c:243
mxf_write_footer
static int mxf_write_footer(AVFormatContext *s)
Definition: mxfenc.c:3025
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:79
mxf_local_tag_batch
static const MXFLocalTagPair mxf_local_tag_batch[]
SMPTE RP210 http://www.smpte-ra.org/mdd/index.html https://smpte-ra.org/sites/default/files/Labels....
Definition: mxfenc.c: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:105
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:504
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
dv_profile.h
MXFStreamContext::v_chroma_sub_sample
int v_chroma_sub_sample
Definition: mxfenc.c:90
LIBAVFORMAT_VERSION_MAJOR
#define LIBAVFORMAT_VERSION_MAJOR
Definition: version.h:34
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:1634
body_partition_key
static const uint8_t body_partition_key[]
Definition: mxfenc.c:246
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:1681
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:580
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:470
AVCodecParameters::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:148
avassert.h
mxf_write_package
static void mxf_write_package(AVFormatContext *s, MXFPackage *package)
Definition: mxfenc.c:1559
system_metadata_package_set_key
static const uint8_t system_metadata_package_set_key[]
Definition: mxfenc.c:2722
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
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
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:2014
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:152
mxf_dnxhd_codec_uls
static const struct @277 mxf_dnxhd_codec_uls[]
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:219
MXFStreamContext::h_chroma_sub_sample
int h_chroma_sub_sample
Definition: mxfenc.c:89
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c: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:1541
MXFStreamContext::temporal_reordering
int temporal_reordering
Definition: mxfenc.c:91
mxf_parse_h264_frame
static int mxf_parse_h264_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt, MXFIndexEntry *e)
Definition: mxfenc.c:2229
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:115
s
#define s(width, name)
Definition: cbs_vp9.c:257
MXFMetadataSetType
MXFMetadataSetType
Definition: mxf.h:31
AVCHROMA_LOC_TOP
@ AVCHROMA_LOC_TOP
Definition: pixfmt.h:621
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:277
MultipleDescriptor
@ MultipleDescriptor
Definition: mxf.h:39
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:128
FFFormatContext::packet_buffer
PacketList packet_buffer
This buffer is only needed when packets were already buffered but not decoded, for example to get the...
Definition: internal.h:107
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:222
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:136
AVDictionaryEntry::key
char * key
Definition: dict.h:80
frame_size
int frame_size
Definition: mxfenc.c:2199
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
ULIndex
ULIndex
Definition: mxfenc.c:118
AVCSubDescriptor
@ AVCSubDescriptor
Definition: mxf.h:52
mxf_parse_mpeg2_frame
static int mxf_parse_mpeg2_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt, MXFIndexEntry *e)
Definition: mxfenc.c:2377
mxf_write_wav_desc
static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1492
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
mxf_d10_muxer_class
static const AVClass mxf_d10_muxer_class
Definition: mxfenc.c:3208
mxf_cdci_descriptor_key
static const UID mxf_cdci_descriptor_key
Definition: mxfenc.c: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:1885
INDEX_WAV
@ INDEX_WAV
Definition: mxfenc.c:121
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:842
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
INDEX_DV
@ INDEX_DV
Definition: mxfenc.c:124
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
mxf_compare_timestamps
static int mxf_compare_timestamps(AVFormatContext *s, const AVPacket *next, const AVPacket *pkt)
Definition: mxfenc.c:3142
mxf_write_opatom_packet
static int mxf_write_opatom_packet(AVFormatContext *s, AVPacket *pkt, MXFIndexEntry *ie)
Definition: mxfenc.c:2826
key
const char * key
Definition: hwcontext_opencl.c:168
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:43
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:155
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:73
MXFContext::duration
uint64_t duration
Definition: mxfenc.c:407
MXFIndexEntry::slice_offset
unsigned slice_offset
offset of audio slice
Definition: mxfenc.c:72
SubDescriptor
@ SubDescriptor
Definition: mxf.h:46
AVFormatContext
Format I/O context.
Definition: avformat.h:1200
mxf_write_tagged_value
static int mxf_write_tagged_value(AVFormatContext *s, const char *name, const char *value)
Definition: mxfenc.c:1512
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:100
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1095
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
mxf_d10_container_uls
static const UID mxf_d10_container_uls[]
Definition: mxfenc.c:223
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
mxf_write_aes3_desc
static void mxf_write_aes3_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1498
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:965
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:593
NULL
#define NULL
Definition: coverity.c:32
MaterialPackage
@ MaterialPackage
Definition: mxf.h:33
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:98
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:618
mxf_write_essence_container_data
static int mxf_write_essence_container_data(AVFormatContext *s)
Definition: mxfenc.c:1659
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:3248
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:620
FF_MXF_MASTERING_CHROMA_DEN
#define FF_MXF_MASTERING_CHROMA_DEN
Definition: mxf.h:99
mxf_interleave_get_packet
static int mxf_interleave_get_packet(AVFormatContext *s, AVPacket *out, int flush)
Definition: mxfenc.c:3091
MXFContainerEssenceEntry
Definition: mxfenc.c:104
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:235
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: utils.c:1789
avc.h
MXFStreamContext::b_picture_count
int b_picture_count
maximum number of consecutive b pictures, used in mpeg-2 descriptor
Definition: mxfenc.c:99
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:1006
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
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:98
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:210
ffio_fill
void ffio_fill(AVIOContext *s, int b, int64_t count)
Definition: aviobuf.c:218
mxf_init
static int mxf_init(AVFormatContext *s)
Definition: mxfenc.c:2497
mxf_mpeg2_codec_uls
static const UID mxf_mpeg2_codec_uls[]
Definition: mxfenc.c:2344
PacketListEntry::next
struct PacketListEntry * next
Definition: packet_internal.h:27
mxf_write_index_table_segment
static void mxf_write_index_table_segment(AVFormatContext *s)
Definition: mxfenc.c:1739
MXFStreamContext::codec_ul
const UID * codec_ul
Definition: mxfenc.c:81
seed
static unsigned int seed
Definition: videogen.c:78
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:563
AVCodecParameters::level
int level
Definition: codec_par.h:121
INDEX_D10_AUDIO
@ INDEX_D10_AUDIO
Definition: mxfenc.c:123
AVTimecode::rate
AVRational rate
frame rate in rational form
Definition: timecode.h:44
h264_ps.h
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
cid
uint16_t cid
Definition: mxfenc.c:2039
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:83
mxf_compute_edit_unit_byte_count
static void mxf_compute_edit_unit_byte_count(AVFormatContext *s)
Definition: mxfenc.c:2855
mxf_deinit
static void mxf_deinit(AVFormatContext *s)
Definition: mxfenc.c:3082
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:57
mxf_indirect_value_utf16le
static const uint8_t mxf_indirect_value_utf16le[]
Definition: mxfenc.c:1510
FF_MXF_MasteringDisplayWhitePointChromaticity
#define FF_MXF_MasteringDisplayWhitePointChromaticity
Definition: mxf.h:95
MXFStreamContext::closed_gop
int closed_gop
gop is closed, used in mpeg-2 frame parsing
Definition: mxfenc.c:93
klv_encode_ber4_length
static void klv_encode_ber4_length(AVIOContext *pb, int len)
Definition: mxfenc.c:477
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:326
MXFContext::cbr_index
int cbr_index
use a constant bitrate index
Definition: mxfenc.c:422
AVPacket::size
int size
Definition: packet.h:374
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:1636
FF_PROFILE_PRORES_STANDARD
#define FF_PROFILE_PRORES_STANDARD
Definition: avcodec.h:1635
MXFStreamContext::color_siting
int color_siting
Definition: mxfenc.c:87
MXFStreamContext::pkt_cnt
int64_t pkt_cnt
pkt counter for muxed packets
Definition: mxfenc.c:78
sample
#define sample
Definition: flacdsp_template.c:44
mxf_write_packet
static int mxf_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mxfenc.c:2876
size
int size
Definition: twinvq_data.h:10344
Identification
@ Identification
Definition: mxf.h:44
INDEX_AES3
@ INDEX_AES3
Definition: mxfenc.c:120
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
mxf_update_klv_size
static void mxf_update_klv_size(AVIOContext *pb, int64_t pos)
Definition: mxfenc.c: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:120
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:372
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
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
av_reallocp_array
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
Definition: mem.c:232
mxf_opatom_muxer_class
static const AVClass mxf_opatom_muxer_class
Definition: mxfenc.c:3224
avio_wl32
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:386
IndexTableSegment
@ IndexTableSegment
Definition: mxf.h:47
mxf_gen_umid
static void mxf_gen_umid(AVFormatContext *s)
Definition: mxfenc.c:2461
mxf_write_system_item
static void mxf_write_system_item(AVFormatContext *s)
Definition: mxfenc.c:2724
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:3215
footer_partition_key
static const uint8_t footer_partition_key[]
Definition: mxfenc.c:240
mxf_prores_codec_uls
static const struct @276 mxf_prores_codec_uls[]
write_packet
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:727
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:52
MXFContext::footer_partition_offset
int64_t footer_partition_offset
Definition: mxfenc.c:395
container_ul
const UID container_ul
Definition: mxfenc.c:2111
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:2040
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:503
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:366
MXFContext::content_package_rate
int content_package_rate
content package rate in system element, see SMPTE 326M
Definition: mxfenc.c:412
avio_internal.h
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
klv_fill_size
static unsigned klv_fill_size(uint64_t size)
Definition: mxfenc.c:1730
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:2004
MXFStreamContext::slice_offset
int slice_offset
Definition: mxfenc.c:95
index
enum ULIndex index
Definition: mxfenc.c:134
AVCodecParameters::height
int height
Definition: codec_par.h:127
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:177
MXFStreamContext::container_ul
const UID * container_ul
Definition: mxfenc.c:82
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
mxf_parse_dv_frame
static int mxf_parse_dv_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mxfenc.c:2136
MXFContainerEssenceEntry::element_ul
UID element_ul
Definition: mxfenc.c:106
mxf_h264_codec_uls
static const struct @279 mxf_h264_codec_uls[]
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:74
mxf_d10_codec_uls
static const UID mxf_d10_codec_uls[]
Definition: mxfenc.c:214
mxf_write_timecode_component
static void mxf_write_timecode_component(AVFormatContext *s, AVStream *st, MXFPackage *package)
Definition: mxfenc.c:938
system_metadata_pack_key
static const uint8_t system_metadata_pack_key[]
Definition: mxfenc.c:2721
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:71
EssenceContainerData
@ EssenceContainerData
Definition: mxf.h:48
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:263
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:146
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:2003
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:128
FFStream::last_in_packet_buffer
PacketListEntry * last_in_packet_buffer
last packet in packet_buffer for this stream when muxing.
Definition: internal.h:393
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:580
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:141
MXFPackage
Definition: mxfdec.c:253
mxf_interleave
static int mxf_interleave(AVFormatContext *s, AVPacket *pkt, int flush, int has_packet)
Definition: mxfenc.c:3152
AV_TIMECODE_FLAG_DROPFRAME
@ AV_TIMECODE_FLAG_DROPFRAME
timecode is drop frame
Definition: timecode.h:36
MXFStreamContext::seq_closed_gop
int seq_closed_gop
all gops in sequence are closed, used in mpeg-2 descriptor
Definition: mxfenc.c:97
tag
uint32_t tag
Definition: movenc.c:1596
LIBAVFORMAT_VERSION
#define LIBAVFORMAT_VERSION
Definition: version.h:41
ret
ret
Definition: filter_design.txt:187
mxf_write_wav_common
static int64_t mxf_write_wav_common(AVFormatContext *s, AVStream *st, const UID key)
Definition: mxfenc.c:1477
AVFMT_FLAG_BITEXACT
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1335
AVStream
Stream structure.
Definition: avformat.h:935
LIBAVFORMAT_VERSION_MINOR
#define LIBAVFORMAT_VERSION_MINOR
Definition: version.h:35
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:1637
FF_PROFILE_PRORES_PROXY
#define FF_PROFILE_PRORES_PROXY
Definition: avcodec.h:1633
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 *stream, enum AVPacketSideDataType type, size_t *size)
Get side information from stream.
Definition: utils.c:1721
MXFLocalTagPair
Definition: mxf.h:86
mxf_write_partition
static int mxf_write_partition(AVFormatContext *s, int bodysid, int indexsid, const uint8_t *key, int write_metadata)
Definition: mxfenc.c:1897
ff_mxf_random_index_pack_key
const uint8_t ff_mxf_random_index_pack_key[16]
Definition: mxf.c:26
opatom_ul
static const uint8_t opatom_ul[]
Definition: mxfenc.c:239
mxf_essence_mappings
static const struct @275 mxf_essence_mappings[]
avio_put_str16be
int avio_put_str16be(AVIOContext *s, const char *str)
Convert an UTF-8 string to UTF-16BE and write it.
id
enum AVCodecID id
Definition: mxfenc.c:133
mxf_write_mpegvideo_desc
static void mxf_write_mpegvideo_desc(AVFormatContext *s, AVStream *st)
Definition: mxfenc.c:1392
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:943
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
random_seed.h
mxf_init_timecode
static int mxf_init_timecode(AVFormatContext *s, AVStream *st, AVRational tbc)
Definition: mxfenc.c:2473
MXFIndexEntry::temporal_ref
uint16_t temporal_ref
Definition: mxfenc.c:73
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
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:619
MXFStreamContext::low_delay
int low_delay
low delay, used in mpeg-2 descriptor
Definition: mxfenc.c:100
FF_MXF_MasteringDisplayMaximumLuminance
#define FF_MXF_MasteringDisplayMaximumLuminance
Definition: mxf.h:96
AVRational::den
int den
Denominator.
Definition: rational.h:60
MXFStreamContext::video_bit_rate
int video_bit_rate
Definition: mxfenc.c:94
mxf_mpegvideo_descriptor_key
static const UID mxf_mpegvideo_descriptor_key
Definition: mxfenc.c:1089
MXFStreamContext::aspect_ratio
AVRational aspect_ratio
display aspect ratio
Definition: mxfenc.c:92
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
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:2357
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
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: utils.c:1195
SourcePackage
@ SourcePackage
Definition: mxf.h:34
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:375
MXFStreamContext::avc_intra
int avc_intra
Definition: mxfenc.c:101
av_clip_uint16
#define av_clip_uint16
Definition: common.h:108
avio_wb64
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:460
INDEX_D10_VIDEO
@ INDEX_D10_VIDEO
Definition: mxfenc.c:122
mxf_generic_sound_descriptor_key
static const UID mxf_generic_sound_descriptor_key
Definition: mxfenc.c:1093
mxf_parse_timestamp
static uint64_t mxf_parse_timestamp(int64_t timestamp64)
Definition: mxfenc.c:2445
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:129
mastering_display_metadata.h
get_ue_golomb_long
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:104
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: codec_par.h:38
AVCodecParameters::format
int format
Definition: codec_par.h:84
MXFCodecUL
Definition: mxf.h:102
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:3185
MXFContainerEssenceEntry::container_ul
UID container_ul
Definition: mxfenc.c:105
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:60
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
write_metadata
static void write_metadata(AVFormatContext *s, unsigned int ts)
Definition: flvenc.c:274
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.
bytestream.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:67
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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:250
Sequence
@ Sequence
Definition: mxf.h:38
AVDictionaryEntry::value
char * value
Definition: dict.h:81
AVTimecode
Definition: timecode.h:41
AVIOContext::buf_ptr
unsigned char * buf_ptr
Current position in the buffer.
Definition: avio.h:228
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: 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:86
snprintf
#define snprintf
Definition: snprintf.h:34
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
UID
uint8_t UID[16]
Definition: mxf.h:29
mxf_write_primer_pack
static void mxf_write_primer_pack(AVFormatContext *s)
Definition: mxfenc.c:520
MXFCodecUL::uid
UID uid
Definition: mxf.h:103
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:85
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:261
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:146
Generated on Fri Jan 28 2022 19:22:09 for FFmpeg by   doxygen 1.8.17