1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage> {
6 storage: Storage,
7}
8impl<Storage> __BindgenBitfieldUnit<Storage> {
9 #[inline]
10 pub const fn new(storage: Storage) -> Self {
11 Self { storage }
12 }
13}
14impl<Storage> __BindgenBitfieldUnit<Storage>
15where
16 Storage: AsRef<[u8]> + AsMut<[u8]>,
17{
18 #[inline]
19 pub fn get_bit(&self, index: usize) -> bool {
20 debug_assert!(index / 8 < self.storage.as_ref().len());
21 let byte_index = index / 8;
22 let byte = self.storage.as_ref()[byte_index];
23 let bit_index = if cfg!(target_endian = "big") {
24 7 - (index % 8)
25 } else {
26 index % 8
27 };
28 let mask = 1 << bit_index;
29 byte & mask == mask
30 }
31 #[inline]
32 pub fn set_bit(&mut self, index: usize, val: bool) {
33 debug_assert!(index / 8 < self.storage.as_ref().len());
34 let byte_index = index / 8;
35 let byte = &mut self.storage.as_mut()[byte_index];
36 let bit_index = if cfg!(target_endian = "big") {
37 7 - (index % 8)
38 } else {
39 index % 8
40 };
41 let mask = 1 << bit_index;
42 if val {
43 *byte |= mask;
44 } else {
45 *byte &= !mask;
46 }
47 }
48 #[inline]
49 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
50 debug_assert!(bit_width <= 64);
51 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
52 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
53 let mut val = 0;
54 for i in 0..(bit_width as usize) {
55 if self.get_bit(i + bit_offset) {
56 let index = if cfg!(target_endian = "big") {
57 bit_width as usize - 1 - i
58 } else {
59 i
60 };
61 val |= 1 << index;
62 }
63 }
64 val
65 }
66 #[inline]
67 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
68 debug_assert!(bit_width <= 64);
69 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
70 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
71 for i in 0..(bit_width as usize) {
72 let mask = 1 << i;
73 let val_bit_is_set = val & mask == mask;
74 let index = if cfg!(target_endian = "big") {
75 bit_width as usize - 1 - i
76 } else {
77 i
78 };
79 self.set_bit(index + bit_offset, val_bit_is_set);
80 }
81 }
82}
83pub const _BSD_SOURCE: u32 = 1;
84pub const _XOPEN_SOURCE: u32 = 700;
85pub const __LITTLE_ENDIAN: u32 = 1234;
86pub const __BIG_ENDIAN: u32 = 4321;
87pub const __USE_TIME_BITS64: u32 = 1;
88pub const EOF: i32 = -1;
89pub const INT8_MIN: i32 = -128;
90pub const INT16_MIN: i32 = -32768;
91pub const INT32_MIN: i32 = -2147483648;
92pub const INT64_MIN: i64 = -9223372036854775808;
93pub const INT8_MAX: u32 = 127;
94pub const INT16_MAX: u32 = 32767;
95pub const INT32_MAX: u32 = 2147483647;
96pub const INT64_MAX: u64 = 9223372036854775807;
97pub const UINT8_MAX: u32 = 255;
98pub const UINT16_MAX: u32 = 65535;
99pub const UINT32_MAX: u32 = 4294967295;
100pub const UINT64_MAX: i32 = -1;
101pub const INT_FAST8_MIN: i32 = -128;
102pub const INT_FAST64_MIN: i64 = -9223372036854775808;
103pub const INT_LEAST8_MIN: i32 = -128;
104pub const INT_LEAST16_MIN: i32 = -32768;
105pub const INT_LEAST32_MIN: i32 = -2147483648;
106pub const INT_LEAST64_MIN: i64 = -9223372036854775808;
107pub const INT_FAST8_MAX: u32 = 127;
108pub const INT_FAST64_MAX: u64 = 9223372036854775807;
109pub const INT_LEAST8_MAX: u32 = 127;
110pub const INT_LEAST16_MAX: u32 = 32767;
111pub const INT_LEAST32_MAX: u32 = 2147483647;
112pub const INT_LEAST64_MAX: u64 = 9223372036854775807;
113pub const UINT_FAST8_MAX: u32 = 255;
114pub const UINT_FAST64_MAX: i32 = -1;
115pub const UINT_LEAST8_MAX: u32 = 255;
116pub const UINT_LEAST16_MAX: u32 = 65535;
117pub const UINT_LEAST32_MAX: u32 = 4294967295;
118pub const UINT_LEAST64_MAX: i32 = -1;
119pub const INTMAX_MIN: i64 = -9223372036854775808;
120pub const INTMAX_MAX: u64 = 9223372036854775807;
121pub const UINTMAX_MAX: i32 = -1;
122pub const WINT_MIN: u32 = 0;
123pub const WINT_MAX: u32 = 4294967295;
124pub const SIG_ATOMIC_MIN: i32 = -2147483648;
125pub const SIG_ATOMIC_MAX: u32 = 2147483647;
126pub const INT_FAST16_MIN: i32 = -32768;
127pub const INT_FAST32_MIN: i32 = -2147483648;
128pub const INT_FAST16_MAX: u32 = 32767;
129pub const INT_FAST32_MAX: u32 = 2147483647;
130pub const UINT_FAST16_MAX: u32 = 65535;
131pub const UINT_FAST32_MAX: u32 = 4294967295;
132pub const INTPTR_MIN: i32 = -2147483648;
133pub const INTPTR_MAX: u32 = 2147483647;
134pub const UINTPTR_MAX: u32 = 4294967295;
135pub const PTRDIFF_MIN: i32 = -2147483648;
136pub const PTRDIFF_MAX: u32 = 2147483647;
137pub const SIZE_MAX: u32 = 4294967295;
138pub const _IOFBF: u32 = 0;
139pub const _IOLBF: u32 = 1;
140pub const _IONBF: u32 = 2;
141pub const BUFSIZ: u32 = 1024;
142pub const FILENAME_MAX: u32 = 4096;
143pub const FOPEN_MAX: u32 = 1000;
144pub const L_ctermid: u32 = 20;
145pub const L_cuserid: u32 = 20;
146pub const FF_LAMBDA_SHIFT: u32 = 7;
147pub const FF_LAMBDA_SCALE: u32 = 128;
148pub const FF_QP2LAMBDA: u32 = 118;
149pub const FF_LAMBDA_MAX: u32 = 32767;
150pub const FF_QUALITY_SCALE: u32 = 128;
151pub const AV_TIME_BASE: u32 = 1000000;
152pub const CHAR_MIN: i32 = -128;
153pub const CHAR_MAX: u32 = 127;
154pub const CHAR_BIT: u32 = 8;
155pub const SCHAR_MIN: i32 = -128;
156pub const SCHAR_MAX: u32 = 127;
157pub const UCHAR_MAX: u32 = 255;
158pub const SHRT_MIN: i32 = -32768;
159pub const SHRT_MAX: u32 = 32767;
160pub const USHRT_MAX: u32 = 65535;
161pub const INT_MIN: i32 = -2147483648;
162pub const INT_MAX: u32 = 2147483647;
163pub const UINT_MAX: u32 = 4294967295;
164pub const LLONG_MAX: u64 = 9223372036854775807;
165pub const ULLONG_MAX: i32 = -1;
166pub const MB_LEN_MAX: u32 = 4;
167pub const PAGESIZE: u32 = 65536;
168pub const FILESIZEBITS: u32 = 64;
169pub const NAME_MAX: u32 = 255;
170pub const PATH_MAX: u32 = 4096;
171pub const NGROUPS_MAX: u32 = 32;
172pub const ARG_MAX: u32 = 131072;
173pub const IOV_MAX: u32 = 1024;
174pub const SYMLOOP_MAX: u32 = 40;
175pub const WORD_BIT: u32 = 32;
176pub const TZNAME_MAX: u32 = 6;
177pub const TTY_NAME_MAX: u32 = 32;
178pub const HOST_NAME_MAX: u32 = 255;
179pub const LONG_BIT: u32 = 32;
180pub const DELAYTIMER_MAX: u32 = 2147483647;
181pub const CHARCLASS_NAME_MAX: u32 = 14;
182pub const COLL_WEIGHTS_MAX: u32 = 2;
183pub const RE_DUP_MAX: u32 = 255;
184pub const NL_ARGMAX: u32 = 9;
185pub const NL_MSGMAX: u32 = 32767;
186pub const NL_SETMAX: u32 = 255;
187pub const NL_TEXTMAX: u32 = 2048;
188pub const PAGE_SIZE: u32 = 65536;
189pub const NZERO: u32 = 20;
190pub const NL_LANGMAX: u32 = 32;
191pub const NL_NMAX: u32 = 16;
192pub const _POSIX_AIO_LISTIO_MAX: u32 = 2;
193pub const _POSIX_AIO_MAX: u32 = 1;
194pub const _POSIX_ARG_MAX: u32 = 4096;
195pub const _POSIX_CHILD_MAX: u32 = 25;
196pub const _POSIX_CLOCKRES_MIN: u32 = 20000000;
197pub const _POSIX_DELAYTIMER_MAX: u32 = 32;
198pub const _POSIX_HOST_NAME_MAX: u32 = 255;
199pub const _POSIX_LINK_MAX: u32 = 8;
200pub const _POSIX_LOGIN_NAME_MAX: u32 = 9;
201pub const _POSIX_MAX_CANON: u32 = 255;
202pub const _POSIX_MAX_INPUT: u32 = 255;
203pub const _POSIX_MQ_OPEN_MAX: u32 = 8;
204pub const _POSIX_MQ_PRIO_MAX: u32 = 32;
205pub const _POSIX_NAME_MAX: u32 = 14;
206pub const _POSIX_NGROUPS_MAX: u32 = 8;
207pub const _POSIX_OPEN_MAX: u32 = 20;
208pub const _POSIX_PATH_MAX: u32 = 256;
209pub const _POSIX_PIPE_BUF: u32 = 512;
210pub const _POSIX_RE_DUP_MAX: u32 = 255;
211pub const _POSIX_RTSIG_MAX: u32 = 8;
212pub const _POSIX_SEM_NSEMS_MAX: u32 = 256;
213pub const _POSIX_SEM_VALUE_MAX: u32 = 32767;
214pub const _POSIX_SIGQUEUE_MAX: u32 = 32;
215pub const _POSIX_SSIZE_MAX: u32 = 32767;
216pub const _POSIX_STREAM_MAX: u32 = 8;
217pub const _POSIX_SS_REPL_MAX: u32 = 4;
218pub const _POSIX_SYMLINK_MAX: u32 = 255;
219pub const _POSIX_SYMLOOP_MAX: u32 = 8;
220pub const _POSIX_THREAD_DESTRUCTOR_ITERATIONS: u32 = 4;
221pub const _POSIX_THREAD_KEYS_MAX: u32 = 128;
222pub const _POSIX_THREAD_THREADS_MAX: u32 = 64;
223pub const _POSIX_TIMER_MAX: u32 = 32;
224pub const _POSIX_TRACE_EVENT_NAME_MAX: u32 = 30;
225pub const _POSIX_TRACE_NAME_MAX: u32 = 8;
226pub const _POSIX_TRACE_SYS_MAX: u32 = 8;
227pub const _POSIX_TRACE_USER_EVENT_MAX: u32 = 32;
228pub const _POSIX_TTY_NAME_MAX: u32 = 9;
229pub const _POSIX_TZNAME_MAX: u32 = 6;
230pub const _POSIX2_BC_BASE_MAX: u32 = 99;
231pub const _POSIX2_BC_DIM_MAX: u32 = 2048;
232pub const _POSIX2_BC_SCALE_MAX: u32 = 99;
233pub const _POSIX2_BC_STRING_MAX: u32 = 1000;
234pub const _POSIX2_CHARCLASS_NAME_MAX: u32 = 14;
235pub const _POSIX2_COLL_WEIGHTS_MAX: u32 = 2;
236pub const _POSIX2_EXPR_NEST_MAX: u32 = 32;
237pub const _POSIX2_LINE_MAX: u32 = 2048;
238pub const _POSIX2_RE_DUP_MAX: u32 = 255;
239pub const _XOPEN_IOV_MAX: u32 = 16;
240pub const _XOPEN_NAME_MAX: u32 = 255;
241pub const _XOPEN_PATH_MAX: u32 = 1024;
242pub const MATH_ERRNO: u32 = 1;
243pub const MATH_ERREXCEPT: u32 = 2;
244pub const math_errhandling: u32 = 2;
245pub const FP_ILOGBNAN: i32 = -2147483648;
246pub const FP_ILOGB0: i32 = -2147483648;
247pub const FP_NAN: u32 = 0;
248pub const FP_INFINITE: u32 = 1;
249pub const FP_ZERO: u32 = 2;
250pub const FP_SUBNORMAL: u32 = 3;
251pub const FP_NORMAL: u32 = 4;
252pub const M_E: f64 = 2.718281828459045;
253pub const M_LOG2E: f64 = 1.4426950408889634;
254pub const M_LOG10E: f64 = 0.4342944819032518;
255pub const M_LN2: f64 = 0.6931471805599453;
256pub const M_LN10: f64 = 2.302585092994046;
257pub const M_PI: f64 = 3.141592653589793;
258pub const M_PI_2: f64 = 1.5707963267948966;
259pub const M_PI_4: f64 = 0.7853981633974483;
260pub const M_1_PI: f64 = 0.3183098861837907;
261pub const M_2_PI: f64 = 0.6366197723675814;
262pub const M_2_SQRTPI: f64 = 1.1283791670955126;
263pub const M_SQRT2: f64 = 1.4142135623730951;
264pub const M_SQRT1_2: f64 = 0.7071067811865476;
265pub const EXIT_FAILURE: u32 = 1;
266pub const EXIT_SUCCESS: u32 = 0;
267pub const RAND_MAX: u32 = 2147483647;
268pub const AV_HAVE_BIGENDIAN: u32 = 0;
269pub const AV_HAVE_FAST_UNALIGNED: u32 = 0;
270pub const AVERROR_EXPERIMENTAL: i32 = -733130664;
271pub const AVERROR_INPUT_CHANGED: i32 = -1668179713;
272pub const AVERROR_OUTPUT_CHANGED: i32 = -1668179714;
273pub const AV_ERROR_MAX_STRING_SIZE: u32 = 64;
274pub const LIBAVUTIL_VERSION_MAJOR: u32 = 59;
275pub const LIBAVUTIL_VERSION_MINOR: u32 = 16;
276pub const LIBAVUTIL_VERSION_MICRO: u32 = 101;
277pub const M_Ef: f64 = 2.718281828459045;
278pub const M_LN2f: f64 = 0.6931471805599453;
279pub const M_LN10f: f64 = 2.302585092994046;
280pub const M_LOG2_10: f64 = 3.321928094887362;
281pub const M_LOG2_10f: f64 = 3.321928094887362;
282pub const M_PHI: f64 = 1.618033988749895;
283pub const M_PHIf: f64 = 1.618033988749895;
284pub const M_PIf: f64 = 3.141592653589793;
285pub const M_PI_2f: f64 = 1.5707963267948966;
286pub const M_PI_4f: f64 = 0.7853981633974483;
287pub const M_1_PIf: f64 = 0.3183098861837907;
288pub const M_2_PIf: f64 = 0.6366197723675814;
289pub const M_2_SQRTPIf: f64 = 1.1283791670955126;
290pub const M_SQRT1_2f: f64 = 0.7071067811865476;
291pub const M_SQRT2f: f64 = 1.4142135623730951;
292pub const __GNUC_VA_LIST: u32 = 1;
293pub const AV_LOG_QUIET: i32 = -8;
294pub const AV_LOG_PANIC: u32 = 0;
295pub const AV_LOG_FATAL: u32 = 8;
296pub const AV_LOG_ERROR: u32 = 16;
297pub const AV_LOG_WARNING: u32 = 24;
298pub const AV_LOG_INFO: u32 = 32;
299pub const AV_LOG_VERBOSE: u32 = 40;
300pub const AV_LOG_DEBUG: u32 = 48;
301pub const AV_LOG_TRACE: u32 = 56;
302pub const AV_LOG_MAX_OFFSET: u32 = 64;
303pub const AV_LOG_SKIP_REPEATED: u32 = 1;
304pub const AV_LOG_PRINT_LEVEL: u32 = 2;
305pub const AVPALETTE_SIZE: u32 = 1024;
306pub const AVPALETTE_COUNT: u32 = 256;
307pub const AV_VIDEO_MAX_PLANES: u32 = 4;
308pub const AV_FOURCC_MAX_STRING_SIZE: u32 = 32;
309pub const AV_CHANNEL_LAYOUT_RETYPE_FLAG_LOSSLESS: u32 = 1;
310pub const AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL: u32 = 2;
311pub const LIBAVCODEC_VERSION_MAJOR: u32 = 61;
312pub const AV_INPUT_BUFFER_PADDING_SIZE: u32 = 64;
313pub const AV_EF_CRCCHECK: u32 = 1;
314pub const AV_EF_BITSTREAM: u32 = 2;
315pub const AV_EF_BUFFER: u32 = 4;
316pub const AV_EF_EXPLODE: u32 = 8;
317pub const AV_EF_IGNORE_ERR: u32 = 32768;
318pub const AV_EF_CAREFUL: u32 = 65536;
319pub const AV_EF_COMPLIANT: u32 = 131072;
320pub const AV_EF_AGGRESSIVE: u32 = 262144;
321pub const FF_COMPLIANCE_VERY_STRICT: u32 = 2;
322pub const FF_COMPLIANCE_STRICT: u32 = 1;
323pub const FF_COMPLIANCE_NORMAL: u32 = 0;
324pub const FF_COMPLIANCE_UNOFFICIAL: i32 = -1;
325pub const FF_COMPLIANCE_EXPERIMENTAL: i32 = -2;
326pub const AV_PROFILE_UNKNOWN: i32 = -99;
327pub const AV_PROFILE_RESERVED: i32 = -100;
328pub const AV_PROFILE_AAC_MAIN: u32 = 0;
329pub const AV_PROFILE_AAC_LOW: u32 = 1;
330pub const AV_PROFILE_AAC_SSR: u32 = 2;
331pub const AV_PROFILE_AAC_LTP: u32 = 3;
332pub const AV_PROFILE_AAC_HE: u32 = 4;
333pub const AV_PROFILE_AAC_HE_V2: u32 = 28;
334pub const AV_PROFILE_AAC_LD: u32 = 22;
335pub const AV_PROFILE_AAC_ELD: u32 = 38;
336pub const AV_PROFILE_MPEG2_AAC_LOW: u32 = 128;
337pub const AV_PROFILE_MPEG2_AAC_HE: u32 = 131;
338pub const AV_PROFILE_DNXHD: u32 = 0;
339pub const AV_PROFILE_DNXHR_LB: u32 = 1;
340pub const AV_PROFILE_DNXHR_SQ: u32 = 2;
341pub const AV_PROFILE_DNXHR_HQ: u32 = 3;
342pub const AV_PROFILE_DNXHR_HQX: u32 = 4;
343pub const AV_PROFILE_DNXHR_444: u32 = 5;
344pub const AV_PROFILE_DTS: u32 = 20;
345pub const AV_PROFILE_DTS_ES: u32 = 30;
346pub const AV_PROFILE_DTS_96_24: u32 = 40;
347pub const AV_PROFILE_DTS_HD_HRA: u32 = 50;
348pub const AV_PROFILE_DTS_HD_MA: u32 = 60;
349pub const AV_PROFILE_DTS_EXPRESS: u32 = 70;
350pub const AV_PROFILE_DTS_HD_MA_X: u32 = 61;
351pub const AV_PROFILE_DTS_HD_MA_X_IMAX: u32 = 62;
352pub const AV_PROFILE_EAC3_DDP_ATMOS: u32 = 30;
353pub const AV_PROFILE_TRUEHD_ATMOS: u32 = 30;
354pub const AV_PROFILE_MPEG2_422: u32 = 0;
355pub const AV_PROFILE_MPEG2_HIGH: u32 = 1;
356pub const AV_PROFILE_MPEG2_SS: u32 = 2;
357pub const AV_PROFILE_MPEG2_SNR_SCALABLE: u32 = 3;
358pub const AV_PROFILE_MPEG2_MAIN: u32 = 4;
359pub const AV_PROFILE_MPEG2_SIMPLE: u32 = 5;
360pub const AV_PROFILE_H264_CONSTRAINED: u32 = 512;
361pub const AV_PROFILE_H264_INTRA: u32 = 2048;
362pub const AV_PROFILE_H264_BASELINE: u32 = 66;
363pub const AV_PROFILE_H264_CONSTRAINED_BASELINE: u32 = 578;
364pub const AV_PROFILE_H264_MAIN: u32 = 77;
365pub const AV_PROFILE_H264_EXTENDED: u32 = 88;
366pub const AV_PROFILE_H264_HIGH: u32 = 100;
367pub const AV_PROFILE_H264_HIGH_10: u32 = 110;
368pub const AV_PROFILE_H264_HIGH_10_INTRA: u32 = 2158;
369pub const AV_PROFILE_H264_MULTIVIEW_HIGH: u32 = 118;
370pub const AV_PROFILE_H264_HIGH_422: u32 = 122;
371pub const AV_PROFILE_H264_HIGH_422_INTRA: u32 = 2170;
372pub const AV_PROFILE_H264_STEREO_HIGH: u32 = 128;
373pub const AV_PROFILE_H264_HIGH_444: u32 = 144;
374pub const AV_PROFILE_H264_HIGH_444_PREDICTIVE: u32 = 244;
375pub const AV_PROFILE_H264_HIGH_444_INTRA: u32 = 2292;
376pub const AV_PROFILE_H264_CAVLC_444: u32 = 44;
377pub const AV_PROFILE_VC1_SIMPLE: u32 = 0;
378pub const AV_PROFILE_VC1_MAIN: u32 = 1;
379pub const AV_PROFILE_VC1_COMPLEX: u32 = 2;
380pub const AV_PROFILE_VC1_ADVANCED: u32 = 3;
381pub const AV_PROFILE_MPEG4_SIMPLE: u32 = 0;
382pub const AV_PROFILE_MPEG4_SIMPLE_SCALABLE: u32 = 1;
383pub const AV_PROFILE_MPEG4_CORE: u32 = 2;
384pub const AV_PROFILE_MPEG4_MAIN: u32 = 3;
385pub const AV_PROFILE_MPEG4_N_BIT: u32 = 4;
386pub const AV_PROFILE_MPEG4_SCALABLE_TEXTURE: u32 = 5;
387pub const AV_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION: u32 = 6;
388pub const AV_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE: u32 = 7;
389pub const AV_PROFILE_MPEG4_HYBRID: u32 = 8;
390pub const AV_PROFILE_MPEG4_ADVANCED_REAL_TIME: u32 = 9;
391pub const AV_PROFILE_MPEG4_CORE_SCALABLE: u32 = 10;
392pub const AV_PROFILE_MPEG4_ADVANCED_CODING: u32 = 11;
393pub const AV_PROFILE_MPEG4_ADVANCED_CORE: u32 = 12;
394pub const AV_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE: u32 = 13;
395pub const AV_PROFILE_MPEG4_SIMPLE_STUDIO: u32 = 14;
396pub const AV_PROFILE_MPEG4_ADVANCED_SIMPLE: u32 = 15;
397pub const AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0: u32 = 1;
398pub const AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1: u32 = 2;
399pub const AV_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION: u32 = 32768;
400pub const AV_PROFILE_JPEG2000_DCINEMA_2K: u32 = 3;
401pub const AV_PROFILE_JPEG2000_DCINEMA_4K: u32 = 4;
402pub const AV_PROFILE_VP9_0: u32 = 0;
403pub const AV_PROFILE_VP9_1: u32 = 1;
404pub const AV_PROFILE_VP9_2: u32 = 2;
405pub const AV_PROFILE_VP9_3: u32 = 3;
406pub const AV_PROFILE_HEVC_MAIN: u32 = 1;
407pub const AV_PROFILE_HEVC_MAIN_10: u32 = 2;
408pub const AV_PROFILE_HEVC_MAIN_STILL_PICTURE: u32 = 3;
409pub const AV_PROFILE_HEVC_REXT: u32 = 4;
410pub const AV_PROFILE_HEVC_SCC: u32 = 9;
411pub const AV_PROFILE_VVC_MAIN_10: u32 = 1;
412pub const AV_PROFILE_VVC_MAIN_10_444: u32 = 33;
413pub const AV_PROFILE_AV1_MAIN: u32 = 0;
414pub const AV_PROFILE_AV1_HIGH: u32 = 1;
415pub const AV_PROFILE_AV1_PROFESSIONAL: u32 = 2;
416pub const AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT: u32 = 192;
417pub const AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT: u32 = 193;
418pub const AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT: u32 = 194;
419pub const AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS: u32 = 195;
420pub const AV_PROFILE_MJPEG_JPEG_LS: u32 = 247;
421pub const AV_PROFILE_SBC_MSBC: u32 = 1;
422pub const AV_PROFILE_PRORES_PROXY: u32 = 0;
423pub const AV_PROFILE_PRORES_LT: u32 = 1;
424pub const AV_PROFILE_PRORES_STANDARD: u32 = 2;
425pub const AV_PROFILE_PRORES_HQ: u32 = 3;
426pub const AV_PROFILE_PRORES_4444: u32 = 4;
427pub const AV_PROFILE_PRORES_XQ: u32 = 5;
428pub const AV_PROFILE_ARIB_PROFILE_A: u32 = 0;
429pub const AV_PROFILE_ARIB_PROFILE_C: u32 = 1;
430pub const AV_PROFILE_KLVA_SYNC: u32 = 0;
431pub const AV_PROFILE_KLVA_ASYNC: u32 = 1;
432pub const AV_PROFILE_EVC_BASELINE: u32 = 0;
433pub const AV_PROFILE_EVC_MAIN: u32 = 1;
434pub const AV_LEVEL_UNKNOWN: i32 = -99;
435pub const AV_BUFFER_FLAG_READONLY: u32 = 1;
436pub const AV_DICT_MATCH_CASE: u32 = 1;
437pub const AV_DICT_IGNORE_SUFFIX: u32 = 2;
438pub const AV_DICT_DONT_STRDUP_KEY: u32 = 4;
439pub const AV_DICT_DONT_STRDUP_VAL: u32 = 8;
440pub const AV_DICT_DONT_OVERWRITE: u32 = 16;
441pub const AV_DICT_APPEND: u32 = 32;
442pub const AV_DICT_MULTIKEY: u32 = 64;
443pub const AV_PKT_FLAG_KEY: u32 = 1;
444pub const AV_PKT_FLAG_CORRUPT: u32 = 2;
445pub const AV_PKT_FLAG_DISCARD: u32 = 4;
446pub const AV_PKT_FLAG_TRUSTED: u32 = 8;
447pub const AV_PKT_FLAG_DISPOSABLE: u32 = 16;
448pub const LIBAVFORMAT_VERSION_MAJOR: u32 = 61;
449pub const FF_API_R_FRAME_RATE: u32 = 1;
450pub const AVIO_SEEKABLE_NORMAL: u32 = 1;
451pub const AVIO_SEEKABLE_TIME: u32 = 2;
452pub const AVSEEK_SIZE: u32 = 65536;
453pub const AVSEEK_FORCE: u32 = 131072;
454pub const AVIO_FLAG_READ: u32 = 1;
455pub const AVIO_FLAG_WRITE: u32 = 2;
456pub const AVIO_FLAG_READ_WRITE: u32 = 3;
457pub const AVIO_FLAG_NONBLOCK: u32 = 8;
458pub const AVIO_FLAG_DIRECT: u32 = 32768;
459pub const LIBAVFORMAT_VERSION_MINOR: u32 = 3;
460pub const LIBAVFORMAT_VERSION_MICRO: u32 = 103;
461pub const AV_NUM_DATA_POINTERS: u32 = 8;
462pub const AV_FRAME_FLAG_CORRUPT: u32 = 1;
463pub const AV_FRAME_FLAG_KEY: u32 = 2;
464pub const AV_FRAME_FLAG_DISCARD: u32 = 4;
465pub const AV_FRAME_FLAG_INTERLACED: u32 = 8;
466pub const AV_FRAME_FLAG_TOP_FIELD_FIRST: u32 = 16;
467pub const FF_DECODE_ERROR_INVALID_BITSTREAM: u32 = 1;
468pub const FF_DECODE_ERROR_MISSING_REFERENCE: u32 = 2;
469pub const FF_DECODE_ERROR_CONCEALMENT_ACTIVE: u32 = 4;
470pub const FF_DECODE_ERROR_DECODE_SLICES: u32 = 8;
471pub const AV_FRAME_SIDE_DATA_FLAG_UNIQUE: u32 = 1;
472pub const AV_FRAME_SIDE_DATA_FLAG_REPLACE: u32 = 2;
473pub const AV_CODEC_CAP_DRAW_HORIZ_BAND: u32 = 1;
474pub const AV_CODEC_CAP_DR1: u32 = 2;
475pub const AV_CODEC_CAP_DELAY: u32 = 32;
476pub const AV_CODEC_CAP_SMALL_LAST_FRAME: u32 = 64;
477pub const AV_CODEC_CAP_SUBFRAMES: u32 = 256;
478pub const AV_CODEC_CAP_EXPERIMENTAL: u32 = 512;
479pub const AV_CODEC_CAP_CHANNEL_CONF: u32 = 1024;
480pub const AV_CODEC_CAP_FRAME_THREADS: u32 = 4096;
481pub const AV_CODEC_CAP_SLICE_THREADS: u32 = 8192;
482pub const AV_CODEC_CAP_PARAM_CHANGE: u32 = 16384;
483pub const AV_CODEC_CAP_OTHER_THREADS: u32 = 32768;
484pub const AV_CODEC_CAP_VARIABLE_FRAME_SIZE: u32 = 65536;
485pub const AV_CODEC_CAP_AVOID_PROBING: u32 = 131072;
486pub const AV_CODEC_CAP_HARDWARE: u32 = 262144;
487pub const AV_CODEC_CAP_HYBRID: u32 = 524288;
488pub const AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE: u32 = 1048576;
489pub const AV_CODEC_CAP_ENCODER_FLUSH: u32 = 2097152;
490pub const AV_CODEC_CAP_ENCODER_RECON_FRAME: u32 = 4194304;
491pub const AVPROBE_SCORE_EXTENSION: u32 = 50;
492pub const AVPROBE_SCORE_MIME: u32 = 75;
493pub const AVPROBE_SCORE_MAX: u32 = 100;
494pub const AVPROBE_PADDING_SIZE: u32 = 32;
495pub const AVFMT_NOFILE: u32 = 1;
496pub const AVFMT_NEEDNUMBER: u32 = 2;
497pub const AVFMT_EXPERIMENTAL: u32 = 4;
498pub const AVFMT_SHOW_IDS: u32 = 8;
499pub const AVFMT_GLOBALHEADER: u32 = 64;
500pub const AVFMT_NOTIMESTAMPS: u32 = 128;
501pub const AVFMT_GENERIC_INDEX: u32 = 256;
502pub const AVFMT_TS_DISCONT: u32 = 512;
503pub const AVFMT_VARIABLE_FPS: u32 = 1024;
504pub const AVFMT_NODIMENSIONS: u32 = 2048;
505pub const AVFMT_NOSTREAMS: u32 = 4096;
506pub const AVFMT_NOBINSEARCH: u32 = 8192;
507pub const AVFMT_NOGENSEARCH: u32 = 16384;
508pub const AVFMT_NO_BYTE_SEEK: u32 = 32768;
509pub const AVFMT_ALLOW_FLUSH: u32 = 65536;
510pub const AVFMT_TS_NONSTRICT: u32 = 131072;
511pub const AVFMT_TS_NEGATIVE: u32 = 262144;
512pub const AVFMT_SEEK_TO_PTS: u32 = 67108864;
513pub const AVINDEX_KEYFRAME: u32 = 1;
514pub const AVINDEX_DISCARD_FRAME: u32 = 2;
515pub const AV_DISPOSITION_DEFAULT: u32 = 1;
516pub const AV_DISPOSITION_DUB: u32 = 2;
517pub const AV_DISPOSITION_ORIGINAL: u32 = 4;
518pub const AV_DISPOSITION_COMMENT: u32 = 8;
519pub const AV_DISPOSITION_LYRICS: u32 = 16;
520pub const AV_DISPOSITION_KARAOKE: u32 = 32;
521pub const AV_DISPOSITION_FORCED: u32 = 64;
522pub const AV_DISPOSITION_HEARING_IMPAIRED: u32 = 128;
523pub const AV_DISPOSITION_VISUAL_IMPAIRED: u32 = 256;
524pub const AV_DISPOSITION_CLEAN_EFFECTS: u32 = 512;
525pub const AV_DISPOSITION_ATTACHED_PIC: u32 = 1024;
526pub const AV_DISPOSITION_TIMED_THUMBNAILS: u32 = 2048;
527pub const AV_DISPOSITION_NON_DIEGETIC: u32 = 4096;
528pub const AV_DISPOSITION_CAPTIONS: u32 = 65536;
529pub const AV_DISPOSITION_DESCRIPTIONS: u32 = 131072;
530pub const AV_DISPOSITION_METADATA: u32 = 262144;
531pub const AV_DISPOSITION_DEPENDENT: u32 = 524288;
532pub const AV_DISPOSITION_STILL_IMAGE: u32 = 1048576;
533pub const AV_PTS_WRAP_IGNORE: u32 = 0;
534pub const AV_PTS_WRAP_ADD_OFFSET: u32 = 1;
535pub const AV_PTS_WRAP_SUB_OFFSET: i32 = -1;
536pub const AVSTREAM_EVENT_FLAG_METADATA_UPDATED: u32 = 1;
537pub const AVSTREAM_EVENT_FLAG_NEW_PACKETS: u32 = 2;
538pub const AV_PROGRAM_RUNNING: u32 = 1;
539pub const AVFMTCTX_NOHEADER: u32 = 1;
540pub const AVFMTCTX_UNSEEKABLE: u32 = 2;
541pub const AVFMT_FLAG_GENPTS: u32 = 1;
542pub const AVFMT_FLAG_IGNIDX: u32 = 2;
543pub const AVFMT_FLAG_NONBLOCK: u32 = 4;
544pub const AVFMT_FLAG_IGNDTS: u32 = 8;
545pub const AVFMT_FLAG_NOFILLIN: u32 = 16;
546pub const AVFMT_FLAG_NOPARSE: u32 = 32;
547pub const AVFMT_FLAG_NOBUFFER: u32 = 64;
548pub const AVFMT_FLAG_CUSTOM_IO: u32 = 128;
549pub const AVFMT_FLAG_DISCARD_CORRUPT: u32 = 256;
550pub const AVFMT_FLAG_FLUSH_PACKETS: u32 = 512;
551pub const AVFMT_FLAG_BITEXACT: u32 = 1024;
552pub const AVFMT_FLAG_SORT_DTS: u32 = 65536;
553pub const AVFMT_FLAG_FAST_SEEK: u32 = 524288;
554pub const AVFMT_FLAG_SHORTEST: u32 = 1048576;
555pub const AVFMT_FLAG_AUTO_BSF: u32 = 2097152;
556pub const FF_FDEBUG_TS: u32 = 1;
557pub const AVFMT_EVENT_FLAG_METADATA_UPDATED: u32 = 1;
558pub const AVFMT_AVOID_NEG_TS_AUTO: i32 = -1;
559pub const AVFMT_AVOID_NEG_TS_DISABLED: u32 = 0;
560pub const AVFMT_AVOID_NEG_TS_MAKE_NON_NEGATIVE: u32 = 1;
561pub const AVFMT_AVOID_NEG_TS_MAKE_ZERO: u32 = 2;
562pub const AVSEEK_FLAG_BACKWARD: u32 = 1;
563pub const AVSEEK_FLAG_BYTE: u32 = 2;
564pub const AVSEEK_FLAG_ANY: u32 = 4;
565pub const AVSEEK_FLAG_FRAME: u32 = 8;
566pub const AVSTREAM_INIT_IN_WRITE_HEADER: u32 = 0;
567pub const AVSTREAM_INIT_IN_INIT_OUTPUT: u32 = 1;
568pub const AV_FRAME_FILENAME_FLAGS_MULTIPLE: u32 = 1;
569pub type off_t = ::std::os::raw::c_longlong;
570pub type time_t = ::std::os::raw::c_longlong;
571pub type suseconds_t = ::std::os::raw::c_longlong;
572#[repr(C)]
573#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
574pub struct timeval {
575 pub tv_sec: time_t,
576 pub tv_usec: suseconds_t,
577}
578#[repr(C)]
579#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
580pub struct timespec {
581 pub tv_sec: time_t,
582 pub tv_nsec: ::std::os::raw::c_long,
583}
584#[repr(C)]
585#[derive(Debug, Copy, Clone)]
586pub struct _IO_FILE {
587 _unused: [u8; 0],
588}
589pub type FILE = _IO_FILE;
590pub type va_list = __builtin_va_list;
591pub type __isoc_va_list = __builtin_va_list;
592#[repr(C)]
593#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
594pub struct iovec {
595 pub iov_base: *mut ::std::os::raw::c_void,
596 pub iov_len: usize,
597}
598impl Default for iovec {
599 fn default() -> Self {
600 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
601 unsafe {
602 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
603 s.assume_init()
604 }
605 }
606}
607pub type wchar_t = ::std::os::raw::c_int;
608#[repr(C)]
609#[repr(align(16))]
610#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)]
611pub struct max_align_t {
612 pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
613 pub __bindgen_padding_0: u64,
614 pub __clang_max_align_nonce2: u128,
615}
616pub type intmax_t = ::std::os::raw::c_longlong;
617pub type uintmax_t = ::std::os::raw::c_ulonglong;
618pub type int_fast8_t = i8;
619pub type int_fast64_t = i64;
620pub type int_least8_t = i8;
621pub type int_least16_t = i16;
622pub type int_least32_t = i32;
623pub type int_least64_t = i64;
624pub type uint_fast8_t = u8;
625pub type uint_fast64_t = u64;
626pub type uint_least8_t = u8;
627pub type uint_least16_t = u16;
628pub type uint_least32_t = u32;
629pub type uint_least64_t = u64;
630pub type int_fast16_t = i16;
631pub type int_fast32_t = i32;
632pub type uint_fast16_t = u16;
633pub type uint_fast32_t = u32;
634pub type __wasi_size_t = ::std::os::raw::c_ulong;
635#[doc = " Non-negative file size or length of a region within a file."]
636pub type __wasi_filesize_t = u64;
637#[doc = " Timestamp in nanoseconds."]
638pub type __wasi_timestamp_t = u64;
639#[doc = " Identifiers for clocks."]
640pub type __wasi_clockid_t = u32;
641#[doc = " Error codes returned by functions.\n Not all of these error codes are returned by the functions provided by this\n API; some are used in higher-level library layers, and others are provided\n merely for alignment with POSIX."]
642pub type __wasi_errno_t = u16;
643#[doc = " File descriptor rights, determining which actions may be performed."]
644pub type __wasi_rights_t = u64;
645#[doc = " A file descriptor handle."]
646pub type __wasi_fd_t = ::std::os::raw::c_int;
647#[doc = " A region of memory for scatter/gather reads."]
648#[repr(C)]
649#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
650pub struct __wasi_iovec_t {
651 #[doc = " The address of the buffer to be filled."]
652 pub buf: *mut u8,
653 #[doc = " The length of the buffer to be filled."]
654 pub buf_len: __wasi_size_t,
655}
656impl Default for __wasi_iovec_t {
657 fn default() -> Self {
658 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
659 unsafe {
660 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
661 s.assume_init()
662 }
663 }
664}
665#[doc = " A region of memory for scatter/gather writes."]
666#[repr(C)]
667#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
668pub struct __wasi_ciovec_t {
669 #[doc = " The address of the buffer to be written."]
670 pub buf: *const u8,
671 #[doc = " The length of the buffer to be written."]
672 pub buf_len: __wasi_size_t,
673}
674impl Default for __wasi_ciovec_t {
675 fn default() -> Self {
676 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
677 unsafe {
678 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
679 s.assume_init()
680 }
681 }
682}
683#[doc = " Relative offset within a file."]
684pub type __wasi_filedelta_t = i64;
685#[doc = " The position relative to which to set the offset of the file descriptor."]
686pub type __wasi_whence_t = u8;
687#[doc = " A reference to the offset of a directory entry.\n\n The value 0 signifies the start of the directory."]
688pub type __wasi_dircookie_t = u64;
689#[doc = " The type for the `dirent::d_namlen` field of `dirent` struct."]
690pub type __wasi_dirnamlen_t = u32;
691#[doc = " File serial number that is unique within its file system."]
692pub type __wasi_inode_t = u64;
693#[doc = " The type of a file descriptor or file."]
694pub type __wasi_filetype_t = u8;
695#[doc = " A directory entry."]
696#[repr(C)]
697#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
698pub struct __wasi_dirent_t {
699 #[doc = " The offset of the next directory entry stored in this directory."]
700 pub d_next: __wasi_dircookie_t,
701 #[doc = " The serial number of the file referred to by this directory entry."]
702 pub d_ino: __wasi_inode_t,
703 #[doc = " The length of the name of the directory entry."]
704 pub d_namlen: __wasi_dirnamlen_t,
705 #[doc = " The type of the file referred to by this directory entry."]
706 pub d_type: __wasi_filetype_t,
707}
708#[doc = " File or memory access pattern advisory information."]
709pub type __wasi_advice_t = u8;
710#[doc = " File descriptor flags."]
711pub type __wasi_fdflags_t = u16;
712#[doc = " File descriptor attributes."]
713#[repr(C)]
714#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
715pub struct __wasi_fdstat_t {
716 #[doc = " File type."]
717 pub fs_filetype: __wasi_filetype_t,
718 #[doc = " File descriptor flags."]
719 pub fs_flags: __wasi_fdflags_t,
720 #[doc = " Rights that apply to this file descriptor."]
721 pub fs_rights_base: __wasi_rights_t,
722 #[doc = " Maximum set of rights that may be installed on new file descriptors that\n are created through this file descriptor, e.g., through `path_open`."]
723 pub fs_rights_inheriting: __wasi_rights_t,
724}
725#[doc = " Identifier for a device containing a file system. Can be used in combination\n with `inode` to uniquely identify a file or directory in the filesystem."]
726pub type __wasi_device_t = u64;
727#[doc = " Which file time attributes to adjust."]
728pub type __wasi_fstflags_t = u16;
729#[doc = " Flags determining the method of how paths are resolved."]
730pub type __wasi_lookupflags_t = u32;
731#[doc = " Open flags used by `path_open`."]
732pub type __wasi_oflags_t = u16;
733#[doc = " Number of hard links to an inode."]
734pub type __wasi_linkcount_t = u64;
735#[doc = " File attributes."]
736#[repr(C)]
737#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
738pub struct __wasi_filestat_t {
739 #[doc = " Device ID of device containing the file."]
740 pub dev: __wasi_device_t,
741 #[doc = " File serial number."]
742 pub ino: __wasi_inode_t,
743 #[doc = " File type."]
744 pub filetype: __wasi_filetype_t,
745 #[doc = " Number of hard links to the file."]
746 pub nlink: __wasi_linkcount_t,
747 #[doc = " For regular files, the file size in bytes. For symbolic links, the length in bytes of the pathname contained in the symbolic link."]
748 pub size: __wasi_filesize_t,
749 #[doc = " Last data access timestamp."]
750 pub atim: __wasi_timestamp_t,
751 #[doc = " Last data modification timestamp."]
752 pub mtim: __wasi_timestamp_t,
753 #[doc = " Last file status change timestamp."]
754 pub ctim: __wasi_timestamp_t,
755}
756#[doc = " User-provided value that may be attached to objects that is retained when\n extracted from the implementation."]
757pub type __wasi_userdata_t = u64;
758#[doc = " Type of a subscription to an event or its occurrence."]
759pub type __wasi_eventtype_t = u8;
760#[doc = " The state of the file descriptor subscribed to with\n `eventtype::fd_read` or `eventtype::fd_write`."]
761pub type __wasi_eventrwflags_t = u16;
762#[doc = " The contents of an `event` when type is `eventtype::fd_read` or\n `eventtype::fd_write`."]
763#[repr(C)]
764#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
765pub struct __wasi_event_fd_readwrite_t {
766 #[doc = " The number of bytes available for reading or writing."]
767 pub nbytes: __wasi_filesize_t,
768 #[doc = " The state of the file descriptor."]
769 pub flags: __wasi_eventrwflags_t,
770}
771#[doc = " An event that occurred."]
772#[repr(C)]
773#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
774pub struct __wasi_event_t {
775 #[doc = " User-provided value that got attached to `subscription::userdata`."]
776 pub userdata: __wasi_userdata_t,
777 #[doc = " If non-zero, an error that occurred while processing the subscription request."]
778 pub error: __wasi_errno_t,
779 #[doc = " The type of event that occured"]
780 pub type_: __wasi_eventtype_t,
781 #[doc = " The contents of the event, if it is an `eventtype::fd_read` or\n `eventtype::fd_write`. `eventtype::clock` events ignore this field."]
782 pub fd_readwrite: __wasi_event_fd_readwrite_t,
783}
784#[doc = " Flags determining how to interpret the timestamp provided in\n `subscription_clock::timeout`."]
785pub type __wasi_subclockflags_t = u16;
786#[doc = " The contents of a `subscription` when type is `eventtype::clock`."]
787#[repr(C)]
788#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
789pub struct __wasi_subscription_clock_t {
790 #[doc = " The clock against which to compare the timestamp."]
791 pub id: __wasi_clockid_t,
792 #[doc = " The absolute or relative timestamp."]
793 pub timeout: __wasi_timestamp_t,
794 #[doc = " The amount of time that the implementation may wait additionally\n to coalesce with other events."]
795 pub precision: __wasi_timestamp_t,
796 #[doc = " Flags specifying whether the timeout is absolute or relative"]
797 pub flags: __wasi_subclockflags_t,
798}
799#[doc = " The contents of a `subscription` when type is type is\n `eventtype::fd_read` or `eventtype::fd_write`."]
800#[repr(C)]
801#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
802pub struct __wasi_subscription_fd_readwrite_t {
803 #[doc = " The file descriptor on which to wait for it to become ready for reading or writing."]
804 pub file_descriptor: __wasi_fd_t,
805}
806#[doc = " The contents of a `subscription`."]
807#[repr(C)]
808#[derive(Copy, Clone)]
809pub union __wasi_subscription_u_u_t {
810 pub clock: __wasi_subscription_clock_t,
811 pub fd_read: __wasi_subscription_fd_readwrite_t,
812 pub fd_write: __wasi_subscription_fd_readwrite_t,
813}
814impl Default for __wasi_subscription_u_u_t {
815 fn default() -> Self {
816 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
817 unsafe {
818 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
819 s.assume_init()
820 }
821 }
822}
823#[repr(C)]
824#[derive(Copy, Clone)]
825pub struct __wasi_subscription_u_t {
826 pub tag: u8,
827 pub u: __wasi_subscription_u_u_t,
828}
829impl Default for __wasi_subscription_u_t {
830 fn default() -> Self {
831 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
832 unsafe {
833 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
834 s.assume_init()
835 }
836 }
837}
838#[doc = " Subscription to an event."]
839#[repr(C)]
840#[derive(Copy, Clone)]
841pub struct __wasi_subscription_t {
842 #[doc = " User-provided value that is attached to the subscription in the\n implementation and returned through `event::userdata`."]
843 pub userdata: __wasi_userdata_t,
844 #[doc = " The type of the event to which to subscribe, and its contents"]
845 pub u: __wasi_subscription_u_t,
846}
847impl Default for __wasi_subscription_t {
848 fn default() -> Self {
849 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
850 unsafe {
851 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
852 s.assume_init()
853 }
854 }
855}
856#[doc = " Exit code generated by a process when exiting."]
857pub type __wasi_exitcode_t = u32;
858#[doc = " Flags provided to `sock_recv`."]
859pub type __wasi_riflags_t = u16;
860#[doc = " Flags returned by `sock_recv`."]
861pub type __wasi_roflags_t = u16;
862#[doc = " Flags provided to `sock_send`. As there are currently no flags\n defined, it must be set to zero."]
863pub type __wasi_siflags_t = u16;
864#[doc = " Which channels on a socket to shut down."]
865pub type __wasi_sdflags_t = u8;
866#[doc = " Identifiers for preopened capabilities."]
867pub type __wasi_preopentype_t = u8;
868#[doc = " The contents of a $prestat when type is `preopentype::dir`."]
869#[repr(C)]
870#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
871pub struct __wasi_prestat_dir_t {
872 #[doc = " The length of the directory name for use with `fd_prestat_dir_name`."]
873 pub pr_name_len: __wasi_size_t,
874}
875#[doc = " Information about a pre-opened capability."]
876#[repr(C)]
877#[derive(Copy, Clone)]
878pub union __wasi_prestat_u_t {
879 pub dir: __wasi_prestat_dir_t,
880}
881impl Default for __wasi_prestat_u_t {
882 fn default() -> Self {
883 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
884 unsafe {
885 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
886 s.assume_init()
887 }
888 }
889}
890#[repr(C)]
891#[derive(Copy, Clone)]
892pub struct __wasi_prestat_t {
893 pub tag: u8,
894 pub u: __wasi_prestat_u_t,
895}
896impl Default for __wasi_prestat_t {
897 fn default() -> Self {
898 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
899 unsafe {
900 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
901 s.assume_init()
902 }
903 }
904}
905extern "C" {
906 #[must_use]
907 #[doc = " Read command-line argument data.\n The size of the array should match that returned by `args_sizes_get`.\n Each argument is expected to be `\\0` terminated."]
908 pub fn __wasi_args_get(argv: *mut *mut u8, argv_buf: *mut u8) -> __wasi_errno_t;
909}
910extern "C" {
911 #[must_use]
912 #[doc = " Return command-line argument data sizes.\n @return\n Returns the number of arguments and the size of the argument string\n data, or an error."]
913 pub fn __wasi_args_sizes_get(
914 retptr0: *mut __wasi_size_t,
915 retptr1: *mut __wasi_size_t,
916 ) -> __wasi_errno_t;
917}
918extern "C" {
919 #[must_use]
920 #[doc = " Read environment variable data.\n The sizes of the buffers should match that returned by `environ_sizes_get`.\n Key/value pairs are expected to be joined with `=`s, and terminated with `\\0`s."]
921 pub fn __wasi_environ_get(environ: *mut *mut u8, environ_buf: *mut u8) -> __wasi_errno_t;
922}
923extern "C" {
924 #[must_use]
925 #[doc = " Return environment variable data sizes.\n @return\n Returns the number of environment variable arguments and the size of the\n environment variable data."]
926 pub fn __wasi_environ_sizes_get(
927 retptr0: *mut __wasi_size_t,
928 retptr1: *mut __wasi_size_t,
929 ) -> __wasi_errno_t;
930}
931extern "C" {
932 #[must_use]
933 #[doc = " Return the resolution of a clock.\n Implementations are required to provide a non-zero value for supported clocks. For unsupported clocks,\n return `errno::inval`.\n Note: This is similar to `clock_getres` in POSIX.\n @return\n The resolution of the clock, or an error if one happened."]
934 pub fn __wasi_clock_res_get(
935 id: __wasi_clockid_t,
936 retptr0: *mut __wasi_timestamp_t,
937 ) -> __wasi_errno_t;
938}
939extern "C" {
940 #[must_use]
941 #[doc = " Return the time value of a clock.\n Note: This is similar to `clock_gettime` in POSIX.\n @return\n The time value of the clock."]
942 pub fn __wasi_clock_time_get(
943 id: __wasi_clockid_t,
944 precision: __wasi_timestamp_t,
945 retptr0: *mut __wasi_timestamp_t,
946 ) -> __wasi_errno_t;
947}
948extern "C" {
949 #[must_use]
950 #[doc = " Provide file advisory information on a file descriptor.\n Note: This is similar to `posix_fadvise` in POSIX."]
951 pub fn __wasi_fd_advise(
952 fd: __wasi_fd_t,
953 offset: __wasi_filesize_t,
954 len: __wasi_filesize_t,
955 advice: __wasi_advice_t,
956 ) -> __wasi_errno_t;
957}
958extern "C" {
959 #[must_use]
960 #[doc = " Force the allocation of space in a file.\n Note: This is similar to `posix_fallocate` in POSIX."]
961 pub fn __wasi_fd_allocate(
962 fd: __wasi_fd_t,
963 offset: __wasi_filesize_t,
964 len: __wasi_filesize_t,
965 ) -> __wasi_errno_t;
966}
967extern "C" {
968 #[must_use]
969 #[doc = " Close a file descriptor.\n Note: This is similar to `close` in POSIX."]
970 pub fn __wasi_fd_close(fd: __wasi_fd_t) -> __wasi_errno_t;
971}
972extern "C" {
973 #[must_use]
974 #[doc = " Synchronize the data of a file to disk.\n Note: This is similar to `fdatasync` in POSIX."]
975 pub fn __wasi_fd_datasync(fd: __wasi_fd_t) -> __wasi_errno_t;
976}
977extern "C" {
978 #[must_use]
979 #[doc = " Get the attributes of a file descriptor.\n Note: This returns similar flags to `fsync(fd, F_GETFL)` in POSIX, as well as additional fields.\n @return\n The buffer where the file descriptor's attributes are stored."]
980 pub fn __wasi_fd_fdstat_get(fd: __wasi_fd_t, retptr0: *mut __wasi_fdstat_t) -> __wasi_errno_t;
981}
982extern "C" {
983 #[must_use]
984 #[doc = " Adjust the flags associated with a file descriptor.\n Note: This is similar to `fcntl(fd, F_SETFL, flags)` in POSIX."]
985 pub fn __wasi_fd_fdstat_set_flags(fd: __wasi_fd_t, flags: __wasi_fdflags_t) -> __wasi_errno_t;
986}
987extern "C" {
988 #[must_use]
989 #[doc = " Adjust the rights associated with a file descriptor.\n This can only be used to remove rights, and returns `errno::notcapable` if called in a way that would attempt to add rights"]
990 pub fn __wasi_fd_fdstat_set_rights(
991 fd: __wasi_fd_t,
992 fs_rights_base: __wasi_rights_t,
993 fs_rights_inheriting: __wasi_rights_t,
994 ) -> __wasi_errno_t;
995}
996extern "C" {
997 #[must_use]
998 #[doc = " Return the attributes of an open file.\n @return\n The buffer where the file's attributes are stored."]
999 pub fn __wasi_fd_filestat_get(
1000 fd: __wasi_fd_t,
1001 retptr0: *mut __wasi_filestat_t,
1002 ) -> __wasi_errno_t;
1003}
1004extern "C" {
1005 #[must_use]
1006 #[doc = " Adjust the size of an open file. If this increases the file's size, the extra bytes are filled with zeros.\n Note: This is similar to `ftruncate` in POSIX."]
1007 pub fn __wasi_fd_filestat_set_size(fd: __wasi_fd_t, size: __wasi_filesize_t) -> __wasi_errno_t;
1008}
1009extern "C" {
1010 #[must_use]
1011 #[doc = " Adjust the timestamps of an open file or directory.\n Note: This is similar to `futimens` in POSIX."]
1012 pub fn __wasi_fd_filestat_set_times(
1013 fd: __wasi_fd_t,
1014 atim: __wasi_timestamp_t,
1015 mtim: __wasi_timestamp_t,
1016 fst_flags: __wasi_fstflags_t,
1017 ) -> __wasi_errno_t;
1018}
1019extern "C" {
1020 #[must_use]
1021 #[doc = " Read from a file descriptor, without using and updating the file descriptor's offset.\n Note: This is similar to `preadv` in POSIX.\n @return\n The number of bytes read."]
1022 pub fn __wasi_fd_pread(
1023 fd: __wasi_fd_t,
1024 iovs: *const __wasi_iovec_t,
1025 iovs_len: usize,
1026 offset: __wasi_filesize_t,
1027 retptr0: *mut __wasi_size_t,
1028 ) -> __wasi_errno_t;
1029}
1030extern "C" {
1031 #[must_use]
1032 #[doc = " Return a description of the given preopened file descriptor.\n @return\n The buffer where the description is stored."]
1033 pub fn __wasi_fd_prestat_get(fd: __wasi_fd_t, retptr0: *mut __wasi_prestat_t)
1034 -> __wasi_errno_t;
1035}
1036extern "C" {
1037 #[must_use]
1038 #[doc = " Return a description of the given preopened file descriptor."]
1039 pub fn __wasi_fd_prestat_dir_name(
1040 fd: __wasi_fd_t,
1041 path: *mut u8,
1042 path_len: __wasi_size_t,
1043 ) -> __wasi_errno_t;
1044}
1045extern "C" {
1046 #[must_use]
1047 #[doc = " Write to a file descriptor, without using and updating the file descriptor's offset.\n Note: This is similar to `pwritev` in POSIX.\n @return\n The number of bytes written."]
1048 pub fn __wasi_fd_pwrite(
1049 fd: __wasi_fd_t,
1050 iovs: *const __wasi_ciovec_t,
1051 iovs_len: usize,
1052 offset: __wasi_filesize_t,
1053 retptr0: *mut __wasi_size_t,
1054 ) -> __wasi_errno_t;
1055}
1056extern "C" {
1057 #[must_use]
1058 #[doc = " Read from a file descriptor.\n Note: This is similar to `readv` in POSIX.\n @return\n The number of bytes read."]
1059 pub fn __wasi_fd_read(
1060 fd: __wasi_fd_t,
1061 iovs: *const __wasi_iovec_t,
1062 iovs_len: usize,
1063 retptr0: *mut __wasi_size_t,
1064 ) -> __wasi_errno_t;
1065}
1066extern "C" {
1067 #[must_use]
1068 #[doc = " Read directory entries from a directory.\n When successful, the contents of the output buffer consist of a sequence of\n directory entries. Each directory entry consists of a `dirent` object,\n followed by `dirent::d_namlen` bytes holding the name of the directory\n entry.\n This function fills the output buffer as much as possible, potentially\n truncating the last directory entry. This allows the caller to grow its\n read buffer size in case it's too small to fit a single large directory\n entry, or skip the oversized directory entry.\n @return\n The number of bytes stored in the read buffer. If less than the size of the read buffer, the end of the directory has been reached."]
1069 pub fn __wasi_fd_readdir(
1070 fd: __wasi_fd_t,
1071 buf: *mut u8,
1072 buf_len: __wasi_size_t,
1073 cookie: __wasi_dircookie_t,
1074 retptr0: *mut __wasi_size_t,
1075 ) -> __wasi_errno_t;
1076}
1077extern "C" {
1078 #[must_use]
1079 #[doc = " Atomically replace a file descriptor by renumbering another file descriptor.\n Due to the strong focus on thread safety, this environment does not provide\n a mechanism to duplicate or renumber a file descriptor to an arbitrary\n number, like `dup2()`. This would be prone to race conditions, as an actual\n file descriptor with the same number could be allocated by a different\n thread at the same time.\n This function provides a way to atomically renumber file descriptors, which\n would disappear if `dup2()` were to be removed entirely."]
1080 pub fn __wasi_fd_renumber(fd: __wasi_fd_t, to: __wasi_fd_t) -> __wasi_errno_t;
1081}
1082extern "C" {
1083 #[must_use]
1084 #[doc = " Move the offset of a file descriptor.\n Note: This is similar to `lseek` in POSIX.\n @return\n The new offset of the file descriptor, relative to the start of the file."]
1085 pub fn __wasi_fd_seek(
1086 fd: __wasi_fd_t,
1087 offset: __wasi_filedelta_t,
1088 whence: __wasi_whence_t,
1089 retptr0: *mut __wasi_filesize_t,
1090 ) -> __wasi_errno_t;
1091}
1092extern "C" {
1093 #[must_use]
1094 #[doc = " Synchronize the data and metadata of a file to disk.\n Note: This is similar to `fsync` in POSIX."]
1095 pub fn __wasi_fd_sync(fd: __wasi_fd_t) -> __wasi_errno_t;
1096}
1097extern "C" {
1098 #[must_use]
1099 #[doc = " Return the current offset of a file descriptor.\n Note: This is similar to `lseek(fd, 0, SEEK_CUR)` in POSIX.\n @return\n The current offset of the file descriptor, relative to the start of the file."]
1100 pub fn __wasi_fd_tell(fd: __wasi_fd_t, retptr0: *mut __wasi_filesize_t) -> __wasi_errno_t;
1101}
1102extern "C" {
1103 #[must_use]
1104 #[doc = " Write to a file descriptor.\n Note: This is similar to `writev` in POSIX."]
1105 pub fn __wasi_fd_write(
1106 fd: __wasi_fd_t,
1107 iovs: *const __wasi_ciovec_t,
1108 iovs_len: usize,
1109 retptr0: *mut __wasi_size_t,
1110 ) -> __wasi_errno_t;
1111}
1112extern "C" {
1113 #[must_use]
1114 #[doc = " Create a directory.\n Note: This is similar to `mkdirat` in POSIX."]
1115 pub fn __wasi_path_create_directory(
1116 fd: __wasi_fd_t,
1117 path: *const ::std::os::raw::c_char,
1118 ) -> __wasi_errno_t;
1119}
1120extern "C" {
1121 #[must_use]
1122 #[doc = " Return the attributes of a file or directory.\n Note: This is similar to `stat` in POSIX.\n @return\n The buffer where the file's attributes are stored."]
1123 pub fn __wasi_path_filestat_get(
1124 fd: __wasi_fd_t,
1125 flags: __wasi_lookupflags_t,
1126 path: *const ::std::os::raw::c_char,
1127 retptr0: *mut __wasi_filestat_t,
1128 ) -> __wasi_errno_t;
1129}
1130extern "C" {
1131 #[must_use]
1132 #[doc = " Adjust the timestamps of a file or directory.\n Note: This is similar to `utimensat` in POSIX."]
1133 pub fn __wasi_path_filestat_set_times(
1134 fd: __wasi_fd_t,
1135 flags: __wasi_lookupflags_t,
1136 path: *const ::std::os::raw::c_char,
1137 atim: __wasi_timestamp_t,
1138 mtim: __wasi_timestamp_t,
1139 fst_flags: __wasi_fstflags_t,
1140 ) -> __wasi_errno_t;
1141}
1142extern "C" {
1143 #[must_use]
1144 #[doc = " Create a hard link.\n Note: This is similar to `linkat` in POSIX."]
1145 pub fn __wasi_path_link(
1146 old_fd: __wasi_fd_t,
1147 old_flags: __wasi_lookupflags_t,
1148 old_path: *const ::std::os::raw::c_char,
1149 new_fd: __wasi_fd_t,
1150 new_path: *const ::std::os::raw::c_char,
1151 ) -> __wasi_errno_t;
1152}
1153extern "C" {
1154 #[must_use]
1155 #[doc = " Open a file or directory.\n The returned file descriptor is not guaranteed to be the lowest-numbered\n file descriptor not currently open; it is randomized to prevent\n applications from depending on making assumptions about indexes, since this\n is error-prone in multi-threaded contexts. The returned file descriptor is\n guaranteed to be less than 2**31.\n Note: This is similar to `openat` in POSIX.\n @return\n The file descriptor of the file that has been opened."]
1156 pub fn __wasi_path_open(
1157 fd: __wasi_fd_t,
1158 dirflags: __wasi_lookupflags_t,
1159 path: *const ::std::os::raw::c_char,
1160 oflags: __wasi_oflags_t,
1161 fs_rights_base: __wasi_rights_t,
1162 fs_rights_inheriting: __wasi_rights_t,
1163 fdflags: __wasi_fdflags_t,
1164 retptr0: *mut __wasi_fd_t,
1165 ) -> __wasi_errno_t;
1166}
1167extern "C" {
1168 #[must_use]
1169 #[doc = " Read the contents of a symbolic link.\n Note: This is similar to `readlinkat` in POSIX.\n @return\n The number of bytes placed in the buffer."]
1170 pub fn __wasi_path_readlink(
1171 fd: __wasi_fd_t,
1172 path: *const ::std::os::raw::c_char,
1173 buf: *mut u8,
1174 buf_len: __wasi_size_t,
1175 retptr0: *mut __wasi_size_t,
1176 ) -> __wasi_errno_t;
1177}
1178extern "C" {
1179 #[must_use]
1180 #[doc = " Remove a directory.\n Return `errno::notempty` if the directory is not empty.\n Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX."]
1181 pub fn __wasi_path_remove_directory(
1182 fd: __wasi_fd_t,
1183 path: *const ::std::os::raw::c_char,
1184 ) -> __wasi_errno_t;
1185}
1186extern "C" {
1187 #[must_use]
1188 #[doc = " Rename a file or directory.\n Note: This is similar to `renameat` in POSIX."]
1189 pub fn __wasi_path_rename(
1190 fd: __wasi_fd_t,
1191 old_path: *const ::std::os::raw::c_char,
1192 new_fd: __wasi_fd_t,
1193 new_path: *const ::std::os::raw::c_char,
1194 ) -> __wasi_errno_t;
1195}
1196extern "C" {
1197 #[must_use]
1198 #[doc = " Create a symbolic link.\n Note: This is similar to `symlinkat` in POSIX."]
1199 pub fn __wasi_path_symlink(
1200 old_path: *const ::std::os::raw::c_char,
1201 fd: __wasi_fd_t,
1202 new_path: *const ::std::os::raw::c_char,
1203 ) -> __wasi_errno_t;
1204}
1205extern "C" {
1206 #[must_use]
1207 #[doc = " Unlink a file.\n Return `errno::isdir` if the path refers to a directory.\n Note: This is similar to `unlinkat(fd, path, 0)` in POSIX."]
1208 pub fn __wasi_path_unlink_file(
1209 fd: __wasi_fd_t,
1210 path: *const ::std::os::raw::c_char,
1211 ) -> __wasi_errno_t;
1212}
1213extern "C" {
1214 #[must_use]
1215 #[doc = " Concurrently poll for the occurrence of a set of events.\n @return\n The number of events stored."]
1216 pub fn __wasi_poll_oneoff(
1217 in_: *const __wasi_subscription_t,
1218 out: *mut __wasi_event_t,
1219 nsubscriptions: __wasi_size_t,
1220 retptr0: *mut __wasi_size_t,
1221 ) -> __wasi_errno_t;
1222}
1223extern "C" {
1224 #[doc = " Terminate the process normally. An exit code of 0 indicates successful\n termination of the program. The meanings of other values is dependent on\n the environment."]
1225 pub fn __wasi_proc_exit(rval: __wasi_exitcode_t) -> !;
1226}
1227extern "C" {
1228 #[must_use]
1229 #[doc = " Temporarily yield execution of the calling thread.\n Note: This is similar to `sched_yield` in POSIX."]
1230 pub fn __wasi_sched_yield() -> __wasi_errno_t;
1231}
1232extern "C" {
1233 #[must_use]
1234 #[doc = " Write high-quality random data into a buffer.\n This function blocks when the implementation is unable to immediately\n provide sufficient high-quality random data.\n This function may execute slowly, so when large mounts of random data are\n required, it's advisable to use this function to seed a pseudo-random\n number generator, rather than to provide the random data directly."]
1235 pub fn __wasi_random_get(buf: *mut u8, buf_len: __wasi_size_t) -> __wasi_errno_t;
1236}
1237extern "C" {
1238 #[must_use]
1239 #[doc = " Accept a new incoming connection.\n Note: This is similar to `accept` in POSIX.\n @return\n New socket connection"]
1240 pub fn __wasi_sock_accept(
1241 fd: __wasi_fd_t,
1242 flags: __wasi_fdflags_t,
1243 retptr0: *mut __wasi_fd_t,
1244 ) -> __wasi_errno_t;
1245}
1246extern "C" {
1247 #[must_use]
1248 #[doc = " Receive a message from a socket.\n Note: This is similar to `recv` in POSIX, though it also supports reading\n the data into multiple buffers in the manner of `readv`.\n @return\n Number of bytes stored in ri_data and message flags."]
1249 pub fn __wasi_sock_recv(
1250 fd: __wasi_fd_t,
1251 ri_data: *const __wasi_iovec_t,
1252 ri_data_len: usize,
1253 ri_flags: __wasi_riflags_t,
1254 retptr0: *mut __wasi_size_t,
1255 retptr1: *mut __wasi_roflags_t,
1256 ) -> __wasi_errno_t;
1257}
1258extern "C" {
1259 #[must_use]
1260 #[doc = " Send a message on a socket.\n Note: This is similar to `send` in POSIX, though it also supports writing\n the data from multiple buffers in the manner of `writev`.\n @return\n Number of bytes transmitted."]
1261 pub fn __wasi_sock_send(
1262 fd: __wasi_fd_t,
1263 si_data: *const __wasi_ciovec_t,
1264 si_data_len: usize,
1265 si_flags: __wasi_siflags_t,
1266 retptr0: *mut __wasi_size_t,
1267 ) -> __wasi_errno_t;
1268}
1269extern "C" {
1270 #[must_use]
1271 #[doc = " Shut down socket send and receive channels.\n Note: This is similar to `shutdown` in POSIX."]
1272 pub fn __wasi_sock_shutdown(fd: __wasi_fd_t, how: __wasi_sdflags_t) -> __wasi_errno_t;
1273}
1274#[repr(C)]
1275#[derive(Copy, Clone)]
1276pub union _G_fpos64_t {
1277 pub __opaque: [::std::os::raw::c_char; 16usize],
1278 pub __lldata: ::std::os::raw::c_longlong,
1279 pub __align: f64,
1280}
1281impl Default for _G_fpos64_t {
1282 fn default() -> Self {
1283 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1284 unsafe {
1285 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1286 s.assume_init()
1287 }
1288 }
1289}
1290pub type fpos_t = _G_fpos64_t;
1291extern "C" {
1292 pub static stdin: *mut FILE;
1293}
1294extern "C" {
1295 pub static stdout: *mut FILE;
1296}
1297extern "C" {
1298 pub static stderr: *mut FILE;
1299}
1300extern "C" {
1301 pub fn fopen(
1302 arg1: *const ::std::os::raw::c_char,
1303 arg2: *const ::std::os::raw::c_char,
1304 ) -> *mut FILE;
1305}
1306extern "C" {
1307 pub fn freopen(
1308 arg1: *const ::std::os::raw::c_char,
1309 arg2: *const ::std::os::raw::c_char,
1310 arg3: *mut FILE,
1311 ) -> *mut FILE;
1312}
1313extern "C" {
1314 pub fn fclose(arg1: *mut FILE) -> ::std::os::raw::c_int;
1315}
1316extern "C" {
1317 pub fn remove(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1318}
1319extern "C" {
1320 pub fn rename(
1321 arg1: *const ::std::os::raw::c_char,
1322 arg2: *const ::std::os::raw::c_char,
1323 ) -> ::std::os::raw::c_int;
1324}
1325extern "C" {
1326 pub fn feof(arg1: *mut FILE) -> ::std::os::raw::c_int;
1327}
1328extern "C" {
1329 pub fn ferror(arg1: *mut FILE) -> ::std::os::raw::c_int;
1330}
1331extern "C" {
1332 pub fn fflush(arg1: *mut FILE) -> ::std::os::raw::c_int;
1333}
1334extern "C" {
1335 pub fn clearerr(arg1: *mut FILE);
1336}
1337extern "C" {
1338 pub fn fseek(
1339 arg1: *mut FILE,
1340 arg2: ::std::os::raw::c_long,
1341 arg3: ::std::os::raw::c_int,
1342 ) -> ::std::os::raw::c_int;
1343}
1344extern "C" {
1345 pub fn ftell(arg1: *mut FILE) -> ::std::os::raw::c_long;
1346}
1347extern "C" {
1348 pub fn rewind(arg1: *mut FILE);
1349}
1350extern "C" {
1351 pub fn fgetpos(arg1: *mut FILE, arg2: *mut fpos_t) -> ::std::os::raw::c_int;
1352}
1353extern "C" {
1354 pub fn fsetpos(arg1: *mut FILE, arg2: *const fpos_t) -> ::std::os::raw::c_int;
1355}
1356extern "C" {
1357 pub fn fread(
1358 arg1: *mut ::std::os::raw::c_void,
1359 arg2: ::std::os::raw::c_ulong,
1360 arg3: ::std::os::raw::c_ulong,
1361 arg4: *mut FILE,
1362 ) -> ::std::os::raw::c_ulong;
1363}
1364extern "C" {
1365 pub fn fwrite(
1366 arg1: *const ::std::os::raw::c_void,
1367 arg2: ::std::os::raw::c_ulong,
1368 arg3: ::std::os::raw::c_ulong,
1369 arg4: *mut FILE,
1370 ) -> ::std::os::raw::c_ulong;
1371}
1372extern "C" {
1373 pub fn fgetc(arg1: *mut FILE) -> ::std::os::raw::c_int;
1374}
1375extern "C" {
1376 pub fn getc(arg1: *mut FILE) -> ::std::os::raw::c_int;
1377}
1378extern "C" {
1379 pub fn getchar() -> ::std::os::raw::c_int;
1380}
1381extern "C" {
1382 pub fn ungetc(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1383}
1384extern "C" {
1385 pub fn fputc(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1386}
1387extern "C" {
1388 pub fn putc(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1389}
1390extern "C" {
1391 pub fn putchar(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1392}
1393extern "C" {
1394 pub fn fgets(
1395 arg1: *mut ::std::os::raw::c_char,
1396 arg2: ::std::os::raw::c_int,
1397 arg3: *mut FILE,
1398 ) -> *mut ::std::os::raw::c_char;
1399}
1400extern "C" {
1401 pub fn fputs(arg1: *const ::std::os::raw::c_char, arg2: *mut FILE) -> ::std::os::raw::c_int;
1402}
1403extern "C" {
1404 pub fn puts(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1405}
1406extern "C" {
1407 pub fn printf(arg1: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
1408}
1409extern "C" {
1410 pub fn fprintf(
1411 arg1: *mut FILE,
1412 arg2: *const ::std::os::raw::c_char,
1413 ...
1414 ) -> ::std::os::raw::c_int;
1415}
1416extern "C" {
1417 pub fn sprintf(
1418 arg1: *mut ::std::os::raw::c_char,
1419 arg2: *const ::std::os::raw::c_char,
1420 ...
1421 ) -> ::std::os::raw::c_int;
1422}
1423extern "C" {
1424 pub fn snprintf(
1425 arg1: *mut ::std::os::raw::c_char,
1426 arg2: ::std::os::raw::c_ulong,
1427 arg3: *const ::std::os::raw::c_char,
1428 ...
1429 ) -> ::std::os::raw::c_int;
1430}
1431extern "C" {
1432 pub fn vprintf(
1433 arg1: *const ::std::os::raw::c_char,
1434 arg2: __builtin_va_list,
1435 ) -> ::std::os::raw::c_int;
1436}
1437extern "C" {
1438 pub fn vfprintf(
1439 arg1: *mut FILE,
1440 arg2: *const ::std::os::raw::c_char,
1441 arg3: __builtin_va_list,
1442 ) -> ::std::os::raw::c_int;
1443}
1444extern "C" {
1445 pub fn vsprintf(
1446 arg1: *mut ::std::os::raw::c_char,
1447 arg2: *const ::std::os::raw::c_char,
1448 arg3: __builtin_va_list,
1449 ) -> ::std::os::raw::c_int;
1450}
1451extern "C" {
1452 pub fn vsnprintf(
1453 arg1: *mut ::std::os::raw::c_char,
1454 arg2: ::std::os::raw::c_ulong,
1455 arg3: *const ::std::os::raw::c_char,
1456 arg4: __builtin_va_list,
1457 ) -> ::std::os::raw::c_int;
1458}
1459extern "C" {
1460 pub fn scanf(arg1: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
1461}
1462extern "C" {
1463 pub fn fscanf(
1464 arg1: *mut FILE,
1465 arg2: *const ::std::os::raw::c_char,
1466 ...
1467 ) -> ::std::os::raw::c_int;
1468}
1469extern "C" {
1470 pub fn sscanf(
1471 arg1: *const ::std::os::raw::c_char,
1472 arg2: *const ::std::os::raw::c_char,
1473 ...
1474 ) -> ::std::os::raw::c_int;
1475}
1476extern "C" {
1477 pub fn vscanf(
1478 arg1: *const ::std::os::raw::c_char,
1479 arg2: __builtin_va_list,
1480 ) -> ::std::os::raw::c_int;
1481}
1482extern "C" {
1483 pub fn vfscanf(
1484 arg1: *mut FILE,
1485 arg2: *const ::std::os::raw::c_char,
1486 arg3: __builtin_va_list,
1487 ) -> ::std::os::raw::c_int;
1488}
1489extern "C" {
1490 pub fn vsscanf(
1491 arg1: *const ::std::os::raw::c_char,
1492 arg2: *const ::std::os::raw::c_char,
1493 arg3: __builtin_va_list,
1494 ) -> ::std::os::raw::c_int;
1495}
1496extern "C" {
1497 pub fn perror(arg1: *const ::std::os::raw::c_char);
1498}
1499extern "C" {
1500 pub fn setvbuf(
1501 arg1: *mut FILE,
1502 arg2: *mut ::std::os::raw::c_char,
1503 arg3: ::std::os::raw::c_int,
1504 arg4: usize,
1505 ) -> ::std::os::raw::c_int;
1506}
1507extern "C" {
1508 pub fn setbuf(arg1: *mut FILE, arg2: *mut ::std::os::raw::c_char);
1509}
1510extern "C" {
1511 pub fn tmpnam(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1512}
1513extern "C" {
1514 pub fn tmpfile() -> *mut FILE;
1515}
1516extern "C" {
1517 pub fn fmemopen(
1518 arg1: *mut ::std::os::raw::c_void,
1519 arg2: usize,
1520 arg3: *const ::std::os::raw::c_char,
1521 ) -> *mut FILE;
1522}
1523extern "C" {
1524 pub fn open_memstream(arg1: *mut *mut ::std::os::raw::c_char, arg2: *mut usize) -> *mut FILE;
1525}
1526extern "C" {
1527 pub fn fdopen(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char) -> *mut FILE;
1528}
1529extern "C" {
1530 pub fn fileno(arg1: *mut FILE) -> ::std::os::raw::c_int;
1531}
1532extern "C" {
1533 pub fn fseeko(
1534 arg1: *mut FILE,
1535 arg2: off_t,
1536 arg3: ::std::os::raw::c_int,
1537 ) -> ::std::os::raw::c_int;
1538}
1539extern "C" {
1540 pub fn ftello(arg1: *mut FILE) -> off_t;
1541}
1542extern "C" {
1543 pub fn dprintf(
1544 arg1: ::std::os::raw::c_int,
1545 arg2: *const ::std::os::raw::c_char,
1546 ...
1547 ) -> ::std::os::raw::c_int;
1548}
1549extern "C" {
1550 pub fn vdprintf(
1551 arg1: ::std::os::raw::c_int,
1552 arg2: *const ::std::os::raw::c_char,
1553 arg3: __isoc_va_list,
1554 ) -> ::std::os::raw::c_int;
1555}
1556extern "C" {
1557 pub fn getc_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
1558}
1559extern "C" {
1560 pub fn getchar_unlocked() -> ::std::os::raw::c_int;
1561}
1562extern "C" {
1563 pub fn putc_unlocked(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1564}
1565extern "C" {
1566 pub fn putchar_unlocked(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1567}
1568extern "C" {
1569 pub fn getdelim(
1570 arg1: *mut *mut ::std::os::raw::c_char,
1571 arg2: *mut usize,
1572 arg3: ::std::os::raw::c_int,
1573 arg4: *mut FILE,
1574 ) -> isize;
1575}
1576extern "C" {
1577 pub fn getline(
1578 arg1: *mut *mut ::std::os::raw::c_char,
1579 arg2: *mut usize,
1580 arg3: *mut FILE,
1581 ) -> isize;
1582}
1583extern "C" {
1584 pub fn renameat(
1585 arg1: ::std::os::raw::c_int,
1586 arg2: *const ::std::os::raw::c_char,
1587 arg3: ::std::os::raw::c_int,
1588 arg4: *const ::std::os::raw::c_char,
1589 ) -> ::std::os::raw::c_int;
1590}
1591extern "C" {
1592 pub fn ctermid(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1593}
1594extern "C" {
1595 pub fn cuserid(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1596}
1597extern "C" {
1598 pub fn setlinebuf(arg1: *mut FILE);
1599}
1600extern "C" {
1601 pub fn setbuffer(arg1: *mut FILE, arg2: *mut ::std::os::raw::c_char, arg3: usize);
1602}
1603extern "C" {
1604 pub fn fgetc_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
1605}
1606extern "C" {
1607 pub fn fputc_unlocked(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1608}
1609extern "C" {
1610 pub fn fflush_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
1611}
1612extern "C" {
1613 pub fn fread_unlocked(
1614 arg1: *mut ::std::os::raw::c_void,
1615 arg2: usize,
1616 arg3: usize,
1617 arg4: *mut FILE,
1618 ) -> usize;
1619}
1620extern "C" {
1621 pub fn fwrite_unlocked(
1622 arg1: *const ::std::os::raw::c_void,
1623 arg2: usize,
1624 arg3: usize,
1625 arg4: *mut FILE,
1626 ) -> usize;
1627}
1628extern "C" {
1629 pub fn clearerr_unlocked(arg1: *mut FILE);
1630}
1631extern "C" {
1632 pub fn feof_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
1633}
1634extern "C" {
1635 pub fn ferror_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
1636}
1637extern "C" {
1638 pub fn fileno_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
1639}
1640extern "C" {
1641 pub fn getw(arg1: *mut FILE) -> ::std::os::raw::c_int;
1642}
1643extern "C" {
1644 pub fn putw(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1645}
1646extern "C" {
1647 pub fn fgetln(arg1: *mut FILE, arg2: *mut usize) -> *mut ::std::os::raw::c_char;
1648}
1649extern "C" {
1650 pub fn asprintf(
1651 arg1: *mut *mut ::std::os::raw::c_char,
1652 arg2: *const ::std::os::raw::c_char,
1653 ...
1654 ) -> ::std::os::raw::c_int;
1655}
1656extern "C" {
1657 pub fn vasprintf(
1658 arg1: *mut *mut ::std::os::raw::c_char,
1659 arg2: *const ::std::os::raw::c_char,
1660 arg3: __isoc_va_list,
1661 ) -> ::std::os::raw::c_int;
1662}
1663extern "C" {
1664 #[doc = " Return the LIBAVUTIL_VERSION_INT constant."]
1665 pub fn avutil_version() -> ::std::os::raw::c_uint;
1666}
1667extern "C" {
1668 #[doc = " Return an informative version string. This usually is the actual release\n version number or a git commit description. This string has no fixed format\n and can change any time. It should never be parsed by code."]
1669 pub fn av_version_info() -> *const ::std::os::raw::c_char;
1670}
1671extern "C" {
1672 #[doc = " Return the libavutil build-time configuration."]
1673 pub fn avutil_configuration() -> *const ::std::os::raw::c_char;
1674}
1675extern "C" {
1676 #[doc = " Return the libavutil license."]
1677 pub fn avutil_license() -> *const ::std::os::raw::c_char;
1678}
1679#[doc = "< Usually treated as AVMEDIA_TYPE_DATA"]
1680pub const AVMediaType_AVMEDIA_TYPE_UNKNOWN: AVMediaType = -1;
1681pub const AVMediaType_AVMEDIA_TYPE_VIDEO: AVMediaType = 0;
1682pub const AVMediaType_AVMEDIA_TYPE_AUDIO: AVMediaType = 1;
1683#[doc = "< Opaque data information usually continuous"]
1684pub const AVMediaType_AVMEDIA_TYPE_DATA: AVMediaType = 2;
1685pub const AVMediaType_AVMEDIA_TYPE_SUBTITLE: AVMediaType = 3;
1686#[doc = "< Opaque data information usually sparse"]
1687pub const AVMediaType_AVMEDIA_TYPE_ATTACHMENT: AVMediaType = 4;
1688pub const AVMediaType_AVMEDIA_TYPE_NB: AVMediaType = 5;
1689#[doc = " @addtogroup lavu_media Media Type\n @brief Media Type"]
1690pub type AVMediaType = ::std::os::raw::c_int;
1691extern "C" {
1692 #[doc = " Return a string describing the media_type enum, NULL if media_type\n is unknown."]
1693 pub fn av_get_media_type_string(media_type: AVMediaType) -> *const ::std::os::raw::c_char;
1694}
1695#[doc = "< Undefined"]
1696pub const AVPictureType_AV_PICTURE_TYPE_NONE: AVPictureType = 0;
1697#[doc = "< Intra"]
1698pub const AVPictureType_AV_PICTURE_TYPE_I: AVPictureType = 1;
1699#[doc = "< Predicted"]
1700pub const AVPictureType_AV_PICTURE_TYPE_P: AVPictureType = 2;
1701#[doc = "< Bi-dir predicted"]
1702pub const AVPictureType_AV_PICTURE_TYPE_B: AVPictureType = 3;
1703#[doc = "< S(GMC)-VOP MPEG-4"]
1704pub const AVPictureType_AV_PICTURE_TYPE_S: AVPictureType = 4;
1705#[doc = "< Switching Intra"]
1706pub const AVPictureType_AV_PICTURE_TYPE_SI: AVPictureType = 5;
1707#[doc = "< Switching Predicted"]
1708pub const AVPictureType_AV_PICTURE_TYPE_SP: AVPictureType = 6;
1709#[doc = "< BI type"]
1710pub const AVPictureType_AV_PICTURE_TYPE_BI: AVPictureType = 7;
1711#[doc = " @}\n @}\n @defgroup lavu_picture Image related\n\n AVPicture types, pixel formats and basic image planes manipulation.\n\n @{"]
1712pub type AVPictureType = ::std::os::raw::c_uint;
1713extern "C" {
1714 #[doc = " Return a single letter to describe the given picture type\n pict_type.\n\n @param[in] pict_type the picture type @return a single character\n representing the picture type, '?' if pict_type is unknown"]
1715 pub fn av_get_picture_type_char(pict_type: AVPictureType) -> ::std::os::raw::c_char;
1716}
1717extern "C" {
1718 pub static mut errno: ::std::os::raw::c_int;
1719}
1720#[repr(C)]
1721#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1722pub struct imaxdiv_t {
1723 pub quot: intmax_t,
1724 pub rem: intmax_t,
1725}
1726extern "C" {
1727 pub fn imaxabs(arg1: intmax_t) -> intmax_t;
1728}
1729extern "C" {
1730 pub fn imaxdiv(arg1: intmax_t, arg2: intmax_t) -> imaxdiv_t;
1731}
1732extern "C" {
1733 pub fn strtoimax(
1734 arg1: *const ::std::os::raw::c_char,
1735 arg2: *mut *mut ::std::os::raw::c_char,
1736 arg3: ::std::os::raw::c_int,
1737 ) -> intmax_t;
1738}
1739extern "C" {
1740 pub fn strtoumax(
1741 arg1: *const ::std::os::raw::c_char,
1742 arg2: *mut *mut ::std::os::raw::c_char,
1743 arg3: ::std::os::raw::c_int,
1744 ) -> uintmax_t;
1745}
1746extern "C" {
1747 pub fn wcstoimax(
1748 arg1: *const wchar_t,
1749 arg2: *mut *mut wchar_t,
1750 arg3: ::std::os::raw::c_int,
1751 ) -> intmax_t;
1752}
1753extern "C" {
1754 pub fn wcstoumax(
1755 arg1: *const wchar_t,
1756 arg2: *mut *mut wchar_t,
1757 arg3: ::std::os::raw::c_int,
1758 ) -> uintmax_t;
1759}
1760pub type float_t = f32;
1761pub type double_t = f64;
1762extern "C" {
1763 pub fn acos(arg1: f64) -> f64;
1764}
1765extern "C" {
1766 pub fn acosf(arg1: f32) -> f32;
1767}
1768extern "C" {
1769 pub fn acosl(arg1: u128) -> u128;
1770}
1771extern "C" {
1772 pub fn acosh(arg1: f64) -> f64;
1773}
1774extern "C" {
1775 pub fn acoshf(arg1: f32) -> f32;
1776}
1777extern "C" {
1778 pub fn acoshl(arg1: u128) -> u128;
1779}
1780extern "C" {
1781 pub fn asin(arg1: f64) -> f64;
1782}
1783extern "C" {
1784 pub fn asinf(arg1: f32) -> f32;
1785}
1786extern "C" {
1787 pub fn asinl(arg1: u128) -> u128;
1788}
1789extern "C" {
1790 pub fn asinh(arg1: f64) -> f64;
1791}
1792extern "C" {
1793 pub fn asinhf(arg1: f32) -> f32;
1794}
1795extern "C" {
1796 pub fn asinhl(arg1: u128) -> u128;
1797}
1798extern "C" {
1799 pub fn atan(arg1: f64) -> f64;
1800}
1801extern "C" {
1802 pub fn atanf(arg1: f32) -> f32;
1803}
1804extern "C" {
1805 pub fn atanl(arg1: u128) -> u128;
1806}
1807extern "C" {
1808 pub fn atan2(arg1: f64, arg2: f64) -> f64;
1809}
1810extern "C" {
1811 pub fn atan2f(arg1: f32, arg2: f32) -> f32;
1812}
1813extern "C" {
1814 pub fn atan2l(arg1: u128, arg2: u128) -> u128;
1815}
1816extern "C" {
1817 pub fn atanh(arg1: f64) -> f64;
1818}
1819extern "C" {
1820 pub fn atanhf(arg1: f32) -> f32;
1821}
1822extern "C" {
1823 pub fn atanhl(arg1: u128) -> u128;
1824}
1825extern "C" {
1826 pub fn cbrt(arg1: f64) -> f64;
1827}
1828extern "C" {
1829 pub fn cbrtf(arg1: f32) -> f32;
1830}
1831extern "C" {
1832 pub fn cbrtl(arg1: u128) -> u128;
1833}
1834extern "C" {
1835 pub fn ceil(arg1: f64) -> f64;
1836}
1837extern "C" {
1838 pub fn ceilf(arg1: f32) -> f32;
1839}
1840extern "C" {
1841 pub fn ceill(arg1: u128) -> u128;
1842}
1843extern "C" {
1844 pub fn copysign(arg1: f64, arg2: f64) -> f64;
1845}
1846extern "C" {
1847 pub fn copysignf(arg1: f32, arg2: f32) -> f32;
1848}
1849extern "C" {
1850 pub fn copysignl(arg1: u128, arg2: u128) -> u128;
1851}
1852extern "C" {
1853 pub fn cos(arg1: f64) -> f64;
1854}
1855extern "C" {
1856 pub fn cosf(arg1: f32) -> f32;
1857}
1858extern "C" {
1859 pub fn cosl(arg1: u128) -> u128;
1860}
1861extern "C" {
1862 pub fn cosh(arg1: f64) -> f64;
1863}
1864extern "C" {
1865 pub fn coshf(arg1: f32) -> f32;
1866}
1867extern "C" {
1868 pub fn coshl(arg1: u128) -> u128;
1869}
1870extern "C" {
1871 pub fn erf(arg1: f64) -> f64;
1872}
1873extern "C" {
1874 pub fn erff(arg1: f32) -> f32;
1875}
1876extern "C" {
1877 pub fn erfl(arg1: u128) -> u128;
1878}
1879extern "C" {
1880 pub fn erfc(arg1: f64) -> f64;
1881}
1882extern "C" {
1883 pub fn erfcf(arg1: f32) -> f32;
1884}
1885extern "C" {
1886 pub fn erfcl(arg1: u128) -> u128;
1887}
1888extern "C" {
1889 pub fn exp(arg1: f64) -> f64;
1890}
1891extern "C" {
1892 pub fn expf(arg1: f32) -> f32;
1893}
1894extern "C" {
1895 pub fn expl(arg1: u128) -> u128;
1896}
1897extern "C" {
1898 pub fn exp2(arg1: f64) -> f64;
1899}
1900extern "C" {
1901 pub fn exp2f(arg1: f32) -> f32;
1902}
1903extern "C" {
1904 pub fn exp2l(arg1: u128) -> u128;
1905}
1906extern "C" {
1907 pub fn expm1(arg1: f64) -> f64;
1908}
1909extern "C" {
1910 pub fn expm1f(arg1: f32) -> f32;
1911}
1912extern "C" {
1913 pub fn expm1l(arg1: u128) -> u128;
1914}
1915extern "C" {
1916 pub fn fabs(arg1: f64) -> f64;
1917}
1918extern "C" {
1919 pub fn fabsf(arg1: f32) -> f32;
1920}
1921extern "C" {
1922 pub fn fabsl(arg1: u128) -> u128;
1923}
1924extern "C" {
1925 pub fn fdim(arg1: f64, arg2: f64) -> f64;
1926}
1927extern "C" {
1928 pub fn fdimf(arg1: f32, arg2: f32) -> f32;
1929}
1930extern "C" {
1931 pub fn fdiml(arg1: u128, arg2: u128) -> u128;
1932}
1933extern "C" {
1934 pub fn floor(arg1: f64) -> f64;
1935}
1936extern "C" {
1937 pub fn floorf(arg1: f32) -> f32;
1938}
1939extern "C" {
1940 pub fn floorl(arg1: u128) -> u128;
1941}
1942extern "C" {
1943 pub fn fma(arg1: f64, arg2: f64, arg3: f64) -> f64;
1944}
1945extern "C" {
1946 pub fn fmaf(arg1: f32, arg2: f32, arg3: f32) -> f32;
1947}
1948extern "C" {
1949 pub fn fmal(arg1: u128, arg2: u128, arg3: u128) -> u128;
1950}
1951extern "C" {
1952 pub fn fmax(arg1: f64, arg2: f64) -> f64;
1953}
1954extern "C" {
1955 pub fn fmaxf(arg1: f32, arg2: f32) -> f32;
1956}
1957extern "C" {
1958 pub fn fmaxl(arg1: u128, arg2: u128) -> u128;
1959}
1960extern "C" {
1961 pub fn fmin(arg1: f64, arg2: f64) -> f64;
1962}
1963extern "C" {
1964 pub fn fminf(arg1: f32, arg2: f32) -> f32;
1965}
1966extern "C" {
1967 pub fn fminl(arg1: u128, arg2: u128) -> u128;
1968}
1969extern "C" {
1970 pub fn fmod(arg1: f64, arg2: f64) -> f64;
1971}
1972extern "C" {
1973 pub fn fmodf(arg1: f32, arg2: f32) -> f32;
1974}
1975extern "C" {
1976 pub fn fmodl(arg1: u128, arg2: u128) -> u128;
1977}
1978extern "C" {
1979 pub fn frexp(arg1: f64, arg2: *mut ::std::os::raw::c_int) -> f64;
1980}
1981extern "C" {
1982 pub fn frexpf(arg1: f32, arg2: *mut ::std::os::raw::c_int) -> f32;
1983}
1984extern "C" {
1985 pub fn frexpl(arg1: u128, arg2: *mut ::std::os::raw::c_int) -> u128;
1986}
1987extern "C" {
1988 pub fn hypot(arg1: f64, arg2: f64) -> f64;
1989}
1990extern "C" {
1991 pub fn hypotf(arg1: f32, arg2: f32) -> f32;
1992}
1993extern "C" {
1994 pub fn hypotl(arg1: u128, arg2: u128) -> u128;
1995}
1996extern "C" {
1997 pub fn ilogb(arg1: f64) -> ::std::os::raw::c_int;
1998}
1999extern "C" {
2000 pub fn ilogbf(arg1: f32) -> ::std::os::raw::c_int;
2001}
2002extern "C" {
2003 pub fn ilogbl(arg1: u128) -> ::std::os::raw::c_int;
2004}
2005extern "C" {
2006 pub fn ldexp(arg1: f64, arg2: ::std::os::raw::c_int) -> f64;
2007}
2008extern "C" {
2009 pub fn ldexpf(arg1: f32, arg2: ::std::os::raw::c_int) -> f32;
2010}
2011extern "C" {
2012 pub fn ldexpl(arg1: u128, arg2: ::std::os::raw::c_int) -> u128;
2013}
2014extern "C" {
2015 pub fn lgamma(arg1: f64) -> f64;
2016}
2017extern "C" {
2018 pub fn lgammaf(arg1: f32) -> f32;
2019}
2020extern "C" {
2021 pub fn lgammal(arg1: u128) -> u128;
2022}
2023extern "C" {
2024 pub fn llrint(arg1: f64) -> ::std::os::raw::c_longlong;
2025}
2026extern "C" {
2027 pub fn llrintf(arg1: f32) -> ::std::os::raw::c_longlong;
2028}
2029extern "C" {
2030 pub fn llrintl(arg1: u128) -> ::std::os::raw::c_longlong;
2031}
2032extern "C" {
2033 pub fn llround(arg1: f64) -> ::std::os::raw::c_longlong;
2034}
2035extern "C" {
2036 pub fn llroundf(arg1: f32) -> ::std::os::raw::c_longlong;
2037}
2038extern "C" {
2039 pub fn llroundl(arg1: u128) -> ::std::os::raw::c_longlong;
2040}
2041extern "C" {
2042 pub fn log(arg1: f64) -> f64;
2043}
2044extern "C" {
2045 pub fn logf(arg1: f32) -> f32;
2046}
2047extern "C" {
2048 pub fn logl(arg1: u128) -> u128;
2049}
2050extern "C" {
2051 pub fn log10(arg1: f64) -> f64;
2052}
2053extern "C" {
2054 pub fn log10f(arg1: f32) -> f32;
2055}
2056extern "C" {
2057 pub fn log10l(arg1: u128) -> u128;
2058}
2059extern "C" {
2060 pub fn log1p(arg1: f64) -> f64;
2061}
2062extern "C" {
2063 pub fn log1pf(arg1: f32) -> f32;
2064}
2065extern "C" {
2066 pub fn log1pl(arg1: u128) -> u128;
2067}
2068extern "C" {
2069 pub fn log2(arg1: f64) -> f64;
2070}
2071extern "C" {
2072 pub fn log2f(arg1: f32) -> f32;
2073}
2074extern "C" {
2075 pub fn log2l(arg1: u128) -> u128;
2076}
2077extern "C" {
2078 pub fn logb(arg1: f64) -> f64;
2079}
2080extern "C" {
2081 pub fn logbf(arg1: f32) -> f32;
2082}
2083extern "C" {
2084 pub fn logbl(arg1: u128) -> u128;
2085}
2086extern "C" {
2087 pub fn lrint(arg1: f64) -> ::std::os::raw::c_long;
2088}
2089extern "C" {
2090 pub fn lrintf(arg1: f32) -> ::std::os::raw::c_long;
2091}
2092extern "C" {
2093 pub fn lrintl(arg1: u128) -> ::std::os::raw::c_long;
2094}
2095extern "C" {
2096 pub fn lround(arg1: f64) -> ::std::os::raw::c_long;
2097}
2098extern "C" {
2099 pub fn lroundf(arg1: f32) -> ::std::os::raw::c_long;
2100}
2101extern "C" {
2102 pub fn lroundl(arg1: u128) -> ::std::os::raw::c_long;
2103}
2104extern "C" {
2105 pub fn modf(arg1: f64, arg2: *mut f64) -> f64;
2106}
2107extern "C" {
2108 pub fn modff(arg1: f32, arg2: *mut f32) -> f32;
2109}
2110extern "C" {
2111 pub fn modfl(arg1: u128, arg2: *mut u128) -> u128;
2112}
2113extern "C" {
2114 pub fn nan(arg1: *const ::std::os::raw::c_char) -> f64;
2115}
2116extern "C" {
2117 pub fn nanf(arg1: *const ::std::os::raw::c_char) -> f32;
2118}
2119extern "C" {
2120 pub fn nanl(arg1: *const ::std::os::raw::c_char) -> u128;
2121}
2122extern "C" {
2123 pub fn nearbyint(arg1: f64) -> f64;
2124}
2125extern "C" {
2126 pub fn nearbyintf(arg1: f32) -> f32;
2127}
2128extern "C" {
2129 pub fn nearbyintl(arg1: u128) -> u128;
2130}
2131extern "C" {
2132 pub fn nextafter(arg1: f64, arg2: f64) -> f64;
2133}
2134extern "C" {
2135 pub fn nextafterf(arg1: f32, arg2: f32) -> f32;
2136}
2137extern "C" {
2138 pub fn nextafterl(arg1: u128, arg2: u128) -> u128;
2139}
2140extern "C" {
2141 pub fn nexttoward(arg1: f64, arg2: u128) -> f64;
2142}
2143extern "C" {
2144 pub fn nexttowardf(arg1: f32, arg2: u128) -> f32;
2145}
2146extern "C" {
2147 pub fn nexttowardl(arg1: u128, arg2: u128) -> u128;
2148}
2149extern "C" {
2150 pub fn pow(arg1: f64, arg2: f64) -> f64;
2151}
2152extern "C" {
2153 pub fn powf(arg1: f32, arg2: f32) -> f32;
2154}
2155extern "C" {
2156 pub fn powl(arg1: u128, arg2: u128) -> u128;
2157}
2158extern "C" {
2159 pub fn remainder(arg1: f64, arg2: f64) -> f64;
2160}
2161extern "C" {
2162 pub fn remainderf(arg1: f32, arg2: f32) -> f32;
2163}
2164extern "C" {
2165 pub fn remainderl(arg1: u128, arg2: u128) -> u128;
2166}
2167extern "C" {
2168 pub fn remquo(arg1: f64, arg2: f64, arg3: *mut ::std::os::raw::c_int) -> f64;
2169}
2170extern "C" {
2171 pub fn remquof(arg1: f32, arg2: f32, arg3: *mut ::std::os::raw::c_int) -> f32;
2172}
2173extern "C" {
2174 pub fn remquol(arg1: u128, arg2: u128, arg3: *mut ::std::os::raw::c_int) -> u128;
2175}
2176extern "C" {
2177 pub fn rint(arg1: f64) -> f64;
2178}
2179extern "C" {
2180 pub fn rintf(arg1: f32) -> f32;
2181}
2182extern "C" {
2183 pub fn rintl(arg1: u128) -> u128;
2184}
2185extern "C" {
2186 pub fn round(arg1: f64) -> f64;
2187}
2188extern "C" {
2189 pub fn roundf(arg1: f32) -> f32;
2190}
2191extern "C" {
2192 pub fn roundl(arg1: u128) -> u128;
2193}
2194extern "C" {
2195 pub fn scalbln(arg1: f64, arg2: ::std::os::raw::c_long) -> f64;
2196}
2197extern "C" {
2198 pub fn scalblnf(arg1: f32, arg2: ::std::os::raw::c_long) -> f32;
2199}
2200extern "C" {
2201 pub fn scalblnl(arg1: u128, arg2: ::std::os::raw::c_long) -> u128;
2202}
2203extern "C" {
2204 pub fn scalbn(arg1: f64, arg2: ::std::os::raw::c_int) -> f64;
2205}
2206extern "C" {
2207 pub fn scalbnf(arg1: f32, arg2: ::std::os::raw::c_int) -> f32;
2208}
2209extern "C" {
2210 pub fn scalbnl(arg1: u128, arg2: ::std::os::raw::c_int) -> u128;
2211}
2212extern "C" {
2213 pub fn sin(arg1: f64) -> f64;
2214}
2215extern "C" {
2216 pub fn sinf(arg1: f32) -> f32;
2217}
2218extern "C" {
2219 pub fn sinl(arg1: u128) -> u128;
2220}
2221extern "C" {
2222 pub fn sinh(arg1: f64) -> f64;
2223}
2224extern "C" {
2225 pub fn sinhf(arg1: f32) -> f32;
2226}
2227extern "C" {
2228 pub fn sinhl(arg1: u128) -> u128;
2229}
2230extern "C" {
2231 pub fn sqrt(arg1: f64) -> f64;
2232}
2233extern "C" {
2234 pub fn sqrtf(arg1: f32) -> f32;
2235}
2236extern "C" {
2237 pub fn sqrtl(arg1: u128) -> u128;
2238}
2239extern "C" {
2240 pub fn tan(arg1: f64) -> f64;
2241}
2242extern "C" {
2243 pub fn tanf(arg1: f32) -> f32;
2244}
2245extern "C" {
2246 pub fn tanl(arg1: u128) -> u128;
2247}
2248extern "C" {
2249 pub fn tanh(arg1: f64) -> f64;
2250}
2251extern "C" {
2252 pub fn tanhf(arg1: f32) -> f32;
2253}
2254extern "C" {
2255 pub fn tanhl(arg1: u128) -> u128;
2256}
2257extern "C" {
2258 pub fn tgamma(arg1: f64) -> f64;
2259}
2260extern "C" {
2261 pub fn tgammaf(arg1: f32) -> f32;
2262}
2263extern "C" {
2264 pub fn tgammal(arg1: u128) -> u128;
2265}
2266extern "C" {
2267 pub fn trunc(arg1: f64) -> f64;
2268}
2269extern "C" {
2270 pub fn truncf(arg1: f32) -> f32;
2271}
2272extern "C" {
2273 pub fn truncl(arg1: u128) -> u128;
2274}
2275extern "C" {
2276 pub static mut signgam: ::std::os::raw::c_int;
2277}
2278extern "C" {
2279 pub fn j0(arg1: f64) -> f64;
2280}
2281extern "C" {
2282 pub fn j1(arg1: f64) -> f64;
2283}
2284extern "C" {
2285 pub fn jn(arg1: ::std::os::raw::c_int, arg2: f64) -> f64;
2286}
2287extern "C" {
2288 pub fn y0(arg1: f64) -> f64;
2289}
2290extern "C" {
2291 pub fn y1(arg1: f64) -> f64;
2292}
2293extern "C" {
2294 pub fn yn(arg1: ::std::os::raw::c_int, arg2: f64) -> f64;
2295}
2296extern "C" {
2297 pub fn drem(arg1: f64, arg2: f64) -> f64;
2298}
2299extern "C" {
2300 pub fn dremf(arg1: f32, arg2: f32) -> f32;
2301}
2302extern "C" {
2303 pub fn finite(arg1: f64) -> ::std::os::raw::c_int;
2304}
2305extern "C" {
2306 pub fn finitef(arg1: f32) -> ::std::os::raw::c_int;
2307}
2308extern "C" {
2309 pub fn scalb(arg1: f64, arg2: f64) -> f64;
2310}
2311extern "C" {
2312 pub fn scalbf(arg1: f32, arg2: f32) -> f32;
2313}
2314extern "C" {
2315 pub fn significand(arg1: f64) -> f64;
2316}
2317extern "C" {
2318 pub fn significandf(arg1: f32) -> f32;
2319}
2320extern "C" {
2321 pub fn lgamma_r(arg1: f64, arg2: *mut ::std::os::raw::c_int) -> f64;
2322}
2323extern "C" {
2324 pub fn lgammaf_r(arg1: f32, arg2: *mut ::std::os::raw::c_int) -> f32;
2325}
2326extern "C" {
2327 pub fn j0f(arg1: f32) -> f32;
2328}
2329extern "C" {
2330 pub fn j1f(arg1: f32) -> f32;
2331}
2332extern "C" {
2333 pub fn jnf(arg1: ::std::os::raw::c_int, arg2: f32) -> f32;
2334}
2335extern "C" {
2336 pub fn y0f(arg1: f32) -> f32;
2337}
2338extern "C" {
2339 pub fn y1f(arg1: f32) -> f32;
2340}
2341extern "C" {
2342 pub fn ynf(arg1: ::std::os::raw::c_int, arg2: f32) -> f32;
2343}
2344extern "C" {
2345 #[must_use]
2346 pub fn malloc(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
2347}
2348extern "C" {
2349 pub fn free(__ptr: *mut ::std::os::raw::c_void);
2350}
2351extern "C" {
2352 #[must_use]
2353 pub fn calloc(
2354 __nmemb: ::std::os::raw::c_ulong,
2355 __size: ::std::os::raw::c_ulong,
2356 ) -> *mut ::std::os::raw::c_void;
2357}
2358extern "C" {
2359 #[must_use]
2360 pub fn realloc(
2361 __ptr: *mut ::std::os::raw::c_void,
2362 __size: ::std::os::raw::c_ulong,
2363 ) -> *mut ::std::os::raw::c_void;
2364}
2365extern "C" {
2366 #[must_use]
2367 pub fn reallocarray(
2368 __ptr: *mut ::std::os::raw::c_void,
2369 __nmemb: usize,
2370 __size: usize,
2371 ) -> *mut ::std::os::raw::c_void;
2372}
2373extern "C" {
2374 pub fn abort() -> !;
2375}
2376extern "C" {
2377 pub fn qsort(
2378 arg1: *mut ::std::os::raw::c_void,
2379 arg2: usize,
2380 arg3: usize,
2381 arg4: ::std::option::Option<
2382 unsafe extern "C" fn(
2383 arg1: *const ::std::os::raw::c_void,
2384 arg2: *const ::std::os::raw::c_void,
2385 ) -> ::std::os::raw::c_int,
2386 >,
2387 );
2388}
2389extern "C" {
2390 pub fn _Exit(arg1: ::std::os::raw::c_int) -> !;
2391}
2392extern "C" {
2393 pub fn atoi(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2394}
2395extern "C" {
2396 pub fn atol(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
2397}
2398extern "C" {
2399 pub fn atoll(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong;
2400}
2401extern "C" {
2402 pub fn atof(arg1: *const ::std::os::raw::c_char) -> f64;
2403}
2404extern "C" {
2405 pub fn strtof(
2406 arg1: *const ::std::os::raw::c_char,
2407 arg2: *mut *mut ::std::os::raw::c_char,
2408 ) -> f32;
2409}
2410extern "C" {
2411 pub fn strtod(
2412 arg1: *const ::std::os::raw::c_char,
2413 arg2: *mut *mut ::std::os::raw::c_char,
2414 ) -> f64;
2415}
2416extern "C" {
2417 pub fn strtold(
2418 arg1: *const ::std::os::raw::c_char,
2419 arg2: *mut *mut ::std::os::raw::c_char,
2420 ) -> u128;
2421}
2422extern "C" {
2423 pub fn strtol(
2424 arg1: *const ::std::os::raw::c_char,
2425 arg2: *mut *mut ::std::os::raw::c_char,
2426 arg3: ::std::os::raw::c_int,
2427 ) -> ::std::os::raw::c_long;
2428}
2429extern "C" {
2430 pub fn strtoul(
2431 arg1: *const ::std::os::raw::c_char,
2432 arg2: *mut *mut ::std::os::raw::c_char,
2433 arg3: ::std::os::raw::c_int,
2434 ) -> ::std::os::raw::c_ulong;
2435}
2436extern "C" {
2437 pub fn strtoll(
2438 arg1: *const ::std::os::raw::c_char,
2439 arg2: *mut *mut ::std::os::raw::c_char,
2440 arg3: ::std::os::raw::c_int,
2441 ) -> ::std::os::raw::c_longlong;
2442}
2443extern "C" {
2444 pub fn strtoull(
2445 arg1: *const ::std::os::raw::c_char,
2446 arg2: *mut *mut ::std::os::raw::c_char,
2447 arg3: ::std::os::raw::c_int,
2448 ) -> ::std::os::raw::c_ulonglong;
2449}
2450extern "C" {
2451 pub fn rand() -> ::std::os::raw::c_int;
2452}
2453extern "C" {
2454 pub fn srand(arg1: ::std::os::raw::c_uint);
2455}
2456extern "C" {
2457 pub fn aligned_alloc(
2458 arg1: ::std::os::raw::c_ulong,
2459 arg2: ::std::os::raw::c_ulong,
2460 ) -> *mut ::std::os::raw::c_void;
2461}
2462extern "C" {
2463 pub fn atexit(arg1: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
2464}
2465extern "C" {
2466 pub fn exit(arg1: ::std::os::raw::c_int) -> !;
2467}
2468extern "C" {
2469 pub fn at_quick_exit(
2470 arg1: ::std::option::Option<unsafe extern "C" fn()>,
2471 ) -> ::std::os::raw::c_int;
2472}
2473extern "C" {
2474 pub fn quick_exit(arg1: ::std::os::raw::c_int) -> !;
2475}
2476extern "C" {
2477 pub fn getenv(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2478}
2479extern "C" {
2480 pub fn system(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2481}
2482extern "C" {
2483 pub fn bsearch(
2484 arg1: *const ::std::os::raw::c_void,
2485 arg2: *const ::std::os::raw::c_void,
2486 arg3: usize,
2487 arg4: usize,
2488 arg5: ::std::option::Option<
2489 unsafe extern "C" fn(
2490 arg1: *const ::std::os::raw::c_void,
2491 arg2: *const ::std::os::raw::c_void,
2492 ) -> ::std::os::raw::c_int,
2493 >,
2494 ) -> *mut ::std::os::raw::c_void;
2495}
2496extern "C" {
2497 pub fn abs(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
2498}
2499extern "C" {
2500 pub fn labs(arg1: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
2501}
2502extern "C" {
2503 pub fn llabs(arg1: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong;
2504}
2505#[repr(C)]
2506#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2507pub struct div_t {
2508 pub quot: ::std::os::raw::c_int,
2509 pub rem: ::std::os::raw::c_int,
2510}
2511#[repr(C)]
2512#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2513pub struct ldiv_t {
2514 pub quot: ::std::os::raw::c_long,
2515 pub rem: ::std::os::raw::c_long,
2516}
2517#[repr(C)]
2518#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2519pub struct lldiv_t {
2520 pub quot: ::std::os::raw::c_longlong,
2521 pub rem: ::std::os::raw::c_longlong,
2522}
2523extern "C" {
2524 pub fn div(arg1: ::std::os::raw::c_int, arg2: ::std::os::raw::c_int) -> div_t;
2525}
2526extern "C" {
2527 pub fn ldiv(arg1: ::std::os::raw::c_long, arg2: ::std::os::raw::c_long) -> ldiv_t;
2528}
2529extern "C" {
2530 pub fn lldiv(arg1: ::std::os::raw::c_longlong, arg2: ::std::os::raw::c_longlong) -> lldiv_t;
2531}
2532extern "C" {
2533 pub fn mblen(arg1: *const ::std::os::raw::c_char, arg2: usize) -> ::std::os::raw::c_int;
2534}
2535extern "C" {
2536 pub fn mbtowc(
2537 arg1: *mut wchar_t,
2538 arg2: *const ::std::os::raw::c_char,
2539 arg3: usize,
2540 ) -> ::std::os::raw::c_int;
2541}
2542extern "C" {
2543 pub fn wctomb(arg1: *mut ::std::os::raw::c_char, arg2: wchar_t) -> ::std::os::raw::c_int;
2544}
2545extern "C" {
2546 pub fn mbstowcs(arg1: *mut wchar_t, arg2: *const ::std::os::raw::c_char, arg3: usize) -> usize;
2547}
2548extern "C" {
2549 pub fn wcstombs(arg1: *mut ::std::os::raw::c_char, arg2: *const wchar_t, arg3: usize) -> usize;
2550}
2551extern "C" {
2552 pub fn __ctype_get_mb_cur_max() -> usize;
2553}
2554extern "C" {
2555 pub fn posix_memalign(
2556 arg1: *mut *mut ::std::os::raw::c_void,
2557 arg2: usize,
2558 arg3: usize,
2559 ) -> ::std::os::raw::c_int;
2560}
2561extern "C" {
2562 pub fn setenv(
2563 arg1: *const ::std::os::raw::c_char,
2564 arg2: *const ::std::os::raw::c_char,
2565 arg3: ::std::os::raw::c_int,
2566 ) -> ::std::os::raw::c_int;
2567}
2568extern "C" {
2569 pub fn unsetenv(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2570}
2571extern "C" {
2572 pub fn getsubopt(
2573 arg1: *mut *mut ::std::os::raw::c_char,
2574 arg2: *const *mut ::std::os::raw::c_char,
2575 arg3: *mut *mut ::std::os::raw::c_char,
2576 ) -> ::std::os::raw::c_int;
2577}
2578extern "C" {
2579 pub fn rand_r(arg1: *mut ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
2580}
2581extern "C" {
2582 pub fn random() -> ::std::os::raw::c_long;
2583}
2584extern "C" {
2585 pub fn srandom(arg1: ::std::os::raw::c_uint);
2586}
2587extern "C" {
2588 pub fn initstate(
2589 arg1: ::std::os::raw::c_uint,
2590 arg2: *mut ::std::os::raw::c_char,
2591 arg3: usize,
2592 ) -> *mut ::std::os::raw::c_char;
2593}
2594extern "C" {
2595 pub fn setstate(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2596}
2597extern "C" {
2598 pub fn putenv(arg1: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2599}
2600extern "C" {
2601 pub fn l64a(arg1: ::std::os::raw::c_long) -> *mut ::std::os::raw::c_char;
2602}
2603extern "C" {
2604 pub fn a64l(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
2605}
2606extern "C" {
2607 pub fn setkey(arg1: *const ::std::os::raw::c_char);
2608}
2609extern "C" {
2610 pub fn drand48() -> f64;
2611}
2612extern "C" {
2613 pub fn erand48(arg1: *mut ::std::os::raw::c_ushort) -> f64;
2614}
2615extern "C" {
2616 pub fn lrand48() -> ::std::os::raw::c_long;
2617}
2618extern "C" {
2619 pub fn nrand48(arg1: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
2620}
2621extern "C" {
2622 pub fn mrand48() -> ::std::os::raw::c_long;
2623}
2624extern "C" {
2625 pub fn jrand48(arg1: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
2626}
2627extern "C" {
2628 pub fn srand48(arg1: ::std::os::raw::c_long);
2629}
2630extern "C" {
2631 pub fn seed48(arg1: *mut ::std::os::raw::c_ushort) -> *mut ::std::os::raw::c_ushort;
2632}
2633extern "C" {
2634 pub fn lcong48(arg1: *mut ::std::os::raw::c_ushort);
2635}
2636extern "C" {
2637 pub fn alloca(arg1: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
2638}
2639extern "C" {
2640 pub fn clearenv() -> ::std::os::raw::c_int;
2641}
2642extern "C" {
2643 pub fn arc4random() -> u32;
2644}
2645extern "C" {
2646 pub fn arc4random_buf(arg1: *mut ::std::os::raw::c_void, arg2: usize);
2647}
2648extern "C" {
2649 pub fn arc4random_uniform(arg1: u32) -> u32;
2650}
2651extern "C" {
2652 pub fn memcpy(
2653 __dst: *mut ::std::os::raw::c_void,
2654 __src: *const ::std::os::raw::c_void,
2655 __n: ::std::os::raw::c_ulong,
2656 ) -> *mut ::std::os::raw::c_void;
2657}
2658extern "C" {
2659 pub fn memmove(
2660 __dst: *mut ::std::os::raw::c_void,
2661 __src: *const ::std::os::raw::c_void,
2662 __n: ::std::os::raw::c_ulong,
2663 ) -> *mut ::std::os::raw::c_void;
2664}
2665extern "C" {
2666 pub fn memset(
2667 __dst: *mut ::std::os::raw::c_void,
2668 __c: ::std::os::raw::c_int,
2669 __n: ::std::os::raw::c_ulong,
2670 ) -> *mut ::std::os::raw::c_void;
2671}
2672extern "C" {
2673 pub fn strlen(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulong;
2674}
2675extern "C" {
2676 pub fn strdup(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2677}
2678extern "C" {
2679 pub fn strcmp(
2680 arg1: *const ::std::os::raw::c_char,
2681 arg2: *const ::std::os::raw::c_char,
2682 ) -> ::std::os::raw::c_int;
2683}
2684extern "C" {
2685 pub fn memchr(
2686 arg1: *const ::std::os::raw::c_void,
2687 arg2: ::std::os::raw::c_int,
2688 arg3: ::std::os::raw::c_ulong,
2689 ) -> *mut ::std::os::raw::c_void;
2690}
2691#[repr(C)]
2692#[derive(Debug, Copy, Clone)]
2693pub struct __locale_struct {
2694 _unused: [u8; 0],
2695}
2696pub type locale_t = *mut __locale_struct;
2697extern "C" {
2698 pub fn memcmp(
2699 arg1: *const ::std::os::raw::c_void,
2700 arg2: *const ::std::os::raw::c_void,
2701 arg3: ::std::os::raw::c_ulong,
2702 ) -> ::std::os::raw::c_int;
2703}
2704extern "C" {
2705 pub fn strcpy(
2706 arg1: *mut ::std::os::raw::c_char,
2707 arg2: *const ::std::os::raw::c_char,
2708 ) -> *mut ::std::os::raw::c_char;
2709}
2710extern "C" {
2711 pub fn strncpy(
2712 arg1: *mut ::std::os::raw::c_char,
2713 arg2: *const ::std::os::raw::c_char,
2714 arg3: ::std::os::raw::c_ulong,
2715 ) -> *mut ::std::os::raw::c_char;
2716}
2717extern "C" {
2718 pub fn strcat(
2719 arg1: *mut ::std::os::raw::c_char,
2720 arg2: *const ::std::os::raw::c_char,
2721 ) -> *mut ::std::os::raw::c_char;
2722}
2723extern "C" {
2724 pub fn strncat(
2725 arg1: *mut ::std::os::raw::c_char,
2726 arg2: *const ::std::os::raw::c_char,
2727 arg3: ::std::os::raw::c_ulong,
2728 ) -> *mut ::std::os::raw::c_char;
2729}
2730extern "C" {
2731 pub fn strncmp(
2732 arg1: *const ::std::os::raw::c_char,
2733 arg2: *const ::std::os::raw::c_char,
2734 arg3: ::std::os::raw::c_ulong,
2735 ) -> ::std::os::raw::c_int;
2736}
2737extern "C" {
2738 pub fn strcoll(
2739 arg1: *const ::std::os::raw::c_char,
2740 arg2: *const ::std::os::raw::c_char,
2741 ) -> ::std::os::raw::c_int;
2742}
2743extern "C" {
2744 pub fn strxfrm(
2745 arg1: *mut ::std::os::raw::c_char,
2746 arg2: *const ::std::os::raw::c_char,
2747 arg3: ::std::os::raw::c_ulong,
2748 ) -> ::std::os::raw::c_ulong;
2749}
2750extern "C" {
2751 pub fn strchr(
2752 arg1: *const ::std::os::raw::c_char,
2753 arg2: ::std::os::raw::c_int,
2754 ) -> *mut ::std::os::raw::c_char;
2755}
2756extern "C" {
2757 pub fn strrchr(
2758 arg1: *const ::std::os::raw::c_char,
2759 arg2: ::std::os::raw::c_int,
2760 ) -> *mut ::std::os::raw::c_char;
2761}
2762extern "C" {
2763 pub fn strcspn(
2764 arg1: *const ::std::os::raw::c_char,
2765 arg2: *const ::std::os::raw::c_char,
2766 ) -> ::std::os::raw::c_ulong;
2767}
2768extern "C" {
2769 pub fn strspn(
2770 arg1: *const ::std::os::raw::c_char,
2771 arg2: *const ::std::os::raw::c_char,
2772 ) -> ::std::os::raw::c_ulong;
2773}
2774extern "C" {
2775 pub fn strpbrk(
2776 arg1: *const ::std::os::raw::c_char,
2777 arg2: *const ::std::os::raw::c_char,
2778 ) -> *mut ::std::os::raw::c_char;
2779}
2780extern "C" {
2781 pub fn strstr(
2782 arg1: *const ::std::os::raw::c_char,
2783 arg2: *const ::std::os::raw::c_char,
2784 ) -> *mut ::std::os::raw::c_char;
2785}
2786extern "C" {
2787 pub fn strtok(
2788 arg1: *mut ::std::os::raw::c_char,
2789 arg2: *const ::std::os::raw::c_char,
2790 ) -> *mut ::std::os::raw::c_char;
2791}
2792extern "C" {
2793 pub fn strerror(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
2794}
2795extern "C" {
2796 pub fn bcmp(
2797 arg1: *const ::std::os::raw::c_void,
2798 arg2: *const ::std::os::raw::c_void,
2799 arg3: ::std::os::raw::c_ulong,
2800 ) -> ::std::os::raw::c_int;
2801}
2802extern "C" {
2803 pub fn bcopy(
2804 arg1: *const ::std::os::raw::c_void,
2805 arg2: *mut ::std::os::raw::c_void,
2806 arg3: usize,
2807 );
2808}
2809extern "C" {
2810 pub fn bzero(arg1: *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_ulong);
2811}
2812extern "C" {
2813 pub fn index(
2814 arg1: *const ::std::os::raw::c_char,
2815 arg2: ::std::os::raw::c_int,
2816 ) -> *mut ::std::os::raw::c_char;
2817}
2818extern "C" {
2819 pub fn rindex(
2820 arg1: *const ::std::os::raw::c_char,
2821 arg2: ::std::os::raw::c_int,
2822 ) -> *mut ::std::os::raw::c_char;
2823}
2824extern "C" {
2825 pub fn ffs(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
2826}
2827extern "C" {
2828 pub fn ffsl(arg1: ::std::os::raw::c_long) -> ::std::os::raw::c_int;
2829}
2830extern "C" {
2831 pub fn ffsll(arg1: ::std::os::raw::c_longlong) -> ::std::os::raw::c_int;
2832}
2833extern "C" {
2834 pub fn strcasecmp(
2835 arg1: *const ::std::os::raw::c_char,
2836 arg2: *const ::std::os::raw::c_char,
2837 ) -> ::std::os::raw::c_int;
2838}
2839extern "C" {
2840 pub fn strncasecmp(
2841 arg1: *const ::std::os::raw::c_char,
2842 arg2: *const ::std::os::raw::c_char,
2843 arg3: ::std::os::raw::c_ulong,
2844 ) -> ::std::os::raw::c_int;
2845}
2846extern "C" {
2847 pub fn strcasecmp_l(
2848 arg1: *const ::std::os::raw::c_char,
2849 arg2: *const ::std::os::raw::c_char,
2850 arg3: locale_t,
2851 ) -> ::std::os::raw::c_int;
2852}
2853extern "C" {
2854 pub fn strncasecmp_l(
2855 arg1: *const ::std::os::raw::c_char,
2856 arg2: *const ::std::os::raw::c_char,
2857 arg3: usize,
2858 arg4: locale_t,
2859 ) -> ::std::os::raw::c_int;
2860}
2861extern "C" {
2862 pub fn strtok_r(
2863 arg1: *mut ::std::os::raw::c_char,
2864 arg2: *const ::std::os::raw::c_char,
2865 arg3: *mut *mut ::std::os::raw::c_char,
2866 ) -> *mut ::std::os::raw::c_char;
2867}
2868extern "C" {
2869 pub fn strerror_r(
2870 arg1: ::std::os::raw::c_int,
2871 arg2: *mut ::std::os::raw::c_char,
2872 arg3: usize,
2873 ) -> ::std::os::raw::c_int;
2874}
2875extern "C" {
2876 pub fn stpcpy(
2877 arg1: *mut ::std::os::raw::c_char,
2878 arg2: *const ::std::os::raw::c_char,
2879 ) -> *mut ::std::os::raw::c_char;
2880}
2881extern "C" {
2882 pub fn stpncpy(
2883 arg1: *mut ::std::os::raw::c_char,
2884 arg2: *const ::std::os::raw::c_char,
2885 arg3: ::std::os::raw::c_ulong,
2886 ) -> *mut ::std::os::raw::c_char;
2887}
2888extern "C" {
2889 pub fn strnlen(arg1: *const ::std::os::raw::c_char, arg2: usize) -> usize;
2890}
2891extern "C" {
2892 pub fn strndup(
2893 arg1: *const ::std::os::raw::c_char,
2894 arg2: ::std::os::raw::c_ulong,
2895 ) -> *mut ::std::os::raw::c_char;
2896}
2897extern "C" {
2898 pub fn strsignal(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
2899}
2900extern "C" {
2901 pub fn strerror_l(arg1: ::std::os::raw::c_int, arg2: locale_t) -> *mut ::std::os::raw::c_char;
2902}
2903extern "C" {
2904 pub fn strcoll_l(
2905 arg1: *const ::std::os::raw::c_char,
2906 arg2: *const ::std::os::raw::c_char,
2907 arg3: locale_t,
2908 ) -> ::std::os::raw::c_int;
2909}
2910extern "C" {
2911 pub fn strxfrm_l(
2912 arg1: *mut ::std::os::raw::c_char,
2913 arg2: *const ::std::os::raw::c_char,
2914 arg3: usize,
2915 arg4: locale_t,
2916 ) -> usize;
2917}
2918extern "C" {
2919 pub fn memccpy(
2920 arg1: *mut ::std::os::raw::c_void,
2921 arg2: *const ::std::os::raw::c_void,
2922 arg3: ::std::os::raw::c_int,
2923 arg4: ::std::os::raw::c_ulong,
2924 ) -> *mut ::std::os::raw::c_void;
2925}
2926extern "C" {
2927 pub fn strsep(
2928 arg1: *mut *mut ::std::os::raw::c_char,
2929 arg2: *const ::std::os::raw::c_char,
2930 ) -> *mut ::std::os::raw::c_char;
2931}
2932extern "C" {
2933 pub fn strlcat(
2934 arg1: *mut ::std::os::raw::c_char,
2935 arg2: *const ::std::os::raw::c_char,
2936 arg3: ::std::os::raw::c_ulong,
2937 ) -> ::std::os::raw::c_ulong;
2938}
2939extern "C" {
2940 pub fn strlcpy(
2941 arg1: *mut ::std::os::raw::c_char,
2942 arg2: *const ::std::os::raw::c_char,
2943 arg3: ::std::os::raw::c_ulong,
2944 ) -> ::std::os::raw::c_ulong;
2945}
2946extern "C" {
2947 pub fn explicit_bzero(arg1: *mut ::std::os::raw::c_void, arg2: usize);
2948}
2949extern "C" {
2950 #[doc = " Put a description of the AVERROR code errnum in errbuf.\n In case of failure the global variable errno is set to indicate the\n error. Even in case of failure av_strerror() will print a generic\n error message indicating the errnum provided to errbuf.\n\n @param errnum error code to describe\n @param errbuf buffer to which description is written\n @param errbuf_size the size in bytes of errbuf\n @return 0 on success, a negative value if a description for errnum\n cannot be found"]
2951 pub fn av_strerror(
2952 errnum: ::std::os::raw::c_int,
2953 errbuf: *mut ::std::os::raw::c_char,
2954 errbuf_size: usize,
2955 ) -> ::std::os::raw::c_int;
2956}
2957extern "C" {
2958 #[doc = " Allocate a memory block with alignment suitable for all memory accesses\n (including vectors if available on the CPU).\n\n @param size Size in bytes for the memory block to be allocated\n @return Pointer to the allocated block, or `NULL` if the block cannot\n be allocated\n @see av_mallocz()"]
2959 pub fn av_malloc(size: usize) -> *mut ::std::os::raw::c_void;
2960}
2961extern "C" {
2962 #[doc = " Allocate a memory block with alignment suitable for all memory accesses\n (including vectors if available on the CPU) and zero all the bytes of the\n block.\n\n @param size Size in bytes for the memory block to be allocated\n @return Pointer to the allocated block, or `NULL` if it cannot be allocated\n @see av_malloc()"]
2963 pub fn av_mallocz(size: usize) -> *mut ::std::os::raw::c_void;
2964}
2965extern "C" {
2966 #[doc = " Allocate a memory block for an array with av_malloc().\n\n The allocated memory will have size `size * nmemb` bytes.\n\n @param nmemb Number of element\n @param size Size of a single element\n @return Pointer to the allocated block, or `NULL` if the block cannot\n be allocated\n @see av_malloc()"]
2967 pub fn av_malloc_array(nmemb: usize, size: usize) -> *mut ::std::os::raw::c_void;
2968}
2969extern "C" {
2970 #[doc = " Allocate a memory block for an array with av_mallocz().\n\n The allocated memory will have size `size * nmemb` bytes.\n\n @param nmemb Number of elements\n @param size Size of the single element\n @return Pointer to the allocated block, or `NULL` if the block cannot\n be allocated\n\n @see av_mallocz()\n @see av_malloc_array()"]
2971 pub fn av_calloc(nmemb: usize, size: usize) -> *mut ::std::os::raw::c_void;
2972}
2973extern "C" {
2974 #[doc = " Allocate, reallocate, or free a block of memory.\n\n If `ptr` is `NULL` and `size` > 0, allocate a new block. Otherwise, expand or\n shrink that block of memory according to `size`.\n\n @param ptr Pointer to a memory block already allocated with\n av_realloc() or `NULL`\n @param size Size in bytes of the memory block to be allocated or\n reallocated\n\n @return Pointer to a newly-reallocated block or `NULL` if the block\n cannot be reallocated\n\n @warning Unlike av_malloc(), the returned pointer is not guaranteed to be\n correctly aligned. The returned pointer must be freed after even\n if size is zero.\n @see av_fast_realloc()\n @see av_reallocp()"]
2975 pub fn av_realloc(ptr: *mut ::std::os::raw::c_void, size: usize)
2976 -> *mut ::std::os::raw::c_void;
2977}
2978extern "C" {
2979 #[must_use]
2980 #[doc = " Allocate, reallocate, or free a block of memory through a pointer to a\n pointer.\n\n If `*ptr` is `NULL` and `size` > 0, allocate a new block. If `size` is\n zero, free the memory block pointed to by `*ptr`. Otherwise, expand or\n shrink that block of memory according to `size`.\n\n @param[in,out] ptr Pointer to a pointer to a memory block already allocated\n with av_realloc(), or a pointer to `NULL`. The pointer\n is updated on success, or freed on failure.\n @param[in] size Size in bytes for the memory block to be allocated or\n reallocated\n\n @return Zero on success, an AVERROR error code on failure\n\n @warning Unlike av_malloc(), the allocated memory is not guaranteed to be\n correctly aligned."]
2981 pub fn av_reallocp(ptr: *mut ::std::os::raw::c_void, size: usize) -> ::std::os::raw::c_int;
2982}
2983extern "C" {
2984 #[doc = " Allocate, reallocate, or free a block of memory.\n\n This function does the same thing as av_realloc(), except:\n - It takes two size arguments and allocates `nelem * elsize` bytes,\n after checking the result of the multiplication for integer overflow.\n - It frees the input block in case of failure, thus avoiding the memory\n leak with the classic\n @code{.c}\n buf = realloc(buf);\n if (!buf)\n return -1;\n @endcode\n pattern."]
2985 pub fn av_realloc_f(
2986 ptr: *mut ::std::os::raw::c_void,
2987 nelem: usize,
2988 elsize: usize,
2989 ) -> *mut ::std::os::raw::c_void;
2990}
2991extern "C" {
2992 #[doc = " Allocate, reallocate, or free an array.\n\n If `ptr` is `NULL` and `nmemb` > 0, allocate a new block.\n\n @param ptr Pointer to a memory block already allocated with\n av_realloc() or `NULL`\n @param nmemb Number of elements in the array\n @param size Size of the single element of the array\n\n @return Pointer to a newly-reallocated block or NULL if the block\n cannot be reallocated\n\n @warning Unlike av_malloc(), the allocated memory is not guaranteed to be\n correctly aligned. The returned pointer must be freed after even if\n nmemb is zero.\n @see av_reallocp_array()"]
2993 pub fn av_realloc_array(
2994 ptr: *mut ::std::os::raw::c_void,
2995 nmemb: usize,
2996 size: usize,
2997 ) -> *mut ::std::os::raw::c_void;
2998}
2999extern "C" {
3000 #[doc = " Allocate, reallocate an array through a pointer to a pointer.\n\n If `*ptr` is `NULL` and `nmemb` > 0, allocate a new block.\n\n @param[in,out] ptr Pointer to a pointer to a memory block already\n allocated with av_realloc(), or a pointer to `NULL`.\n The pointer is updated on success, or freed on failure.\n @param[in] nmemb Number of elements\n @param[in] size Size of the single element\n\n @return Zero on success, an AVERROR error code on failure\n\n @warning Unlike av_malloc(), the allocated memory is not guaranteed to be\n correctly aligned. *ptr must be freed after even if nmemb is zero."]
3001 pub fn av_reallocp_array(
3002 ptr: *mut ::std::os::raw::c_void,
3003 nmemb: usize,
3004 size: usize,
3005 ) -> ::std::os::raw::c_int;
3006}
3007extern "C" {
3008 #[doc = " Reallocate the given buffer if it is not large enough, otherwise do nothing.\n\n If the given buffer is `NULL`, then a new uninitialized buffer is allocated.\n\n If the given buffer is not large enough, and reallocation fails, `NULL` is\n returned and `*size` is set to 0, but the original buffer is not changed or\n freed.\n\n A typical use pattern follows:\n\n @code{.c}\n uint8_t *buf = ...;\n uint8_t *new_buf = av_fast_realloc(buf, ¤t_size, size_needed);\n if (!new_buf) {\n // Allocation failed; clean up original buffer\n av_freep(&buf);\n return AVERROR(ENOMEM);\n }\n @endcode\n\n @param[in,out] ptr Already allocated buffer, or `NULL`\n @param[in,out] size Pointer to the size of buffer `ptr`. `*size` is\n updated to the new allocated size, in particular 0\n in case of failure.\n @param[in] min_size Desired minimal size of buffer `ptr`\n @return `ptr` if the buffer is large enough, a pointer to newly reallocated\n buffer if the buffer was not large enough, or `NULL` in case of\n error\n @see av_realloc()\n @see av_fast_malloc()"]
3009 pub fn av_fast_realloc(
3010 ptr: *mut ::std::os::raw::c_void,
3011 size: *mut ::std::os::raw::c_uint,
3012 min_size: usize,
3013 ) -> *mut ::std::os::raw::c_void;
3014}
3015extern "C" {
3016 #[doc = " Allocate a buffer, reusing the given one if large enough.\n\n Contrary to av_fast_realloc(), the current buffer contents might not be\n preserved and on error the old buffer is freed, thus no special handling to\n avoid memleaks is necessary.\n\n `*ptr` is allowed to be `NULL`, in which case allocation always happens if\n `size_needed` is greater than 0.\n\n @code{.c}\n uint8_t *buf = ...;\n av_fast_malloc(&buf, ¤t_size, size_needed);\n if (!buf) {\n // Allocation failed; buf already freed\n return AVERROR(ENOMEM);\n }\n @endcode\n\n @param[in,out] ptr Pointer to pointer to an already allocated buffer.\n `*ptr` will be overwritten with pointer to new\n buffer on success or `NULL` on failure\n @param[in,out] size Pointer to the size of buffer `*ptr`. `*size` is\n updated to the new allocated size, in particular 0\n in case of failure.\n @param[in] min_size Desired minimal size of buffer `*ptr`\n @see av_realloc()\n @see av_fast_mallocz()"]
3017 pub fn av_fast_malloc(
3018 ptr: *mut ::std::os::raw::c_void,
3019 size: *mut ::std::os::raw::c_uint,
3020 min_size: usize,
3021 );
3022}
3023extern "C" {
3024 #[doc = " Allocate and clear a buffer, reusing the given one if large enough.\n\n Like av_fast_malloc(), but all newly allocated space is initially cleared.\n Reused buffer is not cleared.\n\n `*ptr` is allowed to be `NULL`, in which case allocation always happens if\n `size_needed` is greater than 0.\n\n @param[in,out] ptr Pointer to pointer to an already allocated buffer.\n `*ptr` will be overwritten with pointer to new\n buffer on success or `NULL` on failure\n @param[in,out] size Pointer to the size of buffer `*ptr`. `*size` is\n updated to the new allocated size, in particular 0\n in case of failure.\n @param[in] min_size Desired minimal size of buffer `*ptr`\n @see av_fast_malloc()"]
3025 pub fn av_fast_mallocz(
3026 ptr: *mut ::std::os::raw::c_void,
3027 size: *mut ::std::os::raw::c_uint,
3028 min_size: usize,
3029 );
3030}
3031extern "C" {
3032 #[doc = " Free a memory block which has been allocated with a function of av_malloc()\n or av_realloc() family.\n\n @param ptr Pointer to the memory block which should be freed.\n\n @note `ptr = NULL` is explicitly allowed.\n @note It is recommended that you use av_freep() instead, to prevent leaving\n behind dangling pointers.\n @see av_freep()"]
3033 pub fn av_free(ptr: *mut ::std::os::raw::c_void);
3034}
3035extern "C" {
3036 #[doc = " Free a memory block which has been allocated with a function of av_malloc()\n or av_realloc() family, and set the pointer pointing to it to `NULL`.\n\n @code{.c}\n uint8_t *buf = av_malloc(16);\n av_free(buf);\n // buf now contains a dangling pointer to freed memory, and accidental\n // dereference of buf will result in a use-after-free, which may be a\n // security risk.\n\n uint8_t *buf = av_malloc(16);\n av_freep(&buf);\n // buf is now NULL, and accidental dereference will only result in a\n // NULL-pointer dereference.\n @endcode\n\n @param ptr Pointer to the pointer to the memory block which should be freed\n @note `*ptr = NULL` is safe and leads to no action.\n @see av_free()"]
3037 pub fn av_freep(ptr: *mut ::std::os::raw::c_void);
3038}
3039extern "C" {
3040 #[doc = " Duplicate a string.\n\n @param s String to be duplicated\n @return Pointer to a newly-allocated string containing a\n copy of `s` or `NULL` if the string cannot be allocated\n @see av_strndup()"]
3041 pub fn av_strdup(s: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
3042}
3043extern "C" {
3044 #[doc = " Duplicate a substring of a string.\n\n @param s String to be duplicated\n @param len Maximum length of the resulting string (not counting the\n terminating byte)\n @return Pointer to a newly-allocated string containing a\n substring of `s` or `NULL` if the string cannot be allocated"]
3045 pub fn av_strndup(s: *const ::std::os::raw::c_char, len: usize) -> *mut ::std::os::raw::c_char;
3046}
3047extern "C" {
3048 #[doc = " Duplicate a buffer with av_malloc().\n\n @param p Buffer to be duplicated\n @param size Size in bytes of the buffer copied\n @return Pointer to a newly allocated buffer containing a\n copy of `p` or `NULL` if the buffer cannot be allocated"]
3049 pub fn av_memdup(p: *const ::std::os::raw::c_void, size: usize) -> *mut ::std::os::raw::c_void;
3050}
3051extern "C" {
3052 #[doc = " Overlapping memcpy() implementation.\n\n @param dst Destination buffer\n @param back Number of bytes back to start copying (i.e. the initial size of\n the overlapping window); must be > 0\n @param cnt Number of bytes to copy; must be >= 0\n\n @note `cnt > back` is valid, this will copy the bytes we just copied,\n thus creating a repeating pattern with a period length of `back`."]
3053 pub fn av_memcpy_backptr(dst: *mut u8, back: ::std::os::raw::c_int, cnt: ::std::os::raw::c_int);
3054}
3055extern "C" {
3056 #[doc = " Add the pointer to an element to a dynamic array.\n\n The array to grow is supposed to be an array of pointers to\n structures, and the element to add must be a pointer to an already\n allocated structure.\n\n The array is reallocated when its size reaches powers of 2.\n Therefore, the amortized cost of adding an element is constant.\n\n In case of success, the pointer to the array is updated in order to\n point to the new grown array, and the number pointed to by `nb_ptr`\n is incremented.\n In case of failure, the array is freed, `*tab_ptr` is set to `NULL` and\n `*nb_ptr` is set to 0.\n\n @param[in,out] tab_ptr Pointer to the array to grow\n @param[in,out] nb_ptr Pointer to the number of elements in the array\n @param[in] elem Element to add\n @see av_dynarray_add_nofree(), av_dynarray2_add()"]
3057 pub fn av_dynarray_add(
3058 tab_ptr: *mut ::std::os::raw::c_void,
3059 nb_ptr: *mut ::std::os::raw::c_int,
3060 elem: *mut ::std::os::raw::c_void,
3061 );
3062}
3063extern "C" {
3064 #[must_use]
3065 #[doc = " Add an element to a dynamic array.\n\n Function has the same functionality as av_dynarray_add(),\n but it doesn't free memory on fails. It returns error code\n instead and leave current buffer untouched.\n\n @return >=0 on success, negative otherwise\n @see av_dynarray_add(), av_dynarray2_add()"]
3066 pub fn av_dynarray_add_nofree(
3067 tab_ptr: *mut ::std::os::raw::c_void,
3068 nb_ptr: *mut ::std::os::raw::c_int,
3069 elem: *mut ::std::os::raw::c_void,
3070 ) -> ::std::os::raw::c_int;
3071}
3072extern "C" {
3073 #[doc = " Add an element of size `elem_size` to a dynamic array.\n\n The array is reallocated when its number of elements reaches powers of 2.\n Therefore, the amortized cost of adding an element is constant.\n\n In case of success, the pointer to the array is updated in order to\n point to the new grown array, and the number pointed to by `nb_ptr`\n is incremented.\n In case of failure, the array is freed, `*tab_ptr` is set to `NULL` and\n `*nb_ptr` is set to 0.\n\n @param[in,out] tab_ptr Pointer to the array to grow\n @param[in,out] nb_ptr Pointer to the number of elements in the array\n @param[in] elem_size Size in bytes of an element in the array\n @param[in] elem_data Pointer to the data of the element to add. If\n `NULL`, the space of the newly added element is\n allocated but left uninitialized.\n\n @return Pointer to the data of the element to copy in the newly allocated\n space\n @see av_dynarray_add(), av_dynarray_add_nofree()"]
3074 pub fn av_dynarray2_add(
3075 tab_ptr: *mut *mut ::std::os::raw::c_void,
3076 nb_ptr: *mut ::std::os::raw::c_int,
3077 elem_size: usize,
3078 elem_data: *const u8,
3079 ) -> *mut ::std::os::raw::c_void;
3080}
3081extern "C" {
3082 #[doc = " Multiply two `size_t` values checking for overflow.\n\n @param[in] a Operand of multiplication\n @param[in] b Operand of multiplication\n @param[out] r Pointer to the result of the operation\n @return 0 on success, AVERROR(EINVAL) on overflow"]
3083 pub fn av_size_mult(a: usize, b: usize, r: *mut usize) -> ::std::os::raw::c_int;
3084}
3085extern "C" {
3086 #[doc = " Set the maximum size that may be allocated in one block.\n\n The value specified with this function is effective for all libavutil's @ref\n lavu_mem_funcs \"heap management functions.\"\n\n By default, the max value is defined as `INT_MAX`.\n\n @param max Value to be set as the new maximum size\n\n @warning Exercise extreme caution when using this function. Don't touch\n this if you do not understand the full consequence of doing so."]
3087 pub fn av_max_alloc(max: usize);
3088}
3089extern "C" {
3090 pub fn av_log2(v: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
3091}
3092extern "C" {
3093 pub fn av_log2_16bit(v: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
3094}
3095#[doc = " Rational number (pair of numerator and denominator)."]
3096#[repr(C)]
3097#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3098pub struct AVRational {
3099 #[doc = "< Numerator"]
3100 pub num: ::std::os::raw::c_int,
3101 #[doc = "< Denominator"]
3102 pub den: ::std::os::raw::c_int,
3103}
3104extern "C" {
3105 #[doc = " Reduce a fraction.\n\n This is useful for framerate calculations.\n\n @param[out] dst_num Destination numerator\n @param[out] dst_den Destination denominator\n @param[in] num Source numerator\n @param[in] den Source denominator\n @param[in] max Maximum allowed values for `dst_num` & `dst_den`\n @return 1 if the operation is exact, 0 otherwise"]
3106 pub fn av_reduce(
3107 dst_num: *mut ::std::os::raw::c_int,
3108 dst_den: *mut ::std::os::raw::c_int,
3109 num: i64,
3110 den: i64,
3111 max: i64,
3112 ) -> ::std::os::raw::c_int;
3113}
3114extern "C" {
3115 #[doc = " Multiply two rationals.\n @param b First rational\n @param c Second rational\n @return b*c"]
3116 pub fn av_mul_q(b: AVRational, c: AVRational) -> AVRational;
3117}
3118extern "C" {
3119 #[doc = " Divide one rational by another.\n @param b First rational\n @param c Second rational\n @return b/c"]
3120 pub fn av_div_q(b: AVRational, c: AVRational) -> AVRational;
3121}
3122extern "C" {
3123 #[doc = " Add two rationals.\n @param b First rational\n @param c Second rational\n @return b+c"]
3124 pub fn av_add_q(b: AVRational, c: AVRational) -> AVRational;
3125}
3126extern "C" {
3127 #[doc = " Subtract one rational from another.\n @param b First rational\n @param c Second rational\n @return b-c"]
3128 pub fn av_sub_q(b: AVRational, c: AVRational) -> AVRational;
3129}
3130extern "C" {
3131 #[doc = " Convert a double precision floating point number to a rational.\n\n In case of infinity, the returned value is expressed as `{1, 0}` or\n `{-1, 0}` depending on the sign.\n\n In general rational numbers with |num| <= 1<<26 && |den| <= 1<<26\n can be recovered exactly from their double representation.\n (no exceptions were found within 1B random ones)\n\n @param d `double` to convert\n @param max Maximum allowed numerator and denominator\n @return `d` in AVRational form\n @see av_q2d()"]
3132 pub fn av_d2q(d: f64, max: ::std::os::raw::c_int) -> AVRational;
3133}
3134extern "C" {
3135 #[doc = " Find which of the two rationals is closer to another rational.\n\n @param q Rational to be compared against\n @param q1 Rational to be tested\n @param q2 Rational to be tested\n @return One of the following values:\n - 1 if `q1` is nearer to `q` than `q2`\n - -1 if `q2` is nearer to `q` than `q1`\n - 0 if they have the same distance"]
3136 pub fn av_nearer_q(q: AVRational, q1: AVRational, q2: AVRational) -> ::std::os::raw::c_int;
3137}
3138extern "C" {
3139 #[doc = " Find the value in a list of rationals nearest a given reference rational.\n\n @param q Reference rational\n @param q_list Array of rationals terminated by `{0, 0}`\n @return Index of the nearest value found in the array"]
3140 pub fn av_find_nearest_q_idx(q: AVRational, q_list: *const AVRational)
3141 -> ::std::os::raw::c_int;
3142}
3143extern "C" {
3144 #[doc = " Convert an AVRational to a IEEE 32-bit `float` expressed in fixed-point\n format.\n\n @param q Rational to be converted\n @return Equivalent floating-point value, expressed as an unsigned 32-bit\n integer.\n @note The returned value is platform-indepedant."]
3145 pub fn av_q2intfloat(q: AVRational) -> u32;
3146}
3147extern "C" {
3148 #[doc = " Return the best rational so that a and b are multiple of it.\n If the resulting denominator is larger than max_den, return def."]
3149 pub fn av_gcd_q(
3150 a: AVRational,
3151 b: AVRational,
3152 max_den: ::std::os::raw::c_int,
3153 def: AVRational,
3154 ) -> AVRational;
3155}
3156#[repr(C)]
3157#[derive(Copy, Clone)]
3158pub union av_intfloat32 {
3159 pub i: u32,
3160 pub f: f32,
3161}
3162impl Default for av_intfloat32 {
3163 fn default() -> Self {
3164 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3165 unsafe {
3166 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3167 s.assume_init()
3168 }
3169 }
3170}
3171#[repr(C)]
3172#[derive(Copy, Clone)]
3173pub union av_intfloat64 {
3174 pub i: u64,
3175 pub f: f64,
3176}
3177impl Default for av_intfloat64 {
3178 fn default() -> Self {
3179 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3180 unsafe {
3181 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3182 s.assume_init()
3183 }
3184 }
3185}
3186#[doc = "< Round toward zero."]
3187pub const AVRounding_AV_ROUND_ZERO: AVRounding = 0;
3188#[doc = "< Round away from zero."]
3189pub const AVRounding_AV_ROUND_INF: AVRounding = 1;
3190#[doc = "< Round toward -infinity."]
3191pub const AVRounding_AV_ROUND_DOWN: AVRounding = 2;
3192#[doc = "< Round toward +infinity."]
3193pub const AVRounding_AV_ROUND_UP: AVRounding = 3;
3194#[doc = "< Round to nearest and halfway cases away from zero."]
3195pub const AVRounding_AV_ROUND_NEAR_INF: AVRounding = 5;
3196#[doc = " Flag telling rescaling functions to pass `INT64_MIN`/`MAX` through\n unchanged, avoiding special cases for #AV_NOPTS_VALUE.\n\n Unlike other values of the enumeration AVRounding, this value is a\n bitmask that must be used in conjunction with another value of the\n enumeration through a bitwise OR, in order to set behavior for normal\n cases.\n\n @code{.c}\n av_rescale_rnd(3, 1, 2, AV_ROUND_UP | AV_ROUND_PASS_MINMAX);\n // Rescaling 3:\n // Calculating 3 * 1 / 2\n // 3 / 2 is rounded up to 2\n // => 2\n\n av_rescale_rnd(AV_NOPTS_VALUE, 1, 2, AV_ROUND_UP | AV_ROUND_PASS_MINMAX);\n // Rescaling AV_NOPTS_VALUE:\n // AV_NOPTS_VALUE == INT64_MIN\n // AV_NOPTS_VALUE is passed through\n // => AV_NOPTS_VALUE\n @endcode"]
3197pub const AVRounding_AV_ROUND_PASS_MINMAX: AVRounding = 8192;
3198#[doc = " Rounding methods."]
3199pub type AVRounding = ::std::os::raw::c_uint;
3200extern "C" {
3201 #[doc = " Compute the greatest common divisor of two integer operands.\n\n @param a Operand\n @param b Operand\n @return GCD of a and b up to sign; if a >= 0 and b >= 0, return value is >= 0;\n if a == 0 and b == 0, returns 0."]
3202 pub fn av_gcd(a: i64, b: i64) -> i64;
3203}
3204extern "C" {
3205 #[doc = " Rescale a 64-bit integer with rounding to nearest.\n\n The operation is mathematically equivalent to `a * b / c`, but writing that\n directly can overflow.\n\n This function is equivalent to av_rescale_rnd() with #AV_ROUND_NEAR_INF.\n\n @see av_rescale_rnd(), av_rescale_q(), av_rescale_q_rnd()"]
3206 pub fn av_rescale(a: i64, b: i64, c: i64) -> i64;
3207}
3208extern "C" {
3209 #[doc = " Rescale a 64-bit integer with specified rounding.\n\n The operation is mathematically equivalent to `a * b / c`, but writing that\n directly can overflow, and does not support different rounding methods.\n If the result is not representable then INT64_MIN is returned.\n\n @see av_rescale(), av_rescale_q(), av_rescale_q_rnd()"]
3210 pub fn av_rescale_rnd(a: i64, b: i64, c: i64, rnd: AVRounding) -> i64;
3211}
3212extern "C" {
3213 #[doc = " Rescale a 64-bit integer by 2 rational numbers.\n\n The operation is mathematically equivalent to `a * bq / cq`.\n\n This function is equivalent to av_rescale_q_rnd() with #AV_ROUND_NEAR_INF.\n\n @see av_rescale(), av_rescale_rnd(), av_rescale_q_rnd()"]
3214 pub fn av_rescale_q(a: i64, bq: AVRational, cq: AVRational) -> i64;
3215}
3216extern "C" {
3217 #[doc = " Rescale a 64-bit integer by 2 rational numbers with specified rounding.\n\n The operation is mathematically equivalent to `a * bq / cq`.\n\n @see av_rescale(), av_rescale_rnd(), av_rescale_q()"]
3218 pub fn av_rescale_q_rnd(a: i64, bq: AVRational, cq: AVRational, rnd: AVRounding) -> i64;
3219}
3220extern "C" {
3221 #[doc = " Compare two timestamps each in its own time base.\n\n @return One of the following values:\n - -1 if `ts_a` is before `ts_b`\n - 1 if `ts_a` is after `ts_b`\n - 0 if they represent the same position\n\n @warning\n The result of the function is undefined if one of the timestamps is outside\n the `int64_t` range when represented in the other's timebase."]
3222 pub fn av_compare_ts(
3223 ts_a: i64,
3224 tb_a: AVRational,
3225 ts_b: i64,
3226 tb_b: AVRational,
3227 ) -> ::std::os::raw::c_int;
3228}
3229extern "C" {
3230 #[doc = " Compare the remainders of two integer operands divided by a common divisor.\n\n In other words, compare the least significant `log2(mod)` bits of integers\n `a` and `b`.\n\n @code{.c}\n av_compare_mod(0x11, 0x02, 0x10) < 0 // since 0x11 % 0x10 (0x1) < 0x02 % 0x10 (0x2)\n av_compare_mod(0x11, 0x02, 0x20) > 0 // since 0x11 % 0x20 (0x11) > 0x02 % 0x20 (0x02)\n @endcode\n\n @param a Operand\n @param b Operand\n @param mod Divisor; must be a power of 2\n @return\n - a negative value if `a % mod < b % mod`\n - a positive value if `a % mod > b % mod`\n - zero if `a % mod == b % mod`"]
3231 pub fn av_compare_mod(a: u64, b: u64, mod_: u64) -> i64;
3232}
3233extern "C" {
3234 #[doc = " Rescale a timestamp while preserving known durations.\n\n This function is designed to be called per audio packet to scale the input\n timestamp to a different time base. Compared to a simple av_rescale_q()\n call, this function is robust against possible inconsistent frame durations.\n\n The `last` parameter is a state variable that must be preserved for all\n subsequent calls for the same stream. For the first call, `*last` should be\n initialized to #AV_NOPTS_VALUE.\n\n @param[in] in_tb Input time base\n @param[in] in_ts Input timestamp\n @param[in] fs_tb Duration time base; typically this is finer-grained\n (greater) than `in_tb` and `out_tb`\n @param[in] duration Duration till the next call to this function (i.e.\n duration of the current packet/frame)\n @param[in,out] last Pointer to a timestamp expressed in terms of\n `fs_tb`, acting as a state variable\n @param[in] out_tb Output timebase\n @return Timestamp expressed in terms of `out_tb`\n\n @note In the context of this function, \"duration\" is in term of samples, not\n seconds."]
3235 pub fn av_rescale_delta(
3236 in_tb: AVRational,
3237 in_ts: i64,
3238 fs_tb: AVRational,
3239 duration: ::std::os::raw::c_int,
3240 last: *mut i64,
3241 out_tb: AVRational,
3242 ) -> i64;
3243}
3244extern "C" {
3245 #[doc = " Add a value to a timestamp.\n\n This function guarantees that when the same value is repeatly added that\n no accumulation of rounding errors occurs.\n\n @param[in] ts Input timestamp\n @param[in] ts_tb Input timestamp time base\n @param[in] inc Value to be added\n @param[in] inc_tb Time base of `inc`"]
3246 pub fn av_add_stable(ts_tb: AVRational, ts: i64, inc_tb: AVRational, inc: i64) -> i64;
3247}
3248extern "C" {
3249 #[doc = " 0th order modified bessel function of the first kind."]
3250 pub fn av_bessel_i0(x: f64) -> f64;
3251}
3252pub type __gnuc_va_list = __builtin_va_list;
3253pub const AVClassCategory_AV_CLASS_CATEGORY_NA: AVClassCategory = 0;
3254pub const AVClassCategory_AV_CLASS_CATEGORY_INPUT: AVClassCategory = 1;
3255pub const AVClassCategory_AV_CLASS_CATEGORY_OUTPUT: AVClassCategory = 2;
3256pub const AVClassCategory_AV_CLASS_CATEGORY_MUXER: AVClassCategory = 3;
3257pub const AVClassCategory_AV_CLASS_CATEGORY_DEMUXER: AVClassCategory = 4;
3258pub const AVClassCategory_AV_CLASS_CATEGORY_ENCODER: AVClassCategory = 5;
3259pub const AVClassCategory_AV_CLASS_CATEGORY_DECODER: AVClassCategory = 6;
3260pub const AVClassCategory_AV_CLASS_CATEGORY_FILTER: AVClassCategory = 7;
3261pub const AVClassCategory_AV_CLASS_CATEGORY_BITSTREAM_FILTER: AVClassCategory = 8;
3262pub const AVClassCategory_AV_CLASS_CATEGORY_SWSCALER: AVClassCategory = 9;
3263pub const AVClassCategory_AV_CLASS_CATEGORY_SWRESAMPLER: AVClassCategory = 10;
3264pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT: AVClassCategory = 40;
3265pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT: AVClassCategory = 41;
3266pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT: AVClassCategory = 42;
3267pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT: AVClassCategory = 43;
3268pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_OUTPUT: AVClassCategory = 44;
3269pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_INPUT: AVClassCategory = 45;
3270#[doc = "< not part of ABI/API"]
3271pub const AVClassCategory_AV_CLASS_CATEGORY_NB: AVClassCategory = 46;
3272pub type AVClassCategory = ::std::os::raw::c_uint;
3273#[repr(C)]
3274#[derive(Debug, Copy, Clone)]
3275pub struct AVOptionRanges {
3276 _unused: [u8; 0],
3277}
3278#[doc = " Describe the class of an AVClass context structure. That is an\n arbitrary struct of which the first field is a pointer to an\n AVClass struct (e.g. AVCodecContext, AVFormatContext etc.)."]
3279#[repr(C)]
3280#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3281pub struct AVClass {
3282 #[doc = " The name of the class; usually it is the same name as the\n context structure type to which the AVClass is associated."]
3283 pub class_name: *const ::std::os::raw::c_char,
3284 #[doc = " A pointer to a function which returns the name of a context\n instance ctx associated with the class."]
3285 pub item_name: ::std::option::Option<
3286 unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void) -> *const ::std::os::raw::c_char,
3287 >,
3288 #[doc = " a pointer to the first option specified in the class if any or NULL\n\n @see av_set_default_options()"]
3289 pub option: *mut AVOption,
3290 #[doc = " LIBAVUTIL_VERSION with which this structure was created.\n This is used to allow fields to be added without requiring major\n version bumps everywhere."]
3291 pub version: ::std::os::raw::c_int,
3292 #[doc = " Offset in the structure where log_level_offset is stored.\n 0 means there is no such variable"]
3293 pub log_level_offset_offset: ::std::os::raw::c_int,
3294 #[doc = " Offset in the structure where a pointer to the parent context for\n logging is stored. For example a decoder could pass its AVCodecContext\n to eval as such a parent context, which an av_log() implementation\n could then leverage to display the parent context.\n The offset can be NULL."]
3295 pub parent_log_context_offset: ::std::os::raw::c_int,
3296 #[doc = " Category used for visualization (like color)\n This is only set if the category is equal for all objects using this class.\n available since version (51 << 16 | 56 << 8 | 100)"]
3297 pub category: AVClassCategory,
3298 #[doc = " Callback to return the category.\n available since version (51 << 16 | 59 << 8 | 100)"]
3299 pub get_category: ::std::option::Option<
3300 unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void) -> AVClassCategory,
3301 >,
3302 #[doc = " Callback to return the supported/allowed ranges.\n available since version (52.12)"]
3303 pub query_ranges: ::std::option::Option<
3304 unsafe extern "C" fn(
3305 arg1: *mut *mut AVOptionRanges,
3306 obj: *mut ::std::os::raw::c_void,
3307 key: *const ::std::os::raw::c_char,
3308 flags: ::std::os::raw::c_int,
3309 ) -> ::std::os::raw::c_int,
3310 >,
3311 #[doc = " Return next AVOptions-enabled child or NULL"]
3312 pub child_next: ::std::option::Option<
3313 unsafe extern "C" fn(
3314 obj: *mut ::std::os::raw::c_void,
3315 prev: *mut ::std::os::raw::c_void,
3316 ) -> *mut ::std::os::raw::c_void,
3317 >,
3318 #[doc = " Iterate over the AVClasses corresponding to potential AVOptions-enabled\n children.\n\n @param iter pointer to opaque iteration state. The caller must initialize\n *iter to NULL before the first call.\n @return AVClass for the next AVOptions-enabled child or NULL if there are\n no more such children.\n\n @note The difference between child_next and this is that child_next\n iterates over _already existing_ objects, while child_class_iterate\n iterates over _all possible_ children."]
3319 pub child_class_iterate: ::std::option::Option<
3320 unsafe extern "C" fn(iter: *mut *mut ::std::os::raw::c_void) -> *const AVClass,
3321 >,
3322}
3323impl Default for AVClass {
3324 fn default() -> Self {
3325 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3326 unsafe {
3327 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3328 s.assume_init()
3329 }
3330 }
3331}
3332extern "C" {
3333 #[doc = " Send the specified message to the log if the level is less than or equal\n to the current av_log_level. By default, all logging messages are sent to\n stderr. This behavior can be altered by setting a different logging callback\n function.\n @see av_log_set_callback\n\n @param avcl A pointer to an arbitrary struct of which the first field is a\n pointer to an AVClass struct or NULL if general log.\n @param level The importance level of the message expressed using a @ref\n lavu_log_constants \"Logging Constant\".\n @param fmt The format string (printf-compatible) that specifies how\n subsequent arguments are converted to output."]
3334 pub fn av_log(
3335 avcl: *mut ::std::os::raw::c_void,
3336 level: ::std::os::raw::c_int,
3337 fmt: *const ::std::os::raw::c_char,
3338 ...
3339 );
3340}
3341extern "C" {
3342 #[doc = " Send the specified message to the log once with the initial_level and then with\n the subsequent_level. By default, all logging messages are sent to\n stderr. This behavior can be altered by setting a different logging callback\n function.\n @see av_log\n\n @param avcl A pointer to an arbitrary struct of which the first field is a\n pointer to an AVClass struct or NULL if general log.\n @param initial_level importance level of the message expressed using a @ref\n lavu_log_constants \"Logging Constant\" for the first occurance.\n @param subsequent_level importance level of the message expressed using a @ref\n lavu_log_constants \"Logging Constant\" after the first occurance.\n @param fmt The format string (printf-compatible) that specifies how\n subsequent arguments are converted to output.\n @param state a variable to keep trak of if a message has already been printed\n this must be initialized to 0 before the first use. The same state\n must not be accessed by 2 Threads simultaneously."]
3343 pub fn av_log_once(
3344 avcl: *mut ::std::os::raw::c_void,
3345 initial_level: ::std::os::raw::c_int,
3346 subsequent_level: ::std::os::raw::c_int,
3347 state: *mut ::std::os::raw::c_int,
3348 fmt: *const ::std::os::raw::c_char,
3349 ...
3350 );
3351}
3352extern "C" {
3353 #[doc = " Send the specified message to the log if the level is less than or equal\n to the current av_log_level. By default, all logging messages are sent to\n stderr. This behavior can be altered by setting a different logging callback\n function.\n @see av_log_set_callback\n\n @param avcl A pointer to an arbitrary struct of which the first field is a\n pointer to an AVClass struct.\n @param level The importance level of the message expressed using a @ref\n lavu_log_constants \"Logging Constant\".\n @param fmt The format string (printf-compatible) that specifies how\n subsequent arguments are converted to output.\n @param vl The arguments referenced by the format string."]
3354 pub fn av_vlog(
3355 avcl: *mut ::std::os::raw::c_void,
3356 level: ::std::os::raw::c_int,
3357 fmt: *const ::std::os::raw::c_char,
3358 vl: va_list,
3359 );
3360}
3361extern "C" {
3362 #[doc = " Get the current log level\n\n @see lavu_log_constants\n\n @return Current log level"]
3363 pub fn av_log_get_level() -> ::std::os::raw::c_int;
3364}
3365extern "C" {
3366 #[doc = " Set the log level\n\n @see lavu_log_constants\n\n @param level Logging level"]
3367 pub fn av_log_set_level(level: ::std::os::raw::c_int);
3368}
3369extern "C" {
3370 #[doc = " Set the logging callback\n\n @note The callback must be thread safe, even if the application does not use\n threads itself as some codecs are multithreaded.\n\n @see av_log_default_callback\n\n @param callback A logging function with a compatible signature."]
3371 pub fn av_log_set_callback(
3372 callback: ::std::option::Option<
3373 unsafe extern "C" fn(
3374 arg1: *mut ::std::os::raw::c_void,
3375 arg2: ::std::os::raw::c_int,
3376 arg3: *const ::std::os::raw::c_char,
3377 arg4: va_list,
3378 ),
3379 >,
3380 );
3381}
3382extern "C" {
3383 #[doc = " Default logging callback\n\n It prints the message to stderr, optionally colorizing it.\n\n @param avcl A pointer to an arbitrary struct of which the first field is a\n pointer to an AVClass struct.\n @param level The importance level of the message expressed using a @ref\n lavu_log_constants \"Logging Constant\".\n @param fmt The format string (printf-compatible) that specifies how\n subsequent arguments are converted to output.\n @param vl The arguments referenced by the format string."]
3384 pub fn av_log_default_callback(
3385 avcl: *mut ::std::os::raw::c_void,
3386 level: ::std::os::raw::c_int,
3387 fmt: *const ::std::os::raw::c_char,
3388 vl: va_list,
3389 );
3390}
3391extern "C" {
3392 #[doc = " Return the context name\n\n @param ctx The AVClass context\n\n @return The AVClass class_name"]
3393 pub fn av_default_item_name(ctx: *mut ::std::os::raw::c_void) -> *const ::std::os::raw::c_char;
3394}
3395extern "C" {
3396 pub fn av_default_get_category(ptr: *mut ::std::os::raw::c_void) -> AVClassCategory;
3397}
3398extern "C" {
3399 #[doc = " Format a line of log the same way as the default callback.\n @param line buffer to receive the formatted line\n @param line_size size of the buffer\n @param print_prefix used to store whether the prefix must be printed;\n must point to a persistent integer initially set to 1"]
3400 pub fn av_log_format_line(
3401 ptr: *mut ::std::os::raw::c_void,
3402 level: ::std::os::raw::c_int,
3403 fmt: *const ::std::os::raw::c_char,
3404 vl: va_list,
3405 line: *mut ::std::os::raw::c_char,
3406 line_size: ::std::os::raw::c_int,
3407 print_prefix: *mut ::std::os::raw::c_int,
3408 );
3409}
3410extern "C" {
3411 #[doc = " Format a line of log the same way as the default callback.\n @param line buffer to receive the formatted line;\n may be NULL if line_size is 0\n @param line_size size of the buffer; at most line_size-1 characters will\n be written to the buffer, plus one null terminator\n @param print_prefix used to store whether the prefix must be printed;\n must point to a persistent integer initially set to 1\n @return Returns a negative value if an error occurred, otherwise returns\n the number of characters that would have been written for a\n sufficiently large buffer, not including the terminating null\n character. If the return value is not less than line_size, it means\n that the log message was truncated to fit the buffer."]
3412 pub fn av_log_format_line2(
3413 ptr: *mut ::std::os::raw::c_void,
3414 level: ::std::os::raw::c_int,
3415 fmt: *const ::std::os::raw::c_char,
3416 vl: va_list,
3417 line: *mut ::std::os::raw::c_char,
3418 line_size: ::std::os::raw::c_int,
3419 print_prefix: *mut ::std::os::raw::c_int,
3420 ) -> ::std::os::raw::c_int;
3421}
3422extern "C" {
3423 pub fn av_log_set_flags(arg: ::std::os::raw::c_int);
3424}
3425extern "C" {
3426 pub fn av_log_get_flags() -> ::std::os::raw::c_int;
3427}
3428pub const AVPixelFormat_AV_PIX_FMT_NONE: AVPixelFormat = -1;
3429#[doc = "< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)"]
3430pub const AVPixelFormat_AV_PIX_FMT_YUV420P: AVPixelFormat = 0;
3431#[doc = "< packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr"]
3432pub const AVPixelFormat_AV_PIX_FMT_YUYV422: AVPixelFormat = 1;
3433#[doc = "< packed RGB 8:8:8, 24bpp, RGBRGB..."]
3434pub const AVPixelFormat_AV_PIX_FMT_RGB24: AVPixelFormat = 2;
3435#[doc = "< packed RGB 8:8:8, 24bpp, BGRBGR..."]
3436pub const AVPixelFormat_AV_PIX_FMT_BGR24: AVPixelFormat = 3;
3437#[doc = "< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)"]
3438pub const AVPixelFormat_AV_PIX_FMT_YUV422P: AVPixelFormat = 4;
3439#[doc = "< planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)"]
3440pub const AVPixelFormat_AV_PIX_FMT_YUV444P: AVPixelFormat = 5;
3441#[doc = "< planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)"]
3442pub const AVPixelFormat_AV_PIX_FMT_YUV410P: AVPixelFormat = 6;
3443#[doc = "< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)"]
3444pub const AVPixelFormat_AV_PIX_FMT_YUV411P: AVPixelFormat = 7;
3445#[doc = "< Y , 8bpp"]
3446pub const AVPixelFormat_AV_PIX_FMT_GRAY8: AVPixelFormat = 8;
3447#[doc = "< Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb"]
3448pub const AVPixelFormat_AV_PIX_FMT_MONOWHITE: AVPixelFormat = 9;
3449#[doc = "< Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb"]
3450pub const AVPixelFormat_AV_PIX_FMT_MONOBLACK: AVPixelFormat = 10;
3451#[doc = "< 8 bits with AV_PIX_FMT_RGB32 palette"]
3452pub const AVPixelFormat_AV_PIX_FMT_PAL8: AVPixelFormat = 11;
3453#[doc = "< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting color_range"]
3454pub const AVPixelFormat_AV_PIX_FMT_YUVJ420P: AVPixelFormat = 12;
3455#[doc = "< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting color_range"]
3456pub const AVPixelFormat_AV_PIX_FMT_YUVJ422P: AVPixelFormat = 13;
3457#[doc = "< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting color_range"]
3458pub const AVPixelFormat_AV_PIX_FMT_YUVJ444P: AVPixelFormat = 14;
3459#[doc = "< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1"]
3460pub const AVPixelFormat_AV_PIX_FMT_UYVY422: AVPixelFormat = 15;
3461#[doc = "< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3"]
3462pub const AVPixelFormat_AV_PIX_FMT_UYYVYY411: AVPixelFormat = 16;
3463#[doc = "< packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)"]
3464pub const AVPixelFormat_AV_PIX_FMT_BGR8: AVPixelFormat = 17;
3465#[doc = "< packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits"]
3466pub const AVPixelFormat_AV_PIX_FMT_BGR4: AVPixelFormat = 18;
3467#[doc = "< packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)"]
3468pub const AVPixelFormat_AV_PIX_FMT_BGR4_BYTE: AVPixelFormat = 19;
3469#[doc = "< packed RGB 3:3:2, 8bpp, (msb)3R 3G 2B(lsb)"]
3470pub const AVPixelFormat_AV_PIX_FMT_RGB8: AVPixelFormat = 20;
3471#[doc = "< packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits"]
3472pub const AVPixelFormat_AV_PIX_FMT_RGB4: AVPixelFormat = 21;
3473#[doc = "< packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)"]
3474pub const AVPixelFormat_AV_PIX_FMT_RGB4_BYTE: AVPixelFormat = 22;
3475#[doc = "< planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)"]
3476pub const AVPixelFormat_AV_PIX_FMT_NV12: AVPixelFormat = 23;
3477#[doc = "< as above, but U and V bytes are swapped"]
3478pub const AVPixelFormat_AV_PIX_FMT_NV21: AVPixelFormat = 24;
3479#[doc = "< packed ARGB 8:8:8:8, 32bpp, ARGBARGB..."]
3480pub const AVPixelFormat_AV_PIX_FMT_ARGB: AVPixelFormat = 25;
3481#[doc = "< packed RGBA 8:8:8:8, 32bpp, RGBARGBA..."]
3482pub const AVPixelFormat_AV_PIX_FMT_RGBA: AVPixelFormat = 26;
3483#[doc = "< packed ABGR 8:8:8:8, 32bpp, ABGRABGR..."]
3484pub const AVPixelFormat_AV_PIX_FMT_ABGR: AVPixelFormat = 27;
3485#[doc = "< packed BGRA 8:8:8:8, 32bpp, BGRABGRA..."]
3486pub const AVPixelFormat_AV_PIX_FMT_BGRA: AVPixelFormat = 28;
3487#[doc = "< Y , 16bpp, big-endian"]
3488pub const AVPixelFormat_AV_PIX_FMT_GRAY16BE: AVPixelFormat = 29;
3489#[doc = "< Y , 16bpp, little-endian"]
3490pub const AVPixelFormat_AV_PIX_FMT_GRAY16LE: AVPixelFormat = 30;
3491#[doc = "< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)"]
3492pub const AVPixelFormat_AV_PIX_FMT_YUV440P: AVPixelFormat = 31;
3493#[doc = "< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range"]
3494pub const AVPixelFormat_AV_PIX_FMT_YUVJ440P: AVPixelFormat = 32;
3495#[doc = "< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)"]
3496pub const AVPixelFormat_AV_PIX_FMT_YUVA420P: AVPixelFormat = 33;
3497#[doc = "< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian"]
3498pub const AVPixelFormat_AV_PIX_FMT_RGB48BE: AVPixelFormat = 34;
3499#[doc = "< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as little-endian"]
3500pub const AVPixelFormat_AV_PIX_FMT_RGB48LE: AVPixelFormat = 35;
3501#[doc = "< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian"]
3502pub const AVPixelFormat_AV_PIX_FMT_RGB565BE: AVPixelFormat = 36;
3503#[doc = "< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian"]
3504pub const AVPixelFormat_AV_PIX_FMT_RGB565LE: AVPixelFormat = 37;
3505#[doc = "< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined"]
3506pub const AVPixelFormat_AV_PIX_FMT_RGB555BE: AVPixelFormat = 38;
3507#[doc = "< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined"]
3508pub const AVPixelFormat_AV_PIX_FMT_RGB555LE: AVPixelFormat = 39;
3509#[doc = "< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian"]
3510pub const AVPixelFormat_AV_PIX_FMT_BGR565BE: AVPixelFormat = 40;
3511#[doc = "< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian"]
3512pub const AVPixelFormat_AV_PIX_FMT_BGR565LE: AVPixelFormat = 41;
3513#[doc = "< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined"]
3514pub const AVPixelFormat_AV_PIX_FMT_BGR555BE: AVPixelFormat = 42;
3515#[doc = "< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined"]
3516pub const AVPixelFormat_AV_PIX_FMT_BGR555LE: AVPixelFormat = 43;
3517#[doc = " Hardware acceleration through VA-API, data[3] contains a\n VASurfaceID."]
3518pub const AVPixelFormat_AV_PIX_FMT_VAAPI: AVPixelFormat = 44;
3519#[doc = "< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian"]
3520pub const AVPixelFormat_AV_PIX_FMT_YUV420P16LE: AVPixelFormat = 45;
3521#[doc = "< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian"]
3522pub const AVPixelFormat_AV_PIX_FMT_YUV420P16BE: AVPixelFormat = 46;
3523#[doc = "< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3524pub const AVPixelFormat_AV_PIX_FMT_YUV422P16LE: AVPixelFormat = 47;
3525#[doc = "< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3526pub const AVPixelFormat_AV_PIX_FMT_YUV422P16BE: AVPixelFormat = 48;
3527#[doc = "< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian"]
3528pub const AVPixelFormat_AV_PIX_FMT_YUV444P16LE: AVPixelFormat = 49;
3529#[doc = "< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian"]
3530pub const AVPixelFormat_AV_PIX_FMT_YUV444P16BE: AVPixelFormat = 50;
3531#[doc = "< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer"]
3532pub const AVPixelFormat_AV_PIX_FMT_DXVA2_VLD: AVPixelFormat = 51;
3533#[doc = "< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined"]
3534pub const AVPixelFormat_AV_PIX_FMT_RGB444LE: AVPixelFormat = 52;
3535#[doc = "< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined"]
3536pub const AVPixelFormat_AV_PIX_FMT_RGB444BE: AVPixelFormat = 53;
3537#[doc = "< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined"]
3538pub const AVPixelFormat_AV_PIX_FMT_BGR444LE: AVPixelFormat = 54;
3539#[doc = "< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined"]
3540pub const AVPixelFormat_AV_PIX_FMT_BGR444BE: AVPixelFormat = 55;
3541#[doc = "< 8 bits gray, 8 bits alpha"]
3542pub const AVPixelFormat_AV_PIX_FMT_YA8: AVPixelFormat = 56;
3543#[doc = "< alias for AV_PIX_FMT_YA8"]
3544pub const AVPixelFormat_AV_PIX_FMT_Y400A: AVPixelFormat = 56;
3545#[doc = "< alias for AV_PIX_FMT_YA8"]
3546pub const AVPixelFormat_AV_PIX_FMT_GRAY8A: AVPixelFormat = 56;
3547#[doc = "< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian"]
3548pub const AVPixelFormat_AV_PIX_FMT_BGR48BE: AVPixelFormat = 57;
3549#[doc = "< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as little-endian"]
3550pub const AVPixelFormat_AV_PIX_FMT_BGR48LE: AVPixelFormat = 58;
3551#[doc = "< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian"]
3552pub const AVPixelFormat_AV_PIX_FMT_YUV420P9BE: AVPixelFormat = 59;
3553#[doc = "< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian"]
3554pub const AVPixelFormat_AV_PIX_FMT_YUV420P9LE: AVPixelFormat = 60;
3555#[doc = "< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian"]
3556pub const AVPixelFormat_AV_PIX_FMT_YUV420P10BE: AVPixelFormat = 61;
3557#[doc = "< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian"]
3558pub const AVPixelFormat_AV_PIX_FMT_YUV420P10LE: AVPixelFormat = 62;
3559#[doc = "< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3560pub const AVPixelFormat_AV_PIX_FMT_YUV422P10BE: AVPixelFormat = 63;
3561#[doc = "< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3562pub const AVPixelFormat_AV_PIX_FMT_YUV422P10LE: AVPixelFormat = 64;
3563#[doc = "< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian"]
3564pub const AVPixelFormat_AV_PIX_FMT_YUV444P9BE: AVPixelFormat = 65;
3565#[doc = "< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian"]
3566pub const AVPixelFormat_AV_PIX_FMT_YUV444P9LE: AVPixelFormat = 66;
3567#[doc = "< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian"]
3568pub const AVPixelFormat_AV_PIX_FMT_YUV444P10BE: AVPixelFormat = 67;
3569#[doc = "< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian"]
3570pub const AVPixelFormat_AV_PIX_FMT_YUV444P10LE: AVPixelFormat = 68;
3571#[doc = "< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3572pub const AVPixelFormat_AV_PIX_FMT_YUV422P9BE: AVPixelFormat = 69;
3573#[doc = "< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3574pub const AVPixelFormat_AV_PIX_FMT_YUV422P9LE: AVPixelFormat = 70;
3575#[doc = "< planar GBR 4:4:4 24bpp"]
3576pub const AVPixelFormat_AV_PIX_FMT_GBRP: AVPixelFormat = 71;
3577pub const AVPixelFormat_AV_PIX_FMT_GBR24P: AVPixelFormat = 71;
3578#[doc = "< planar GBR 4:4:4 27bpp, big-endian"]
3579pub const AVPixelFormat_AV_PIX_FMT_GBRP9BE: AVPixelFormat = 72;
3580#[doc = "< planar GBR 4:4:4 27bpp, little-endian"]
3581pub const AVPixelFormat_AV_PIX_FMT_GBRP9LE: AVPixelFormat = 73;
3582#[doc = "< planar GBR 4:4:4 30bpp, big-endian"]
3583pub const AVPixelFormat_AV_PIX_FMT_GBRP10BE: AVPixelFormat = 74;
3584#[doc = "< planar GBR 4:4:4 30bpp, little-endian"]
3585pub const AVPixelFormat_AV_PIX_FMT_GBRP10LE: AVPixelFormat = 75;
3586#[doc = "< planar GBR 4:4:4 48bpp, big-endian"]
3587pub const AVPixelFormat_AV_PIX_FMT_GBRP16BE: AVPixelFormat = 76;
3588#[doc = "< planar GBR 4:4:4 48bpp, little-endian"]
3589pub const AVPixelFormat_AV_PIX_FMT_GBRP16LE: AVPixelFormat = 77;
3590#[doc = "< planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)"]
3591pub const AVPixelFormat_AV_PIX_FMT_YUVA422P: AVPixelFormat = 78;
3592#[doc = "< planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)"]
3593pub const AVPixelFormat_AV_PIX_FMT_YUVA444P: AVPixelFormat = 79;
3594#[doc = "< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian"]
3595pub const AVPixelFormat_AV_PIX_FMT_YUVA420P9BE: AVPixelFormat = 80;
3596#[doc = "< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian"]
3597pub const AVPixelFormat_AV_PIX_FMT_YUVA420P9LE: AVPixelFormat = 81;
3598#[doc = "< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian"]
3599pub const AVPixelFormat_AV_PIX_FMT_YUVA422P9BE: AVPixelFormat = 82;
3600#[doc = "< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian"]
3601pub const AVPixelFormat_AV_PIX_FMT_YUVA422P9LE: AVPixelFormat = 83;
3602#[doc = "< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian"]
3603pub const AVPixelFormat_AV_PIX_FMT_YUVA444P9BE: AVPixelFormat = 84;
3604#[doc = "< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian"]
3605pub const AVPixelFormat_AV_PIX_FMT_YUVA444P9LE: AVPixelFormat = 85;
3606#[doc = "< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)"]
3607pub const AVPixelFormat_AV_PIX_FMT_YUVA420P10BE: AVPixelFormat = 86;
3608#[doc = "< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)"]
3609pub const AVPixelFormat_AV_PIX_FMT_YUVA420P10LE: AVPixelFormat = 87;
3610#[doc = "< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)"]
3611pub const AVPixelFormat_AV_PIX_FMT_YUVA422P10BE: AVPixelFormat = 88;
3612#[doc = "< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)"]
3613pub const AVPixelFormat_AV_PIX_FMT_YUVA422P10LE: AVPixelFormat = 89;
3614#[doc = "< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)"]
3615pub const AVPixelFormat_AV_PIX_FMT_YUVA444P10BE: AVPixelFormat = 90;
3616#[doc = "< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)"]
3617pub const AVPixelFormat_AV_PIX_FMT_YUVA444P10LE: AVPixelFormat = 91;
3618#[doc = "< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)"]
3619pub const AVPixelFormat_AV_PIX_FMT_YUVA420P16BE: AVPixelFormat = 92;
3620#[doc = "< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)"]
3621pub const AVPixelFormat_AV_PIX_FMT_YUVA420P16LE: AVPixelFormat = 93;
3622#[doc = "< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)"]
3623pub const AVPixelFormat_AV_PIX_FMT_YUVA422P16BE: AVPixelFormat = 94;
3624#[doc = "< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)"]
3625pub const AVPixelFormat_AV_PIX_FMT_YUVA422P16LE: AVPixelFormat = 95;
3626#[doc = "< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)"]
3627pub const AVPixelFormat_AV_PIX_FMT_YUVA444P16BE: AVPixelFormat = 96;
3628#[doc = "< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)"]
3629pub const AVPixelFormat_AV_PIX_FMT_YUVA444P16LE: AVPixelFormat = 97;
3630#[doc = "< HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface"]
3631pub const AVPixelFormat_AV_PIX_FMT_VDPAU: AVPixelFormat = 98;
3632#[doc = "< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as little-endian, the 4 lower bits are set to 0"]
3633pub const AVPixelFormat_AV_PIX_FMT_XYZ12LE: AVPixelFormat = 99;
3634#[doc = "< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as big-endian, the 4 lower bits are set to 0"]
3635pub const AVPixelFormat_AV_PIX_FMT_XYZ12BE: AVPixelFormat = 100;
3636#[doc = "< interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)"]
3637pub const AVPixelFormat_AV_PIX_FMT_NV16: AVPixelFormat = 101;
3638#[doc = "< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3639pub const AVPixelFormat_AV_PIX_FMT_NV20LE: AVPixelFormat = 102;
3640#[doc = "< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3641pub const AVPixelFormat_AV_PIX_FMT_NV20BE: AVPixelFormat = 103;
3642#[doc = "< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian"]
3643pub const AVPixelFormat_AV_PIX_FMT_RGBA64BE: AVPixelFormat = 104;
3644#[doc = "< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian"]
3645pub const AVPixelFormat_AV_PIX_FMT_RGBA64LE: AVPixelFormat = 105;
3646#[doc = "< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian"]
3647pub const AVPixelFormat_AV_PIX_FMT_BGRA64BE: AVPixelFormat = 106;
3648#[doc = "< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian"]
3649pub const AVPixelFormat_AV_PIX_FMT_BGRA64LE: AVPixelFormat = 107;
3650#[doc = "< packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb"]
3651pub const AVPixelFormat_AV_PIX_FMT_YVYU422: AVPixelFormat = 108;
3652#[doc = "< 16 bits gray, 16 bits alpha (big-endian)"]
3653pub const AVPixelFormat_AV_PIX_FMT_YA16BE: AVPixelFormat = 109;
3654#[doc = "< 16 bits gray, 16 bits alpha (little-endian)"]
3655pub const AVPixelFormat_AV_PIX_FMT_YA16LE: AVPixelFormat = 110;
3656#[doc = "< planar GBRA 4:4:4:4 32bpp"]
3657pub const AVPixelFormat_AV_PIX_FMT_GBRAP: AVPixelFormat = 111;
3658#[doc = "< planar GBRA 4:4:4:4 64bpp, big-endian"]
3659pub const AVPixelFormat_AV_PIX_FMT_GBRAP16BE: AVPixelFormat = 112;
3660#[doc = "< planar GBRA 4:4:4:4 64bpp, little-endian"]
3661pub const AVPixelFormat_AV_PIX_FMT_GBRAP16LE: AVPixelFormat = 113;
3662#[doc = " HW acceleration through QSV, data[3] contains a pointer to the\n mfxFrameSurface1 structure.\n\n Before FFmpeg 5.0:\n mfxFrameSurface1.Data.MemId contains a pointer when importing\n the following frames as QSV frames:\n\n VAAPI:\n mfxFrameSurface1.Data.MemId contains a pointer to VASurfaceID\n\n DXVA2:\n mfxFrameSurface1.Data.MemId contains a pointer to IDirect3DSurface9\n\n FFmpeg 5.0 and above:\n mfxFrameSurface1.Data.MemId contains a pointer to the mfxHDLPair\n structure when importing the following frames as QSV frames:\n\n VAAPI:\n mfxHDLPair.first contains a VASurfaceID pointer.\n mfxHDLPair.second is always MFX_INFINITE.\n\n DXVA2:\n mfxHDLPair.first contains IDirect3DSurface9 pointer.\n mfxHDLPair.second is always MFX_INFINITE.\n\n D3D11:\n mfxHDLPair.first contains a ID3D11Texture2D pointer.\n mfxHDLPair.second contains the texture array index of the frame if the\n ID3D11Texture2D is an array texture, or always MFX_INFINITE if it is a\n normal texture."]
3663pub const AVPixelFormat_AV_PIX_FMT_QSV: AVPixelFormat = 114;
3664#[doc = " HW acceleration though MMAL, data[3] contains a pointer to the\n MMAL_BUFFER_HEADER_T structure."]
3665pub const AVPixelFormat_AV_PIX_FMT_MMAL: AVPixelFormat = 115;
3666#[doc = "< HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView pointer"]
3667pub const AVPixelFormat_AV_PIX_FMT_D3D11VA_VLD: AVPixelFormat = 116;
3668#[doc = " HW acceleration through CUDA. data[i] contain CUdeviceptr pointers\n exactly as for system memory frames."]
3669pub const AVPixelFormat_AV_PIX_FMT_CUDA: AVPixelFormat = 117;
3670#[doc = "< packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined"]
3671pub const AVPixelFormat_AV_PIX_FMT_0RGB: AVPixelFormat = 118;
3672#[doc = "< packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined"]
3673pub const AVPixelFormat_AV_PIX_FMT_RGB0: AVPixelFormat = 119;
3674#[doc = "< packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined"]
3675pub const AVPixelFormat_AV_PIX_FMT_0BGR: AVPixelFormat = 120;
3676#[doc = "< packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined"]
3677pub const AVPixelFormat_AV_PIX_FMT_BGR0: AVPixelFormat = 121;
3678#[doc = "< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian"]
3679pub const AVPixelFormat_AV_PIX_FMT_YUV420P12BE: AVPixelFormat = 122;
3680#[doc = "< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian"]
3681pub const AVPixelFormat_AV_PIX_FMT_YUV420P12LE: AVPixelFormat = 123;
3682#[doc = "< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian"]
3683pub const AVPixelFormat_AV_PIX_FMT_YUV420P14BE: AVPixelFormat = 124;
3684#[doc = "< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian"]
3685pub const AVPixelFormat_AV_PIX_FMT_YUV420P14LE: AVPixelFormat = 125;
3686#[doc = "< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3687pub const AVPixelFormat_AV_PIX_FMT_YUV422P12BE: AVPixelFormat = 126;
3688#[doc = "< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3689pub const AVPixelFormat_AV_PIX_FMT_YUV422P12LE: AVPixelFormat = 127;
3690#[doc = "< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3691pub const AVPixelFormat_AV_PIX_FMT_YUV422P14BE: AVPixelFormat = 128;
3692#[doc = "< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3693pub const AVPixelFormat_AV_PIX_FMT_YUV422P14LE: AVPixelFormat = 129;
3694#[doc = "< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian"]
3695pub const AVPixelFormat_AV_PIX_FMT_YUV444P12BE: AVPixelFormat = 130;
3696#[doc = "< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian"]
3697pub const AVPixelFormat_AV_PIX_FMT_YUV444P12LE: AVPixelFormat = 131;
3698#[doc = "< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian"]
3699pub const AVPixelFormat_AV_PIX_FMT_YUV444P14BE: AVPixelFormat = 132;
3700#[doc = "< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian"]
3701pub const AVPixelFormat_AV_PIX_FMT_YUV444P14LE: AVPixelFormat = 133;
3702#[doc = "< planar GBR 4:4:4 36bpp, big-endian"]
3703pub const AVPixelFormat_AV_PIX_FMT_GBRP12BE: AVPixelFormat = 134;
3704#[doc = "< planar GBR 4:4:4 36bpp, little-endian"]
3705pub const AVPixelFormat_AV_PIX_FMT_GBRP12LE: AVPixelFormat = 135;
3706#[doc = "< planar GBR 4:4:4 42bpp, big-endian"]
3707pub const AVPixelFormat_AV_PIX_FMT_GBRP14BE: AVPixelFormat = 136;
3708#[doc = "< planar GBR 4:4:4 42bpp, little-endian"]
3709pub const AVPixelFormat_AV_PIX_FMT_GBRP14LE: AVPixelFormat = 137;
3710#[doc = "< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV411P and setting color_range"]
3711pub const AVPixelFormat_AV_PIX_FMT_YUVJ411P: AVPixelFormat = 138;
3712#[doc = "< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples"]
3713pub const AVPixelFormat_AV_PIX_FMT_BAYER_BGGR8: AVPixelFormat = 139;
3714#[doc = "< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples"]
3715pub const AVPixelFormat_AV_PIX_FMT_BAYER_RGGB8: AVPixelFormat = 140;
3716#[doc = "< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples"]
3717pub const AVPixelFormat_AV_PIX_FMT_BAYER_GBRG8: AVPixelFormat = 141;
3718#[doc = "< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples"]
3719pub const AVPixelFormat_AV_PIX_FMT_BAYER_GRBG8: AVPixelFormat = 142;
3720#[doc = "< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian"]
3721pub const AVPixelFormat_AV_PIX_FMT_BAYER_BGGR16LE: AVPixelFormat = 143;
3722#[doc = "< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian"]
3723pub const AVPixelFormat_AV_PIX_FMT_BAYER_BGGR16BE: AVPixelFormat = 144;
3724#[doc = "< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian"]
3725pub const AVPixelFormat_AV_PIX_FMT_BAYER_RGGB16LE: AVPixelFormat = 145;
3726#[doc = "< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian"]
3727pub const AVPixelFormat_AV_PIX_FMT_BAYER_RGGB16BE: AVPixelFormat = 146;
3728#[doc = "< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian"]
3729pub const AVPixelFormat_AV_PIX_FMT_BAYER_GBRG16LE: AVPixelFormat = 147;
3730#[doc = "< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian"]
3731pub const AVPixelFormat_AV_PIX_FMT_BAYER_GBRG16BE: AVPixelFormat = 148;
3732#[doc = "< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian"]
3733pub const AVPixelFormat_AV_PIX_FMT_BAYER_GRBG16LE: AVPixelFormat = 149;
3734#[doc = "< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian"]
3735pub const AVPixelFormat_AV_PIX_FMT_BAYER_GRBG16BE: AVPixelFormat = 150;
3736#[doc = "< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian"]
3737pub const AVPixelFormat_AV_PIX_FMT_YUV440P10LE: AVPixelFormat = 151;
3738#[doc = "< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian"]
3739pub const AVPixelFormat_AV_PIX_FMT_YUV440P10BE: AVPixelFormat = 152;
3740#[doc = "< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian"]
3741pub const AVPixelFormat_AV_PIX_FMT_YUV440P12LE: AVPixelFormat = 153;
3742#[doc = "< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian"]
3743pub const AVPixelFormat_AV_PIX_FMT_YUV440P12BE: AVPixelFormat = 154;
3744#[doc = "< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian"]
3745pub const AVPixelFormat_AV_PIX_FMT_AYUV64LE: AVPixelFormat = 155;
3746#[doc = "< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), big-endian"]
3747pub const AVPixelFormat_AV_PIX_FMT_AYUV64BE: AVPixelFormat = 156;
3748#[doc = "< hardware decoding through Videotoolbox"]
3749pub const AVPixelFormat_AV_PIX_FMT_VIDEOTOOLBOX: AVPixelFormat = 157;
3750#[doc = "< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, little-endian"]
3751pub const AVPixelFormat_AV_PIX_FMT_P010LE: AVPixelFormat = 158;
3752#[doc = "< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, big-endian"]
3753pub const AVPixelFormat_AV_PIX_FMT_P010BE: AVPixelFormat = 159;
3754#[doc = "< planar GBR 4:4:4:4 48bpp, big-endian"]
3755pub const AVPixelFormat_AV_PIX_FMT_GBRAP12BE: AVPixelFormat = 160;
3756#[doc = "< planar GBR 4:4:4:4 48bpp, little-endian"]
3757pub const AVPixelFormat_AV_PIX_FMT_GBRAP12LE: AVPixelFormat = 161;
3758#[doc = "< planar GBR 4:4:4:4 40bpp, big-endian"]
3759pub const AVPixelFormat_AV_PIX_FMT_GBRAP10BE: AVPixelFormat = 162;
3760#[doc = "< planar GBR 4:4:4:4 40bpp, little-endian"]
3761pub const AVPixelFormat_AV_PIX_FMT_GBRAP10LE: AVPixelFormat = 163;
3762#[doc = "< hardware decoding through MediaCodec"]
3763pub const AVPixelFormat_AV_PIX_FMT_MEDIACODEC: AVPixelFormat = 164;
3764#[doc = "< Y , 12bpp, big-endian"]
3765pub const AVPixelFormat_AV_PIX_FMT_GRAY12BE: AVPixelFormat = 165;
3766#[doc = "< Y , 12bpp, little-endian"]
3767pub const AVPixelFormat_AV_PIX_FMT_GRAY12LE: AVPixelFormat = 166;
3768#[doc = "< Y , 10bpp, big-endian"]
3769pub const AVPixelFormat_AV_PIX_FMT_GRAY10BE: AVPixelFormat = 167;
3770#[doc = "< Y , 10bpp, little-endian"]
3771pub const AVPixelFormat_AV_PIX_FMT_GRAY10LE: AVPixelFormat = 168;
3772#[doc = "< like NV12, with 16bpp per component, little-endian"]
3773pub const AVPixelFormat_AV_PIX_FMT_P016LE: AVPixelFormat = 169;
3774#[doc = "< like NV12, with 16bpp per component, big-endian"]
3775pub const AVPixelFormat_AV_PIX_FMT_P016BE: AVPixelFormat = 170;
3776#[doc = " Hardware surfaces for Direct3D11.\n\n This is preferred over the legacy AV_PIX_FMT_D3D11VA_VLD. The new D3D11\n hwaccel API and filtering support AV_PIX_FMT_D3D11 only.\n\n data[0] contains a ID3D11Texture2D pointer, and data[1] contains the\n texture array index of the frame as intptr_t if the ID3D11Texture2D is\n an array texture (or always 0 if it's a normal texture)."]
3777pub const AVPixelFormat_AV_PIX_FMT_D3D11: AVPixelFormat = 171;
3778#[doc = "< Y , 9bpp, big-endian"]
3779pub const AVPixelFormat_AV_PIX_FMT_GRAY9BE: AVPixelFormat = 172;
3780#[doc = "< Y , 9bpp, little-endian"]
3781pub const AVPixelFormat_AV_PIX_FMT_GRAY9LE: AVPixelFormat = 173;
3782#[doc = "< IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian"]
3783pub const AVPixelFormat_AV_PIX_FMT_GBRPF32BE: AVPixelFormat = 174;
3784#[doc = "< IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian"]
3785pub const AVPixelFormat_AV_PIX_FMT_GBRPF32LE: AVPixelFormat = 175;
3786#[doc = "< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian"]
3787pub const AVPixelFormat_AV_PIX_FMT_GBRAPF32BE: AVPixelFormat = 176;
3788#[doc = "< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian"]
3789pub const AVPixelFormat_AV_PIX_FMT_GBRAPF32LE: AVPixelFormat = 177;
3790#[doc = " DRM-managed buffers exposed through PRIME buffer sharing.\n\n data[0] points to an AVDRMFrameDescriptor."]
3791pub const AVPixelFormat_AV_PIX_FMT_DRM_PRIME: AVPixelFormat = 178;
3792#[doc = " Hardware surfaces for OpenCL.\n\n data[i] contain 2D image objects (typed in C as cl_mem, used\n in OpenCL as image2d_t) for each plane of the surface."]
3793pub const AVPixelFormat_AV_PIX_FMT_OPENCL: AVPixelFormat = 179;
3794#[doc = "< Y , 14bpp, big-endian"]
3795pub const AVPixelFormat_AV_PIX_FMT_GRAY14BE: AVPixelFormat = 180;
3796#[doc = "< Y , 14bpp, little-endian"]
3797pub const AVPixelFormat_AV_PIX_FMT_GRAY14LE: AVPixelFormat = 181;
3798#[doc = "< IEEE-754 single precision Y, 32bpp, big-endian"]
3799pub const AVPixelFormat_AV_PIX_FMT_GRAYF32BE: AVPixelFormat = 182;
3800#[doc = "< IEEE-754 single precision Y, 32bpp, little-endian"]
3801pub const AVPixelFormat_AV_PIX_FMT_GRAYF32LE: AVPixelFormat = 183;
3802#[doc = "< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian"]
3803pub const AVPixelFormat_AV_PIX_FMT_YUVA422P12BE: AVPixelFormat = 184;
3804#[doc = "< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian"]
3805pub const AVPixelFormat_AV_PIX_FMT_YUVA422P12LE: AVPixelFormat = 185;
3806#[doc = "< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian"]
3807pub const AVPixelFormat_AV_PIX_FMT_YUVA444P12BE: AVPixelFormat = 186;
3808#[doc = "< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian"]
3809pub const AVPixelFormat_AV_PIX_FMT_YUVA444P12LE: AVPixelFormat = 187;
3810#[doc = "< planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)"]
3811pub const AVPixelFormat_AV_PIX_FMT_NV24: AVPixelFormat = 188;
3812#[doc = "< as above, but U and V bytes are swapped"]
3813pub const AVPixelFormat_AV_PIX_FMT_NV42: AVPixelFormat = 189;
3814#[doc = " Vulkan hardware images.\n\n data[0] points to an AVVkFrame"]
3815pub const AVPixelFormat_AV_PIX_FMT_VULKAN: AVPixelFormat = 190;
3816#[doc = "< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, big-endian"]
3817pub const AVPixelFormat_AV_PIX_FMT_Y210BE: AVPixelFormat = 191;
3818#[doc = "< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian"]
3819pub const AVPixelFormat_AV_PIX_FMT_Y210LE: AVPixelFormat = 192;
3820#[doc = "< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined"]
3821pub const AVPixelFormat_AV_PIX_FMT_X2RGB10LE: AVPixelFormat = 193;
3822#[doc = "< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), big-endian, X=unused/undefined"]
3823pub const AVPixelFormat_AV_PIX_FMT_X2RGB10BE: AVPixelFormat = 194;
3824#[doc = "< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined"]
3825pub const AVPixelFormat_AV_PIX_FMT_X2BGR10LE: AVPixelFormat = 195;
3826#[doc = "< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), big-endian, X=unused/undefined"]
3827pub const AVPixelFormat_AV_PIX_FMT_X2BGR10BE: AVPixelFormat = 196;
3828#[doc = "< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, big-endian"]
3829pub const AVPixelFormat_AV_PIX_FMT_P210BE: AVPixelFormat = 197;
3830#[doc = "< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, little-endian"]
3831pub const AVPixelFormat_AV_PIX_FMT_P210LE: AVPixelFormat = 198;
3832#[doc = "< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, big-endian"]
3833pub const AVPixelFormat_AV_PIX_FMT_P410BE: AVPixelFormat = 199;
3834#[doc = "< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, little-endian"]
3835pub const AVPixelFormat_AV_PIX_FMT_P410LE: AVPixelFormat = 200;
3836#[doc = "< interleaved chroma YUV 4:2:2, 32bpp, big-endian"]
3837pub const AVPixelFormat_AV_PIX_FMT_P216BE: AVPixelFormat = 201;
3838#[doc = "< interleaved chroma YUV 4:2:2, 32bpp, little-endian"]
3839pub const AVPixelFormat_AV_PIX_FMT_P216LE: AVPixelFormat = 202;
3840#[doc = "< interleaved chroma YUV 4:4:4, 48bpp, big-endian"]
3841pub const AVPixelFormat_AV_PIX_FMT_P416BE: AVPixelFormat = 203;
3842#[doc = "< interleaved chroma YUV 4:4:4, 48bpp, little-endian"]
3843pub const AVPixelFormat_AV_PIX_FMT_P416LE: AVPixelFormat = 204;
3844#[doc = "< packed VUYA 4:4:4, 32bpp, VUYAVUYA..."]
3845pub const AVPixelFormat_AV_PIX_FMT_VUYA: AVPixelFormat = 205;
3846#[doc = "< IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., big-endian"]
3847pub const AVPixelFormat_AV_PIX_FMT_RGBAF16BE: AVPixelFormat = 206;
3848#[doc = "< IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., little-endian"]
3849pub const AVPixelFormat_AV_PIX_FMT_RGBAF16LE: AVPixelFormat = 207;
3850#[doc = "< packed VUYX 4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined"]
3851pub const AVPixelFormat_AV_PIX_FMT_VUYX: AVPixelFormat = 208;
3852#[doc = "< like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, little-endian"]
3853pub const AVPixelFormat_AV_PIX_FMT_P012LE: AVPixelFormat = 209;
3854#[doc = "< like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, big-endian"]
3855pub const AVPixelFormat_AV_PIX_FMT_P012BE: AVPixelFormat = 210;
3856#[doc = "< packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, big-endian"]
3857pub const AVPixelFormat_AV_PIX_FMT_Y212BE: AVPixelFormat = 211;
3858#[doc = "< packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, little-endian"]
3859pub const AVPixelFormat_AV_PIX_FMT_Y212LE: AVPixelFormat = 212;
3860#[doc = "< packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), big-endian, variant of Y410 where alpha channel is left undefined"]
3861pub const AVPixelFormat_AV_PIX_FMT_XV30BE: AVPixelFormat = 213;
3862#[doc = "< packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), little-endian, variant of Y410 where alpha channel is left undefined"]
3863pub const AVPixelFormat_AV_PIX_FMT_XV30LE: AVPixelFormat = 214;
3864#[doc = "< packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, big-endian, variant of Y412 where alpha channel is left undefined"]
3865pub const AVPixelFormat_AV_PIX_FMT_XV36BE: AVPixelFormat = 215;
3866#[doc = "< packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, little-endian, variant of Y412 where alpha channel is left undefined"]
3867pub const AVPixelFormat_AV_PIX_FMT_XV36LE: AVPixelFormat = 216;
3868#[doc = "< IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., big-endian"]
3869pub const AVPixelFormat_AV_PIX_FMT_RGBF32BE: AVPixelFormat = 217;
3870#[doc = "< IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., little-endian"]
3871pub const AVPixelFormat_AV_PIX_FMT_RGBF32LE: AVPixelFormat = 218;
3872#[doc = "< IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., big-endian"]
3873pub const AVPixelFormat_AV_PIX_FMT_RGBAF32BE: AVPixelFormat = 219;
3874#[doc = "< IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., little-endian"]
3875pub const AVPixelFormat_AV_PIX_FMT_RGBAF32LE: AVPixelFormat = 220;
3876#[doc = "< interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, big-endian"]
3877pub const AVPixelFormat_AV_PIX_FMT_P212BE: AVPixelFormat = 221;
3878#[doc = "< interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, little-endian"]
3879pub const AVPixelFormat_AV_PIX_FMT_P212LE: AVPixelFormat = 222;
3880#[doc = "< interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, big-endian"]
3881pub const AVPixelFormat_AV_PIX_FMT_P412BE: AVPixelFormat = 223;
3882#[doc = "< interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, little-endian"]
3883pub const AVPixelFormat_AV_PIX_FMT_P412LE: AVPixelFormat = 224;
3884#[doc = "< planar GBR 4:4:4:4 56bpp, big-endian"]
3885pub const AVPixelFormat_AV_PIX_FMT_GBRAP14BE: AVPixelFormat = 225;
3886#[doc = "< planar GBR 4:4:4:4 56bpp, little-endian"]
3887pub const AVPixelFormat_AV_PIX_FMT_GBRAP14LE: AVPixelFormat = 226;
3888#[doc = " Hardware surfaces for Direct3D 12.\n\n data[0] points to an AVD3D12VAFrame"]
3889pub const AVPixelFormat_AV_PIX_FMT_D3D12: AVPixelFormat = 227;
3890#[doc = "< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions"]
3891pub const AVPixelFormat_AV_PIX_FMT_NB: AVPixelFormat = 228;
3892#[doc = " Pixel format.\n\n @note\n AV_PIX_FMT_RGB32 is handled in an endian-specific manner. An RGBA\n color is put together as:\n (A << 24) | (R << 16) | (G << 8) | B\n This is stored as BGRA on little-endian CPU architectures and ARGB on\n big-endian CPUs.\n\n @note\n If the resolution is not a multiple of the chroma subsampling factor\n then the chroma plane resolution must be rounded up.\n\n @par\n When the pixel format is palettized RGB32 (AV_PIX_FMT_PAL8), the palettized\n image data is stored in AVFrame.data[0]. The palette is transported in\n AVFrame.data[1], is 1024 bytes long (256 4-byte entries) and is\n formatted the same as in AV_PIX_FMT_RGB32 described above (i.e., it is\n also endian-specific). Note also that the individual RGB32 palette\n components stored in AVFrame.data[1] should be in the range 0..255.\n This is important as many custom PAL8 video codecs that were designed\n to run on the IBM VGA graphics adapter use 6-bit palette components.\n\n @par\n For all the 8 bits per pixel formats, an RGB32 palette is in data[1] like\n for pal8. This palette is filled in automatically by the function\n allocating the picture."]
3893pub type AVPixelFormat = ::std::os::raw::c_int;
3894pub const AVColorPrimaries_AVCOL_PRI_RESERVED0: AVColorPrimaries = 0;
3895#[doc = "< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B"]
3896pub const AVColorPrimaries_AVCOL_PRI_BT709: AVColorPrimaries = 1;
3897pub const AVColorPrimaries_AVCOL_PRI_UNSPECIFIED: AVColorPrimaries = 2;
3898pub const AVColorPrimaries_AVCOL_PRI_RESERVED: AVColorPrimaries = 3;
3899#[doc = "< also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)"]
3900pub const AVColorPrimaries_AVCOL_PRI_BT470M: AVColorPrimaries = 4;
3901#[doc = "< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM"]
3902pub const AVColorPrimaries_AVCOL_PRI_BT470BG: AVColorPrimaries = 5;
3903#[doc = "< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC"]
3904pub const AVColorPrimaries_AVCOL_PRI_SMPTE170M: AVColorPrimaries = 6;
3905#[doc = "< identical to above, also called \"SMPTE C\" even though it uses D65"]
3906pub const AVColorPrimaries_AVCOL_PRI_SMPTE240M: AVColorPrimaries = 7;
3907#[doc = "< colour filters using Illuminant C"]
3908pub const AVColorPrimaries_AVCOL_PRI_FILM: AVColorPrimaries = 8;
3909#[doc = "< ITU-R BT2020"]
3910pub const AVColorPrimaries_AVCOL_PRI_BT2020: AVColorPrimaries = 9;
3911#[doc = "< SMPTE ST 428-1 (CIE 1931 XYZ)"]
3912pub const AVColorPrimaries_AVCOL_PRI_SMPTE428: AVColorPrimaries = 10;
3913pub const AVColorPrimaries_AVCOL_PRI_SMPTEST428_1: AVColorPrimaries = 10;
3914#[doc = "< SMPTE ST 431-2 (2011) / DCI P3"]
3915pub const AVColorPrimaries_AVCOL_PRI_SMPTE431: AVColorPrimaries = 11;
3916#[doc = "< SMPTE ST 432-1 (2010) / P3 D65 / Display P3"]
3917pub const AVColorPrimaries_AVCOL_PRI_SMPTE432: AVColorPrimaries = 12;
3918#[doc = "< EBU Tech. 3213-E (nothing there) / one of JEDEC P22 group phosphors"]
3919pub const AVColorPrimaries_AVCOL_PRI_EBU3213: AVColorPrimaries = 22;
3920pub const AVColorPrimaries_AVCOL_PRI_JEDEC_P22: AVColorPrimaries = 22;
3921#[doc = "< Not part of ABI"]
3922pub const AVColorPrimaries_AVCOL_PRI_NB: AVColorPrimaries = 23;
3923#[doc = " Chromaticity coordinates of the source primaries.\n These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.1 and ITU-T H.273."]
3924pub type AVColorPrimaries = ::std::os::raw::c_uint;
3925pub const AVColorTransferCharacteristic_AVCOL_TRC_RESERVED0: AVColorTransferCharacteristic = 0;
3926#[doc = "< also ITU-R BT1361"]
3927pub const AVColorTransferCharacteristic_AVCOL_TRC_BT709: AVColorTransferCharacteristic = 1;
3928pub const AVColorTransferCharacteristic_AVCOL_TRC_UNSPECIFIED: AVColorTransferCharacteristic = 2;
3929pub const AVColorTransferCharacteristic_AVCOL_TRC_RESERVED: AVColorTransferCharacteristic = 3;
3930#[doc = "< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM"]
3931pub const AVColorTransferCharacteristic_AVCOL_TRC_GAMMA22: AVColorTransferCharacteristic = 4;
3932#[doc = "< also ITU-R BT470BG"]
3933pub const AVColorTransferCharacteristic_AVCOL_TRC_GAMMA28: AVColorTransferCharacteristic = 5;
3934#[doc = "< also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC"]
3935pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTE170M: AVColorTransferCharacteristic = 6;
3936pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTE240M: AVColorTransferCharacteristic = 7;
3937#[doc = "< \"Linear transfer characteristics\""]
3938pub const AVColorTransferCharacteristic_AVCOL_TRC_LINEAR: AVColorTransferCharacteristic = 8;
3939#[doc = "< \"Logarithmic transfer characteristic (100:1 range)\""]
3940pub const AVColorTransferCharacteristic_AVCOL_TRC_LOG: AVColorTransferCharacteristic = 9;
3941#[doc = "< \"Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)\""]
3942pub const AVColorTransferCharacteristic_AVCOL_TRC_LOG_SQRT: AVColorTransferCharacteristic = 10;
3943#[doc = "< IEC 61966-2-4"]
3944pub const AVColorTransferCharacteristic_AVCOL_TRC_IEC61966_2_4: AVColorTransferCharacteristic = 11;
3945#[doc = "< ITU-R BT1361 Extended Colour Gamut"]
3946pub const AVColorTransferCharacteristic_AVCOL_TRC_BT1361_ECG: AVColorTransferCharacteristic = 12;
3947#[doc = "< IEC 61966-2-1 (sRGB or sYCC)"]
3948pub const AVColorTransferCharacteristic_AVCOL_TRC_IEC61966_2_1: AVColorTransferCharacteristic = 13;
3949#[doc = "< ITU-R BT2020 for 10-bit system"]
3950pub const AVColorTransferCharacteristic_AVCOL_TRC_BT2020_10: AVColorTransferCharacteristic = 14;
3951#[doc = "< ITU-R BT2020 for 12-bit system"]
3952pub const AVColorTransferCharacteristic_AVCOL_TRC_BT2020_12: AVColorTransferCharacteristic = 15;
3953#[doc = "< SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems"]
3954pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTE2084: AVColorTransferCharacteristic = 16;
3955pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTEST2084: AVColorTransferCharacteristic = 16;
3956#[doc = "< SMPTE ST 428-1"]
3957pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTE428: AVColorTransferCharacteristic = 17;
3958pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTEST428_1: AVColorTransferCharacteristic = 17;
3959#[doc = "< ARIB STD-B67, known as \"Hybrid log-gamma\""]
3960pub const AVColorTransferCharacteristic_AVCOL_TRC_ARIB_STD_B67: AVColorTransferCharacteristic = 18;
3961#[doc = "< Not part of ABI"]
3962pub const AVColorTransferCharacteristic_AVCOL_TRC_NB: AVColorTransferCharacteristic = 19;
3963#[doc = " Color Transfer Characteristic.\n These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.2."]
3964pub type AVColorTransferCharacteristic = ::std::os::raw::c_uint;
3965#[doc = "< order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1"]
3966pub const AVColorSpace_AVCOL_SPC_RGB: AVColorSpace = 0;
3967#[doc = "< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B"]
3968pub const AVColorSpace_AVCOL_SPC_BT709: AVColorSpace = 1;
3969pub const AVColorSpace_AVCOL_SPC_UNSPECIFIED: AVColorSpace = 2;
3970#[doc = "< reserved for future use by ITU-T and ISO/IEC just like 15-255 are"]
3971pub const AVColorSpace_AVCOL_SPC_RESERVED: AVColorSpace = 3;
3972#[doc = "< FCC Title 47 Code of Federal Regulations 73.682 (a)(20)"]
3973pub const AVColorSpace_AVCOL_SPC_FCC: AVColorSpace = 4;
3974#[doc = "< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601"]
3975pub const AVColorSpace_AVCOL_SPC_BT470BG: AVColorSpace = 5;
3976#[doc = "< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above"]
3977pub const AVColorSpace_AVCOL_SPC_SMPTE170M: AVColorSpace = 6;
3978#[doc = "< derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries"]
3979pub const AVColorSpace_AVCOL_SPC_SMPTE240M: AVColorSpace = 7;
3980#[doc = "< used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16"]
3981pub const AVColorSpace_AVCOL_SPC_YCGCO: AVColorSpace = 8;
3982pub const AVColorSpace_AVCOL_SPC_YCOCG: AVColorSpace = 8;
3983#[doc = "< ITU-R BT2020 non-constant luminance system"]
3984pub const AVColorSpace_AVCOL_SPC_BT2020_NCL: AVColorSpace = 9;
3985#[doc = "< ITU-R BT2020 constant luminance system"]
3986pub const AVColorSpace_AVCOL_SPC_BT2020_CL: AVColorSpace = 10;
3987#[doc = "< SMPTE 2085, Y'D'zD'x"]
3988pub const AVColorSpace_AVCOL_SPC_SMPTE2085: AVColorSpace = 11;
3989#[doc = "< Chromaticity-derived non-constant luminance system"]
3990pub const AVColorSpace_AVCOL_SPC_CHROMA_DERIVED_NCL: AVColorSpace = 12;
3991#[doc = "< Chromaticity-derived constant luminance system"]
3992pub const AVColorSpace_AVCOL_SPC_CHROMA_DERIVED_CL: AVColorSpace = 13;
3993#[doc = "< ITU-R BT.2100-0, ICtCp"]
3994pub const AVColorSpace_AVCOL_SPC_ICTCP: AVColorSpace = 14;
3995#[doc = "< SMPTE ST 2128, IPT-C2"]
3996pub const AVColorSpace_AVCOL_SPC_IPT_C2: AVColorSpace = 15;
3997#[doc = "< YCgCo-R, even addition of bits"]
3998pub const AVColorSpace_AVCOL_SPC_YCGCO_RE: AVColorSpace = 16;
3999#[doc = "< YCgCo-R, odd addition of bits"]
4000pub const AVColorSpace_AVCOL_SPC_YCGCO_RO: AVColorSpace = 17;
4001#[doc = "< Not part of ABI"]
4002pub const AVColorSpace_AVCOL_SPC_NB: AVColorSpace = 18;
4003#[doc = " YUV colorspace type.\n These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.3."]
4004pub type AVColorSpace = ::std::os::raw::c_uint;
4005pub const AVColorRange_AVCOL_RANGE_UNSPECIFIED: AVColorRange = 0;
4006#[doc = " Narrow or limited range content.\n\n - For luma planes:\n\n (219 * E + 16) * 2^(n-8)\n\n F.ex. the range of 16-235 for 8 bits\n\n - For chroma planes:\n\n (224 * E + 128) * 2^(n-8)\n\n F.ex. the range of 16-240 for 8 bits"]
4007pub const AVColorRange_AVCOL_RANGE_MPEG: AVColorRange = 1;
4008#[doc = " Full range content.\n\n - For RGB and luma planes:\n\n (2^n - 1) * E\n\n F.ex. the range of 0-255 for 8 bits\n\n - For chroma planes:\n\n (2^n - 1) * E + 2^(n - 1)\n\n F.ex. the range of 1-255 for 8 bits"]
4009pub const AVColorRange_AVCOL_RANGE_JPEG: AVColorRange = 2;
4010#[doc = "< Not part of ABI"]
4011pub const AVColorRange_AVCOL_RANGE_NB: AVColorRange = 3;
4012#[doc = " Visual content value range.\n\n These values are based on definitions that can be found in multiple\n specifications, such as ITU-T BT.709 (3.4 - Quantization of RGB, luminance\n and colour-difference signals), ITU-T BT.2020 (Table 5 - Digital\n Representation) as well as ITU-T BT.2100 (Table 9 - Digital 10- and 12-bit\n integer representation). At the time of writing, the BT.2100 one is\n recommended, as it also defines the full range representation.\n\n Common definitions:\n - For RGB and luma planes such as Y in YCbCr and I in ICtCp,\n 'E' is the original value in range of 0.0 to 1.0.\n - For chroma planes such as Cb,Cr and Ct,Cp, 'E' is the original\n value in range of -0.5 to 0.5.\n - 'n' is the output bit depth.\n - For additional definitions such as rounding and clipping to valid n\n bit unsigned integer range, please refer to BT.2100 (Table 9)."]
4013pub type AVColorRange = ::std::os::raw::c_uint;
4014pub const AVChromaLocation_AVCHROMA_LOC_UNSPECIFIED: AVChromaLocation = 0;
4015#[doc = "< MPEG-2/4 4:2:0, H.264 default for 4:2:0"]
4016pub const AVChromaLocation_AVCHROMA_LOC_LEFT: AVChromaLocation = 1;
4017#[doc = "< MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0"]
4018pub const AVChromaLocation_AVCHROMA_LOC_CENTER: AVChromaLocation = 2;
4019#[doc = "< ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2"]
4020pub const AVChromaLocation_AVCHROMA_LOC_TOPLEFT: AVChromaLocation = 3;
4021pub const AVChromaLocation_AVCHROMA_LOC_TOP: AVChromaLocation = 4;
4022pub const AVChromaLocation_AVCHROMA_LOC_BOTTOMLEFT: AVChromaLocation = 5;
4023pub const AVChromaLocation_AVCHROMA_LOC_BOTTOM: AVChromaLocation = 6;
4024#[doc = "< Not part of ABI"]
4025pub const AVChromaLocation_AVCHROMA_LOC_NB: AVChromaLocation = 7;
4026#[doc = " Location of chroma samples.\n\n Illustration showing the location of the first (top left) chroma sample of the\n image, the left shows only luma, the right\n shows the location of the chroma sample, the 2 could be imagined to overlay\n each other but are drawn separately due to limitations of ASCII\n\n 1st 2nd 1st 2nd horizontal luma sample positions\n v v v v\n ______ ______\n1st luma line > |X X ... |3 4 X ... X are luma samples,\n | |1 2 1-6 are possible chroma positions\n2nd luma line > |X X ... |5 6 X ... 0 is undefined/unknown position"]
4027pub type AVChromaLocation = ::std::os::raw::c_uint;
4028extern "C" {
4029 #[doc = " Compute the length of an integer list.\n\n @param elsize size in bytes of each list element (only 1, 2, 4 or 8)\n @param term list terminator (usually 0 or -1)\n @param list pointer to the list\n @return length of the list, in elements, not counting the terminator"]
4030 pub fn av_int_list_length_for_size(
4031 elsize: ::std::os::raw::c_uint,
4032 list: *const ::std::os::raw::c_void,
4033 term: u64,
4034 ) -> ::std::os::raw::c_uint;
4035}
4036extern "C" {
4037 #[doc = " Return the fractional representation of the internal time base."]
4038 pub fn av_get_time_base_q() -> AVRational;
4039}
4040extern "C" {
4041 #[doc = " Fill the provided buffer with a string containing a FourCC (four-character\n code) representation.\n\n @param buf a buffer with size in bytes of at least AV_FOURCC_MAX_STRING_SIZE\n @param fourcc the fourcc to represent\n @return the buffer in input"]
4042 pub fn av_fourcc_make_string(
4043 buf: *mut ::std::os::raw::c_char,
4044 fourcc: u32,
4045 ) -> *mut ::std::os::raw::c_char;
4046}
4047pub const AVChannel_AV_CHAN_NONE: AVChannel = -1;
4048pub const AVChannel_AV_CHAN_FRONT_LEFT: AVChannel = 0;
4049pub const AVChannel_AV_CHAN_FRONT_RIGHT: AVChannel = 1;
4050pub const AVChannel_AV_CHAN_FRONT_CENTER: AVChannel = 2;
4051pub const AVChannel_AV_CHAN_LOW_FREQUENCY: AVChannel = 3;
4052pub const AVChannel_AV_CHAN_BACK_LEFT: AVChannel = 4;
4053pub const AVChannel_AV_CHAN_BACK_RIGHT: AVChannel = 5;
4054pub const AVChannel_AV_CHAN_FRONT_LEFT_OF_CENTER: AVChannel = 6;
4055pub const AVChannel_AV_CHAN_FRONT_RIGHT_OF_CENTER: AVChannel = 7;
4056pub const AVChannel_AV_CHAN_BACK_CENTER: AVChannel = 8;
4057pub const AVChannel_AV_CHAN_SIDE_LEFT: AVChannel = 9;
4058pub const AVChannel_AV_CHAN_SIDE_RIGHT: AVChannel = 10;
4059pub const AVChannel_AV_CHAN_TOP_CENTER: AVChannel = 11;
4060pub const AVChannel_AV_CHAN_TOP_FRONT_LEFT: AVChannel = 12;
4061pub const AVChannel_AV_CHAN_TOP_FRONT_CENTER: AVChannel = 13;
4062pub const AVChannel_AV_CHAN_TOP_FRONT_RIGHT: AVChannel = 14;
4063pub const AVChannel_AV_CHAN_TOP_BACK_LEFT: AVChannel = 15;
4064pub const AVChannel_AV_CHAN_TOP_BACK_CENTER: AVChannel = 16;
4065pub const AVChannel_AV_CHAN_TOP_BACK_RIGHT: AVChannel = 17;
4066#[doc = " Stereo downmix."]
4067pub const AVChannel_AV_CHAN_STEREO_LEFT: AVChannel = 29;
4068#[doc = " See above."]
4069pub const AVChannel_AV_CHAN_STEREO_RIGHT: AVChannel = 30;
4070#[doc = " See above."]
4071pub const AVChannel_AV_CHAN_WIDE_LEFT: AVChannel = 31;
4072#[doc = " See above."]
4073pub const AVChannel_AV_CHAN_WIDE_RIGHT: AVChannel = 32;
4074#[doc = " See above."]
4075pub const AVChannel_AV_CHAN_SURROUND_DIRECT_LEFT: AVChannel = 33;
4076#[doc = " See above."]
4077pub const AVChannel_AV_CHAN_SURROUND_DIRECT_RIGHT: AVChannel = 34;
4078#[doc = " See above."]
4079pub const AVChannel_AV_CHAN_LOW_FREQUENCY_2: AVChannel = 35;
4080#[doc = " See above."]
4081pub const AVChannel_AV_CHAN_TOP_SIDE_LEFT: AVChannel = 36;
4082#[doc = " See above."]
4083pub const AVChannel_AV_CHAN_TOP_SIDE_RIGHT: AVChannel = 37;
4084#[doc = " See above."]
4085pub const AVChannel_AV_CHAN_BOTTOM_FRONT_CENTER: AVChannel = 38;
4086#[doc = " See above."]
4087pub const AVChannel_AV_CHAN_BOTTOM_FRONT_LEFT: AVChannel = 39;
4088#[doc = " See above."]
4089pub const AVChannel_AV_CHAN_BOTTOM_FRONT_RIGHT: AVChannel = 40;
4090#[doc = " Channel is empty can be safely skipped."]
4091pub const AVChannel_AV_CHAN_UNUSED: AVChannel = 512;
4092#[doc = " Channel contains data, but its position is unknown."]
4093pub const AVChannel_AV_CHAN_UNKNOWN: AVChannel = 768;
4094#[doc = " Range of channels between AV_CHAN_AMBISONIC_BASE and\n AV_CHAN_AMBISONIC_END represent Ambisonic components using the ACN system.\n\n Given a channel id `<i>` between AV_CHAN_AMBISONIC_BASE and\n AV_CHAN_AMBISONIC_END (inclusive), the ACN index of the channel `<n>` is\n `<n> = <i> - AV_CHAN_AMBISONIC_BASE`.\n\n @note these values are only used for AV_CHANNEL_ORDER_CUSTOM channel\n orderings, the AV_CHANNEL_ORDER_AMBISONIC ordering orders the channels\n implicitly by their position in the stream."]
4095pub const AVChannel_AV_CHAN_AMBISONIC_BASE: AVChannel = 1024;
4096#[doc = " Range of channels between AV_CHAN_AMBISONIC_BASE and\n AV_CHAN_AMBISONIC_END represent Ambisonic components using the ACN system.\n\n Given a channel id `<i>` between AV_CHAN_AMBISONIC_BASE and\n AV_CHAN_AMBISONIC_END (inclusive), the ACN index of the channel `<n>` is\n `<n> = <i> - AV_CHAN_AMBISONIC_BASE`.\n\n @note these values are only used for AV_CHANNEL_ORDER_CUSTOM channel\n orderings, the AV_CHANNEL_ORDER_AMBISONIC ordering orders the channels\n implicitly by their position in the stream."]
4097pub const AVChannel_AV_CHAN_AMBISONIC_END: AVChannel = 2047;
4098#[doc = " @defgroup lavu_audio_channels Audio channels\n @ingroup lavu_audio\n\n Audio channel layout utility functions\n\n @{"]
4099pub type AVChannel = ::std::os::raw::c_int;
4100#[doc = " Only the channel count is specified, without any further information\n about the channel order."]
4101pub const AVChannelOrder_AV_CHANNEL_ORDER_UNSPEC: AVChannelOrder = 0;
4102#[doc = " The native channel order, i.e. the channels are in the same order in\n which they are defined in the AVChannel enum. This supports up to 63\n different channels."]
4103pub const AVChannelOrder_AV_CHANNEL_ORDER_NATIVE: AVChannelOrder = 1;
4104#[doc = " The channel order does not correspond to any other predefined order and\n is stored as an explicit map. For example, this could be used to support\n layouts with 64 or more channels, or with empty/skipped (AV_CHAN_UNUSED)\n channels at arbitrary positions."]
4105pub const AVChannelOrder_AV_CHANNEL_ORDER_CUSTOM: AVChannelOrder = 2;
4106#[doc = " The audio is represented as the decomposition of the sound field into\n spherical harmonics. Each channel corresponds to a single expansion\n component. Channels are ordered according to ACN (Ambisonic Channel\n Number).\n\n The channel with the index n in the stream contains the spherical\n harmonic of degree l and order m given by\n @code{.unparsed}\n l = floor(sqrt(n)),\n m = n - l * (l + 1).\n @endcode\n\n Conversely given a spherical harmonic of degree l and order m, the\n corresponding channel index n is given by\n @code{.unparsed}\n n = l * (l + 1) + m.\n @endcode\n\n Normalization is assumed to be SN3D (Schmidt Semi-Normalization)\n as defined in AmbiX format $ 2.1."]
4107pub const AVChannelOrder_AV_CHANNEL_ORDER_AMBISONIC: AVChannelOrder = 3;
4108#[doc = " Number of channel orders, not part of ABI/API"]
4109pub const AVChannelOrder_FF_CHANNEL_ORDER_NB: AVChannelOrder = 4;
4110pub type AVChannelOrder = ::std::os::raw::c_uint;
4111pub const AVMatrixEncoding_AV_MATRIX_ENCODING_NONE: AVMatrixEncoding = 0;
4112pub const AVMatrixEncoding_AV_MATRIX_ENCODING_DOLBY: AVMatrixEncoding = 1;
4113pub const AVMatrixEncoding_AV_MATRIX_ENCODING_DPLII: AVMatrixEncoding = 2;
4114pub const AVMatrixEncoding_AV_MATRIX_ENCODING_DPLIIX: AVMatrixEncoding = 3;
4115pub const AVMatrixEncoding_AV_MATRIX_ENCODING_DPLIIZ: AVMatrixEncoding = 4;
4116pub const AVMatrixEncoding_AV_MATRIX_ENCODING_DOLBYEX: AVMatrixEncoding = 5;
4117pub const AVMatrixEncoding_AV_MATRIX_ENCODING_DOLBYHEADPHONE: AVMatrixEncoding = 6;
4118pub const AVMatrixEncoding_AV_MATRIX_ENCODING_NB: AVMatrixEncoding = 7;
4119pub type AVMatrixEncoding = ::std::os::raw::c_uint;
4120#[doc = " An AVChannelCustom defines a single channel within a custom order layout\n\n Unlike most structures in FFmpeg, sizeof(AVChannelCustom) is a part of the\n public ABI.\n\n No new fields may be added to it without a major version bump."]
4121#[repr(C)]
4122#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4123pub struct AVChannelCustom {
4124 pub id: AVChannel,
4125 pub name: [::std::os::raw::c_char; 16usize],
4126 pub opaque: *mut ::std::os::raw::c_void,
4127}
4128impl Default for AVChannelCustom {
4129 fn default() -> Self {
4130 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4131 unsafe {
4132 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4133 s.assume_init()
4134 }
4135 }
4136}
4137#[doc = " An AVChannelLayout holds information about the channel layout of audio data.\n\n A channel layout here is defined as a set of channels ordered in a specific\n way (unless the channel order is AV_CHANNEL_ORDER_UNSPEC, in which case an\n AVChannelLayout carries only the channel count).\n All orders may be treated as if they were AV_CHANNEL_ORDER_UNSPEC by\n ignoring everything but the channel count, as long as av_channel_layout_check()\n considers they are valid.\n\n Unlike most structures in FFmpeg, sizeof(AVChannelLayout) is a part of the\n public ABI and may be used by the caller. E.g. it may be allocated on stack\n or embedded in caller-defined structs.\n\n AVChannelLayout can be initialized as follows:\n - default initialization with {0}, followed by setting all used fields\n correctly;\n - by assigning one of the predefined AV_CHANNEL_LAYOUT_* initializers;\n - with a constructor function, such as av_channel_layout_default(),\n av_channel_layout_from_mask() or av_channel_layout_from_string().\n\n The channel layout must be unitialized with av_channel_layout_uninit()\n\n Copying an AVChannelLayout via assigning is forbidden,\n av_channel_layout_copy() must be used instead (and its return value should\n be checked)\n\n No new fields may be added to it without a major version bump, except for\n new elements of the union fitting in sizeof(uint64_t)."]
4138#[repr(C)]
4139#[derive(Copy, Clone)]
4140pub struct AVChannelLayout {
4141 #[doc = " Channel order used in this layout.\n This is a mandatory field."]
4142 pub order: AVChannelOrder,
4143 #[doc = " Number of channels in this layout. Mandatory field."]
4144 pub nb_channels: ::std::os::raw::c_int,
4145 pub u: AVChannelLayout__bindgen_ty_1,
4146 #[doc = " For some private data of the user."]
4147 pub opaque: *mut ::std::os::raw::c_void,
4148}
4149#[doc = " Details about which channels are present in this layout.\n For AV_CHANNEL_ORDER_UNSPEC, this field is undefined and must not be\n used."]
4150#[repr(C)]
4151#[derive(Copy, Clone)]
4152pub union AVChannelLayout__bindgen_ty_1 {
4153 #[doc = " This member must be used for AV_CHANNEL_ORDER_NATIVE, and may be used\n for AV_CHANNEL_ORDER_AMBISONIC to signal non-diegetic channels.\n It is a bitmask, where the position of each set bit means that the\n AVChannel with the corresponding value is present.\n\n I.e. when (mask & (1 << AV_CHAN_FOO)) is non-zero, then AV_CHAN_FOO\n is present in the layout. Otherwise it is not present.\n\n @note when a channel layout using a bitmask is constructed or\n modified manually (i.e. not using any of the av_channel_layout_*\n functions), the code doing it must ensure that the number of set bits\n is equal to nb_channels."]
4154 pub mask: u64,
4155 #[doc = " This member must be used when the channel order is\n AV_CHANNEL_ORDER_CUSTOM. It is a nb_channels-sized array, with each\n element signalling the presence of the AVChannel with the\n corresponding value in map[i].id.\n\n I.e. when map[i].id is equal to AV_CHAN_FOO, then AV_CH_FOO is the\n i-th channel in the audio data.\n\n When map[i].id is in the range between AV_CHAN_AMBISONIC_BASE and\n AV_CHAN_AMBISONIC_END (inclusive), the channel contains an ambisonic\n component with ACN index (as defined above)\n n = map[i].id - AV_CHAN_AMBISONIC_BASE.\n\n map[i].name may be filled with a 0-terminated string, in which case\n it will be used for the purpose of identifying the channel with the\n convenience functions below. Otherise it must be zeroed."]
4156 pub map: *mut AVChannelCustom,
4157}
4158impl Default for AVChannelLayout__bindgen_ty_1 {
4159 fn default() -> Self {
4160 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4161 unsafe {
4162 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4163 s.assume_init()
4164 }
4165 }
4166}
4167impl Default for AVChannelLayout {
4168 fn default() -> Self {
4169 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4170 unsafe {
4171 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4172 s.assume_init()
4173 }
4174 }
4175}
4176#[doc = " @}"]
4177#[repr(C)]
4178#[derive(Debug, Copy, Clone)]
4179pub struct AVBPrint {
4180 _unused: [u8; 0],
4181}
4182extern "C" {
4183 #[doc = " Get a human readable string in an abbreviated form describing a given channel.\n This is the inverse function of @ref av_channel_from_string().\n\n @param buf pre-allocated buffer where to put the generated string\n @param buf_size size in bytes of the buffer.\n @param channel the AVChannel whose name to get\n @return amount of bytes needed to hold the output string, or a negative AVERROR\n on failure. If the returned value is bigger than buf_size, then the\n string was truncated."]
4184 pub fn av_channel_name(
4185 buf: *mut ::std::os::raw::c_char,
4186 buf_size: usize,
4187 channel: AVChannel,
4188 ) -> ::std::os::raw::c_int;
4189}
4190extern "C" {
4191 #[doc = " bprint variant of av_channel_name().\n\n @note the string will be appended to the bprint buffer."]
4192 pub fn av_channel_name_bprint(bp: *mut AVBPrint, channel_id: AVChannel);
4193}
4194extern "C" {
4195 #[doc = " Get a human readable string describing a given channel.\n\n @param buf pre-allocated buffer where to put the generated string\n @param buf_size size in bytes of the buffer.\n @param channel the AVChannel whose description to get\n @return amount of bytes needed to hold the output string, or a negative AVERROR\n on failure. If the returned value is bigger than buf_size, then the\n string was truncated."]
4196 pub fn av_channel_description(
4197 buf: *mut ::std::os::raw::c_char,
4198 buf_size: usize,
4199 channel: AVChannel,
4200 ) -> ::std::os::raw::c_int;
4201}
4202extern "C" {
4203 #[doc = " bprint variant of av_channel_description().\n\n @note the string will be appended to the bprint buffer."]
4204 pub fn av_channel_description_bprint(bp: *mut AVBPrint, channel_id: AVChannel);
4205}
4206extern "C" {
4207 #[doc = " This is the inverse function of @ref av_channel_name().\n\n @return the channel with the given name\n AV_CHAN_NONE when name does not identify a known channel"]
4208 pub fn av_channel_from_string(name: *const ::std::os::raw::c_char) -> AVChannel;
4209}
4210extern "C" {
4211 #[doc = " Initialize a custom channel layout with the specified number of channels.\n The channel map will be allocated and the designation of all channels will\n be set to AV_CHAN_UNKNOWN.\n\n This is only a convenience helper function, a custom channel layout can also\n be constructed without using this.\n\n @param channel_layout the layout structure to be initialized\n @param nb_channels the number of channels\n\n @return 0 on success\n AVERROR(EINVAL) if the number of channels <= 0\n AVERROR(ENOMEM) if the channel map could not be allocated"]
4212 pub fn av_channel_layout_custom_init(
4213 channel_layout: *mut AVChannelLayout,
4214 nb_channels: ::std::os::raw::c_int,
4215 ) -> ::std::os::raw::c_int;
4216}
4217extern "C" {
4218 #[doc = " Initialize a native channel layout from a bitmask indicating which channels\n are present.\n\n @param channel_layout the layout structure to be initialized\n @param mask bitmask describing the channel layout\n\n @return 0 on success\n AVERROR(EINVAL) for invalid mask values"]
4219 pub fn av_channel_layout_from_mask(
4220 channel_layout: *mut AVChannelLayout,
4221 mask: u64,
4222 ) -> ::std::os::raw::c_int;
4223}
4224extern "C" {
4225 #[doc = " Initialize a channel layout from a given string description.\n The input string can be represented by:\n - the formal channel layout name (returned by av_channel_layout_describe())\n - single or multiple channel names (returned by av_channel_name(), eg. \"FL\",\n or concatenated with \"+\", each optionally containing a custom name after\n a \"@\", eg. \"FL@Left+FR@Right+LFE\")\n - a decimal or hexadecimal value of a native channel layout (eg. \"4\" or \"0x4\")\n - the number of channels with default layout (eg. \"4c\")\n - the number of unordered channels (eg. \"4C\" or \"4 channels\")\n - the ambisonic order followed by optional non-diegetic channels (eg.\n \"ambisonic 2+stereo\")\n On error, the channel layout will remain uninitialized, but not necessarily\n untouched.\n\n @param channel_layout uninitialized channel layout for the result\n @param str string describing the channel layout\n @return 0 on success parsing the channel layout\n AVERROR(EINVAL) if an invalid channel layout string was provided\n AVERROR(ENOMEM) if there was not enough memory"]
4226 pub fn av_channel_layout_from_string(
4227 channel_layout: *mut AVChannelLayout,
4228 str_: *const ::std::os::raw::c_char,
4229 ) -> ::std::os::raw::c_int;
4230}
4231extern "C" {
4232 #[doc = " Get the default channel layout for a given number of channels.\n\n @param ch_layout the layout structure to be initialized\n @param nb_channels number of channels"]
4233 pub fn av_channel_layout_default(
4234 ch_layout: *mut AVChannelLayout,
4235 nb_channels: ::std::os::raw::c_int,
4236 );
4237}
4238extern "C" {
4239 #[doc = " Iterate over all standard channel layouts.\n\n @param opaque a pointer where libavutil will store the iteration state. Must\n point to NULL to start the iteration.\n\n @return the standard channel layout or NULL when the iteration is\n finished"]
4240 pub fn av_channel_layout_standard(
4241 opaque: *mut *mut ::std::os::raw::c_void,
4242 ) -> *const AVChannelLayout;
4243}
4244extern "C" {
4245 #[doc = " Free any allocated data in the channel layout and reset the channel\n count to 0.\n\n @param channel_layout the layout structure to be uninitialized"]
4246 pub fn av_channel_layout_uninit(channel_layout: *mut AVChannelLayout);
4247}
4248extern "C" {
4249 #[doc = " Make a copy of a channel layout. This differs from just assigning src to dst\n in that it allocates and copies the map for AV_CHANNEL_ORDER_CUSTOM.\n\n @note the destination channel_layout will be always uninitialized before copy.\n\n @param dst destination channel layout\n @param src source channel layout\n @return 0 on success, a negative AVERROR on error."]
4250 pub fn av_channel_layout_copy(
4251 dst: *mut AVChannelLayout,
4252 src: *const AVChannelLayout,
4253 ) -> ::std::os::raw::c_int;
4254}
4255extern "C" {
4256 #[doc = " Get a human-readable string describing the channel layout properties.\n The string will be in the same format that is accepted by\n @ref av_channel_layout_from_string(), allowing to rebuild the same\n channel layout, except for opaque pointers.\n\n @param channel_layout channel layout to be described\n @param buf pre-allocated buffer where to put the generated string\n @param buf_size size in bytes of the buffer.\n @return amount of bytes needed to hold the output string, or a negative AVERROR\n on failure. If the returned value is bigger than buf_size, then the\n string was truncated."]
4257 pub fn av_channel_layout_describe(
4258 channel_layout: *const AVChannelLayout,
4259 buf: *mut ::std::os::raw::c_char,
4260 buf_size: usize,
4261 ) -> ::std::os::raw::c_int;
4262}
4263extern "C" {
4264 #[doc = " bprint variant of av_channel_layout_describe().\n\n @note the string will be appended to the bprint buffer.\n @return 0 on success, or a negative AVERROR value on failure."]
4265 pub fn av_channel_layout_describe_bprint(
4266 channel_layout: *const AVChannelLayout,
4267 bp: *mut AVBPrint,
4268 ) -> ::std::os::raw::c_int;
4269}
4270extern "C" {
4271 #[doc = " Get the channel with the given index in a channel layout.\n\n @param channel_layout input channel layout\n @param idx index of the channel\n @return channel with the index idx in channel_layout on success or\n AV_CHAN_NONE on failure (if idx is not valid or the channel order is\n unspecified)"]
4272 pub fn av_channel_layout_channel_from_index(
4273 channel_layout: *const AVChannelLayout,
4274 idx: ::std::os::raw::c_uint,
4275 ) -> AVChannel;
4276}
4277extern "C" {
4278 #[doc = " Get the index of a given channel in a channel layout. In case multiple\n channels are found, only the first match will be returned.\n\n @param channel_layout input channel layout\n @param channel the channel whose index to obtain\n @return index of channel in channel_layout on success or a negative number if\n channel is not present in channel_layout."]
4279 pub fn av_channel_layout_index_from_channel(
4280 channel_layout: *const AVChannelLayout,
4281 channel: AVChannel,
4282 ) -> ::std::os::raw::c_int;
4283}
4284extern "C" {
4285 #[doc = " Get the index in a channel layout of a channel described by the given string.\n In case multiple channels are found, only the first match will be returned.\n\n This function accepts channel names in the same format as\n @ref av_channel_from_string().\n\n @param channel_layout input channel layout\n @param name string describing the channel whose index to obtain\n @return a channel index described by the given string, or a negative AVERROR\n value."]
4286 pub fn av_channel_layout_index_from_string(
4287 channel_layout: *const AVChannelLayout,
4288 name: *const ::std::os::raw::c_char,
4289 ) -> ::std::os::raw::c_int;
4290}
4291extern "C" {
4292 #[doc = " Get a channel described by the given string.\n\n This function accepts channel names in the same format as\n @ref av_channel_from_string().\n\n @param channel_layout input channel layout\n @param name string describing the channel to obtain\n @return a channel described by the given string in channel_layout on success\n or AV_CHAN_NONE on failure (if the string is not valid or the channel\n order is unspecified)"]
4293 pub fn av_channel_layout_channel_from_string(
4294 channel_layout: *const AVChannelLayout,
4295 name: *const ::std::os::raw::c_char,
4296 ) -> AVChannel;
4297}
4298extern "C" {
4299 #[doc = " Find out what channels from a given set are present in a channel layout,\n without regard for their positions.\n\n @param channel_layout input channel layout\n @param mask a combination of AV_CH_* representing a set of channels\n @return a bitfield representing all the channels from mask that are present\n in channel_layout"]
4300 pub fn av_channel_layout_subset(channel_layout: *const AVChannelLayout, mask: u64) -> u64;
4301}
4302extern "C" {
4303 #[doc = " Check whether a channel layout is valid, i.e. can possibly describe audio\n data.\n\n @param channel_layout input channel layout\n @return 1 if channel_layout is valid, 0 otherwise."]
4304 pub fn av_channel_layout_check(channel_layout: *const AVChannelLayout)
4305 -> ::std::os::raw::c_int;
4306}
4307extern "C" {
4308 #[doc = " Check whether two channel layouts are semantically the same, i.e. the same\n channels are present on the same positions in both.\n\n If one of the channel layouts is AV_CHANNEL_ORDER_UNSPEC, while the other is\n not, they are considered to be unequal. If both are AV_CHANNEL_ORDER_UNSPEC,\n they are considered equal iff the channel counts are the same in both.\n\n @param chl input channel layout\n @param chl1 input channel layout\n @return 0 if chl and chl1 are equal, 1 if they are not equal. A negative\n AVERROR code if one or both are invalid."]
4309 pub fn av_channel_layout_compare(
4310 chl: *const AVChannelLayout,
4311 chl1: *const AVChannelLayout,
4312 ) -> ::std::os::raw::c_int;
4313}
4314extern "C" {
4315 #[doc = " Change the AVChannelOrder of a channel layout.\n\n Change of AVChannelOrder can be either lossless or lossy. In case of a\n lossless conversion all the channel designations and the associated channel\n names (if any) are kept. On a lossy conversion the channel names and channel\n designations might be lost depending on the capabilities of the desired\n AVChannelOrder. Note that some conversions are simply not possible in which\n case this function returns AVERROR(ENOSYS).\n\n The following conversions are supported:\n\n Any -> Custom : Always possible, always lossless.\n Any -> Unspecified: Always possible, lossless if channel designations\n are all unknown and channel names are not used, lossy otherwise.\n Custom -> Ambisonic : Possible if it contains ambisonic channels with\n optional non-diegetic channels in the end. Lossy if the channels have\n custom names, lossless otherwise.\n Custom -> Native : Possible if it contains native channels in native\n order. Lossy if the channels have custom names, lossless otherwise.\n\n On error this function keeps the original channel layout untouched.\n\n @param channel_layout channel layout which will be changed\n @param order the desired channel layout order\n @param flags a combination of AV_CHANNEL_LAYOUT_RETYPE_FLAG_* constants\n @return 0 if the conversion was successful and lossless or if the channel\n layout was already in the desired order\n >0 if the conversion was successful but lossy\n AVERROR(ENOSYS) if the conversion was not possible (or would be\n lossy and AV_CHANNEL_LAYOUT_RETYPE_FLAG_LOSSLESS was specified)\n AVERROR(EINVAL), AVERROR(ENOMEM) on error"]
4316 pub fn av_channel_layout_retype(
4317 channel_layout: *mut AVChannelLayout,
4318 order: AVChannelOrder,
4319 flags: ::std::os::raw::c_int,
4320 ) -> ::std::os::raw::c_int;
4321}
4322pub const AVSampleFormat_AV_SAMPLE_FMT_NONE: AVSampleFormat = -1;
4323#[doc = "< unsigned 8 bits"]
4324pub const AVSampleFormat_AV_SAMPLE_FMT_U8: AVSampleFormat = 0;
4325#[doc = "< signed 16 bits"]
4326pub const AVSampleFormat_AV_SAMPLE_FMT_S16: AVSampleFormat = 1;
4327#[doc = "< signed 32 bits"]
4328pub const AVSampleFormat_AV_SAMPLE_FMT_S32: AVSampleFormat = 2;
4329#[doc = "< float"]
4330pub const AVSampleFormat_AV_SAMPLE_FMT_FLT: AVSampleFormat = 3;
4331#[doc = "< double"]
4332pub const AVSampleFormat_AV_SAMPLE_FMT_DBL: AVSampleFormat = 4;
4333#[doc = "< unsigned 8 bits, planar"]
4334pub const AVSampleFormat_AV_SAMPLE_FMT_U8P: AVSampleFormat = 5;
4335#[doc = "< signed 16 bits, planar"]
4336pub const AVSampleFormat_AV_SAMPLE_FMT_S16P: AVSampleFormat = 6;
4337#[doc = "< signed 32 bits, planar"]
4338pub const AVSampleFormat_AV_SAMPLE_FMT_S32P: AVSampleFormat = 7;
4339#[doc = "< float, planar"]
4340pub const AVSampleFormat_AV_SAMPLE_FMT_FLTP: AVSampleFormat = 8;
4341#[doc = "< double, planar"]
4342pub const AVSampleFormat_AV_SAMPLE_FMT_DBLP: AVSampleFormat = 9;
4343#[doc = "< signed 64 bits"]
4344pub const AVSampleFormat_AV_SAMPLE_FMT_S64: AVSampleFormat = 10;
4345#[doc = "< signed 64 bits, planar"]
4346pub const AVSampleFormat_AV_SAMPLE_FMT_S64P: AVSampleFormat = 11;
4347#[doc = "< Number of sample formats. DO NOT USE if linking dynamically"]
4348pub const AVSampleFormat_AV_SAMPLE_FMT_NB: AVSampleFormat = 12;
4349#[doc = " Audio sample formats\n\n - The data described by the sample format is always in native-endian order.\n Sample values can be expressed by native C types, hence the lack of a signed\n 24-bit sample format even though it is a common raw audio data format.\n\n - The floating-point formats are based on full volume being in the range\n [-1.0, 1.0]. Any values outside this range are beyond full volume level.\n\n - The data layout as used in av_samples_fill_arrays() and elsewhere in FFmpeg\n (such as AVFrame in libavcodec) is as follows:\n\n @par\n For planar sample formats, each audio channel is in a separate data plane,\n and linesize is the buffer size, in bytes, for a single plane. All data\n planes must be the same size. For packed sample formats, only the first data\n plane is used, and samples for each channel are interleaved. In this case,\n linesize is the buffer size, in bytes, for the 1 plane.\n"]
4350pub type AVSampleFormat = ::std::os::raw::c_int;
4351extern "C" {
4352 #[doc = " Return the name of sample_fmt, or NULL if sample_fmt is not\n recognized."]
4353 pub fn av_get_sample_fmt_name(sample_fmt: AVSampleFormat) -> *const ::std::os::raw::c_char;
4354}
4355extern "C" {
4356 #[doc = " Return a sample format corresponding to name, or AV_SAMPLE_FMT_NONE\n on error."]
4357 pub fn av_get_sample_fmt(name: *const ::std::os::raw::c_char) -> AVSampleFormat;
4358}
4359extern "C" {
4360 #[doc = " Return the planar<->packed alternative form of the given sample format, or\n AV_SAMPLE_FMT_NONE on error. If the passed sample_fmt is already in the\n requested planar/packed format, the format returned is the same as the\n input."]
4361 pub fn av_get_alt_sample_fmt(
4362 sample_fmt: AVSampleFormat,
4363 planar: ::std::os::raw::c_int,
4364 ) -> AVSampleFormat;
4365}
4366extern "C" {
4367 #[doc = " Get the packed alternative form of the given sample format.\n\n If the passed sample_fmt is already in packed format, the format returned is\n the same as the input.\n\n @return the packed alternative form of the given sample format or\nAV_SAMPLE_FMT_NONE on error."]
4368 pub fn av_get_packed_sample_fmt(sample_fmt: AVSampleFormat) -> AVSampleFormat;
4369}
4370extern "C" {
4371 #[doc = " Get the planar alternative form of the given sample format.\n\n If the passed sample_fmt is already in planar format, the format returned is\n the same as the input.\n\n @return the planar alternative form of the given sample format or\nAV_SAMPLE_FMT_NONE on error."]
4372 pub fn av_get_planar_sample_fmt(sample_fmt: AVSampleFormat) -> AVSampleFormat;
4373}
4374extern "C" {
4375 #[doc = " Generate a string corresponding to the sample format with\n sample_fmt, or a header if sample_fmt is negative.\n\n @param buf the buffer where to write the string\n @param buf_size the size of buf\n @param sample_fmt the number of the sample format to print the\n corresponding info string, or a negative value to print the\n corresponding header.\n @return the pointer to the filled buffer or NULL if sample_fmt is\n unknown or in case of other errors"]
4376 pub fn av_get_sample_fmt_string(
4377 buf: *mut ::std::os::raw::c_char,
4378 buf_size: ::std::os::raw::c_int,
4379 sample_fmt: AVSampleFormat,
4380 ) -> *mut ::std::os::raw::c_char;
4381}
4382extern "C" {
4383 #[doc = " Return number of bytes per sample.\n\n @param sample_fmt the sample format\n @return number of bytes per sample or zero if unknown for the given\n sample format"]
4384 pub fn av_get_bytes_per_sample(sample_fmt: AVSampleFormat) -> ::std::os::raw::c_int;
4385}
4386extern "C" {
4387 #[doc = " Check if the sample format is planar.\n\n @param sample_fmt the sample format to inspect\n @return 1 if the sample format is planar, 0 if it is interleaved"]
4388 pub fn av_sample_fmt_is_planar(sample_fmt: AVSampleFormat) -> ::std::os::raw::c_int;
4389}
4390extern "C" {
4391 #[doc = " Get the required buffer size for the given audio parameters.\n\n @param[out] linesize calculated linesize, may be NULL\n @param nb_channels the number of channels\n @param nb_samples the number of samples in a single channel\n @param sample_fmt the sample format\n @param align buffer size alignment (0 = default, 1 = no alignment)\n @return required buffer size, or negative error code on failure"]
4392 pub fn av_samples_get_buffer_size(
4393 linesize: *mut ::std::os::raw::c_int,
4394 nb_channels: ::std::os::raw::c_int,
4395 nb_samples: ::std::os::raw::c_int,
4396 sample_fmt: AVSampleFormat,
4397 align: ::std::os::raw::c_int,
4398 ) -> ::std::os::raw::c_int;
4399}
4400extern "C" {
4401 #[doc = " Fill plane data pointers and linesize for samples with sample\n format sample_fmt.\n\n The audio_data array is filled with the pointers to the samples data planes:\n for planar, set the start point of each channel's data within the buffer,\n for packed, set the start point of the entire buffer only.\n\n The value pointed to by linesize is set to the aligned size of each\n channel's data buffer for planar layout, or to the aligned size of the\n buffer for all channels for packed layout.\n\n The buffer in buf must be big enough to contain all the samples\n (use av_samples_get_buffer_size() to compute its minimum size),\n otherwise the audio_data pointers will point to invalid data.\n\n @see enum AVSampleFormat\n The documentation for AVSampleFormat describes the data layout.\n\n @param[out] audio_data array to be filled with the pointer for each channel\n @param[out] linesize calculated linesize, may be NULL\n @param buf the pointer to a buffer containing the samples\n @param nb_channels the number of channels\n @param nb_samples the number of samples in a single channel\n @param sample_fmt the sample format\n @param align buffer size alignment (0 = default, 1 = no alignment)\n @return minimum size in bytes required for the buffer on success,\n or a negative error code on failure"]
4402 pub fn av_samples_fill_arrays(
4403 audio_data: *mut *mut u8,
4404 linesize: *mut ::std::os::raw::c_int,
4405 buf: *const u8,
4406 nb_channels: ::std::os::raw::c_int,
4407 nb_samples: ::std::os::raw::c_int,
4408 sample_fmt: AVSampleFormat,
4409 align: ::std::os::raw::c_int,
4410 ) -> ::std::os::raw::c_int;
4411}
4412extern "C" {
4413 #[doc = " Allocate a samples buffer for nb_samples samples, and fill data pointers and\n linesize accordingly.\n The allocated samples buffer can be freed by using av_freep(&audio_data[0])\n Allocated data will be initialized to silence.\n\n @see enum AVSampleFormat\n The documentation for AVSampleFormat describes the data layout.\n\n @param[out] audio_data array to be filled with the pointer for each channel\n @param[out] linesize aligned size for audio buffer(s), may be NULL\n @param nb_channels number of audio channels\n @param nb_samples number of samples per channel\n @param sample_fmt the sample format\n @param align buffer size alignment (0 = default, 1 = no alignment)\n @return >=0 on success or a negative error code on failure\n @todo return the size of the allocated buffer in case of success at the next bump\n @see av_samples_fill_arrays()\n @see av_samples_alloc_array_and_samples()"]
4414 pub fn av_samples_alloc(
4415 audio_data: *mut *mut u8,
4416 linesize: *mut ::std::os::raw::c_int,
4417 nb_channels: ::std::os::raw::c_int,
4418 nb_samples: ::std::os::raw::c_int,
4419 sample_fmt: AVSampleFormat,
4420 align: ::std::os::raw::c_int,
4421 ) -> ::std::os::raw::c_int;
4422}
4423extern "C" {
4424 #[doc = " Allocate a data pointers array, samples buffer for nb_samples\n samples, and fill data pointers and linesize accordingly.\n\n This is the same as av_samples_alloc(), but also allocates the data\n pointers array.\n\n @see av_samples_alloc()"]
4425 pub fn av_samples_alloc_array_and_samples(
4426 audio_data: *mut *mut *mut u8,
4427 linesize: *mut ::std::os::raw::c_int,
4428 nb_channels: ::std::os::raw::c_int,
4429 nb_samples: ::std::os::raw::c_int,
4430 sample_fmt: AVSampleFormat,
4431 align: ::std::os::raw::c_int,
4432 ) -> ::std::os::raw::c_int;
4433}
4434extern "C" {
4435 #[doc = " Copy samples from src to dst.\n\n @param dst destination array of pointers to data planes\n @param src source array of pointers to data planes\n @param dst_offset offset in samples at which the data will be written to dst\n @param src_offset offset in samples at which the data will be read from src\n @param nb_samples number of samples to be copied\n @param nb_channels number of audio channels\n @param sample_fmt audio sample format"]
4436 pub fn av_samples_copy(
4437 dst: *const *mut u8,
4438 src: *const *mut u8,
4439 dst_offset: ::std::os::raw::c_int,
4440 src_offset: ::std::os::raw::c_int,
4441 nb_samples: ::std::os::raw::c_int,
4442 nb_channels: ::std::os::raw::c_int,
4443 sample_fmt: AVSampleFormat,
4444 ) -> ::std::os::raw::c_int;
4445}
4446extern "C" {
4447 #[doc = " Fill an audio buffer with silence.\n\n @param audio_data array of pointers to data planes\n @param offset offset in samples at which to start filling\n @param nb_samples number of samples to fill\n @param nb_channels number of audio channels\n @param sample_fmt audio sample format"]
4448 pub fn av_samples_set_silence(
4449 audio_data: *const *mut u8,
4450 offset: ::std::os::raw::c_int,
4451 nb_samples: ::std::os::raw::c_int,
4452 nb_channels: ::std::os::raw::c_int,
4453 sample_fmt: AVSampleFormat,
4454 ) -> ::std::os::raw::c_int;
4455}
4456pub const AVCodecID_AV_CODEC_ID_NONE: AVCodecID = 0;
4457pub const AVCodecID_AV_CODEC_ID_MPEG1VIDEO: AVCodecID = 1;
4458#[doc = "< preferred ID for MPEG-1/2 video decoding"]
4459pub const AVCodecID_AV_CODEC_ID_MPEG2VIDEO: AVCodecID = 2;
4460pub const AVCodecID_AV_CODEC_ID_H261: AVCodecID = 3;
4461pub const AVCodecID_AV_CODEC_ID_H263: AVCodecID = 4;
4462pub const AVCodecID_AV_CODEC_ID_RV10: AVCodecID = 5;
4463pub const AVCodecID_AV_CODEC_ID_RV20: AVCodecID = 6;
4464pub const AVCodecID_AV_CODEC_ID_MJPEG: AVCodecID = 7;
4465pub const AVCodecID_AV_CODEC_ID_MJPEGB: AVCodecID = 8;
4466pub const AVCodecID_AV_CODEC_ID_LJPEG: AVCodecID = 9;
4467pub const AVCodecID_AV_CODEC_ID_SP5X: AVCodecID = 10;
4468pub const AVCodecID_AV_CODEC_ID_JPEGLS: AVCodecID = 11;
4469pub const AVCodecID_AV_CODEC_ID_MPEG4: AVCodecID = 12;
4470pub const AVCodecID_AV_CODEC_ID_RAWVIDEO: AVCodecID = 13;
4471pub const AVCodecID_AV_CODEC_ID_MSMPEG4V1: AVCodecID = 14;
4472pub const AVCodecID_AV_CODEC_ID_MSMPEG4V2: AVCodecID = 15;
4473pub const AVCodecID_AV_CODEC_ID_MSMPEG4V3: AVCodecID = 16;
4474pub const AVCodecID_AV_CODEC_ID_WMV1: AVCodecID = 17;
4475pub const AVCodecID_AV_CODEC_ID_WMV2: AVCodecID = 18;
4476pub const AVCodecID_AV_CODEC_ID_H263P: AVCodecID = 19;
4477pub const AVCodecID_AV_CODEC_ID_H263I: AVCodecID = 20;
4478pub const AVCodecID_AV_CODEC_ID_FLV1: AVCodecID = 21;
4479pub const AVCodecID_AV_CODEC_ID_SVQ1: AVCodecID = 22;
4480pub const AVCodecID_AV_CODEC_ID_SVQ3: AVCodecID = 23;
4481pub const AVCodecID_AV_CODEC_ID_DVVIDEO: AVCodecID = 24;
4482pub const AVCodecID_AV_CODEC_ID_HUFFYUV: AVCodecID = 25;
4483pub const AVCodecID_AV_CODEC_ID_CYUV: AVCodecID = 26;
4484pub const AVCodecID_AV_CODEC_ID_H264: AVCodecID = 27;
4485pub const AVCodecID_AV_CODEC_ID_INDEO3: AVCodecID = 28;
4486pub const AVCodecID_AV_CODEC_ID_VP3: AVCodecID = 29;
4487pub const AVCodecID_AV_CODEC_ID_THEORA: AVCodecID = 30;
4488pub const AVCodecID_AV_CODEC_ID_ASV1: AVCodecID = 31;
4489pub const AVCodecID_AV_CODEC_ID_ASV2: AVCodecID = 32;
4490pub const AVCodecID_AV_CODEC_ID_FFV1: AVCodecID = 33;
4491pub const AVCodecID_AV_CODEC_ID_4XM: AVCodecID = 34;
4492pub const AVCodecID_AV_CODEC_ID_VCR1: AVCodecID = 35;
4493pub const AVCodecID_AV_CODEC_ID_CLJR: AVCodecID = 36;
4494pub const AVCodecID_AV_CODEC_ID_MDEC: AVCodecID = 37;
4495pub const AVCodecID_AV_CODEC_ID_ROQ: AVCodecID = 38;
4496pub const AVCodecID_AV_CODEC_ID_INTERPLAY_VIDEO: AVCodecID = 39;
4497pub const AVCodecID_AV_CODEC_ID_XAN_WC3: AVCodecID = 40;
4498pub const AVCodecID_AV_CODEC_ID_XAN_WC4: AVCodecID = 41;
4499pub const AVCodecID_AV_CODEC_ID_RPZA: AVCodecID = 42;
4500pub const AVCodecID_AV_CODEC_ID_CINEPAK: AVCodecID = 43;
4501pub const AVCodecID_AV_CODEC_ID_WS_VQA: AVCodecID = 44;
4502pub const AVCodecID_AV_CODEC_ID_MSRLE: AVCodecID = 45;
4503pub const AVCodecID_AV_CODEC_ID_MSVIDEO1: AVCodecID = 46;
4504pub const AVCodecID_AV_CODEC_ID_IDCIN: AVCodecID = 47;
4505pub const AVCodecID_AV_CODEC_ID_8BPS: AVCodecID = 48;
4506pub const AVCodecID_AV_CODEC_ID_SMC: AVCodecID = 49;
4507pub const AVCodecID_AV_CODEC_ID_FLIC: AVCodecID = 50;
4508pub const AVCodecID_AV_CODEC_ID_TRUEMOTION1: AVCodecID = 51;
4509pub const AVCodecID_AV_CODEC_ID_VMDVIDEO: AVCodecID = 52;
4510pub const AVCodecID_AV_CODEC_ID_MSZH: AVCodecID = 53;
4511pub const AVCodecID_AV_CODEC_ID_ZLIB: AVCodecID = 54;
4512pub const AVCodecID_AV_CODEC_ID_QTRLE: AVCodecID = 55;
4513pub const AVCodecID_AV_CODEC_ID_TSCC: AVCodecID = 56;
4514pub const AVCodecID_AV_CODEC_ID_ULTI: AVCodecID = 57;
4515pub const AVCodecID_AV_CODEC_ID_QDRAW: AVCodecID = 58;
4516pub const AVCodecID_AV_CODEC_ID_VIXL: AVCodecID = 59;
4517pub const AVCodecID_AV_CODEC_ID_QPEG: AVCodecID = 60;
4518pub const AVCodecID_AV_CODEC_ID_PNG: AVCodecID = 61;
4519pub const AVCodecID_AV_CODEC_ID_PPM: AVCodecID = 62;
4520pub const AVCodecID_AV_CODEC_ID_PBM: AVCodecID = 63;
4521pub const AVCodecID_AV_CODEC_ID_PGM: AVCodecID = 64;
4522pub const AVCodecID_AV_CODEC_ID_PGMYUV: AVCodecID = 65;
4523pub const AVCodecID_AV_CODEC_ID_PAM: AVCodecID = 66;
4524pub const AVCodecID_AV_CODEC_ID_FFVHUFF: AVCodecID = 67;
4525pub const AVCodecID_AV_CODEC_ID_RV30: AVCodecID = 68;
4526pub const AVCodecID_AV_CODEC_ID_RV40: AVCodecID = 69;
4527pub const AVCodecID_AV_CODEC_ID_VC1: AVCodecID = 70;
4528pub const AVCodecID_AV_CODEC_ID_WMV3: AVCodecID = 71;
4529pub const AVCodecID_AV_CODEC_ID_LOCO: AVCodecID = 72;
4530pub const AVCodecID_AV_CODEC_ID_WNV1: AVCodecID = 73;
4531pub const AVCodecID_AV_CODEC_ID_AASC: AVCodecID = 74;
4532pub const AVCodecID_AV_CODEC_ID_INDEO2: AVCodecID = 75;
4533pub const AVCodecID_AV_CODEC_ID_FRAPS: AVCodecID = 76;
4534pub const AVCodecID_AV_CODEC_ID_TRUEMOTION2: AVCodecID = 77;
4535pub const AVCodecID_AV_CODEC_ID_BMP: AVCodecID = 78;
4536pub const AVCodecID_AV_CODEC_ID_CSCD: AVCodecID = 79;
4537pub const AVCodecID_AV_CODEC_ID_MMVIDEO: AVCodecID = 80;
4538pub const AVCodecID_AV_CODEC_ID_ZMBV: AVCodecID = 81;
4539pub const AVCodecID_AV_CODEC_ID_AVS: AVCodecID = 82;
4540pub const AVCodecID_AV_CODEC_ID_SMACKVIDEO: AVCodecID = 83;
4541pub const AVCodecID_AV_CODEC_ID_NUV: AVCodecID = 84;
4542pub const AVCodecID_AV_CODEC_ID_KMVC: AVCodecID = 85;
4543pub const AVCodecID_AV_CODEC_ID_FLASHSV: AVCodecID = 86;
4544pub const AVCodecID_AV_CODEC_ID_CAVS: AVCodecID = 87;
4545pub const AVCodecID_AV_CODEC_ID_JPEG2000: AVCodecID = 88;
4546pub const AVCodecID_AV_CODEC_ID_VMNC: AVCodecID = 89;
4547pub const AVCodecID_AV_CODEC_ID_VP5: AVCodecID = 90;
4548pub const AVCodecID_AV_CODEC_ID_VP6: AVCodecID = 91;
4549pub const AVCodecID_AV_CODEC_ID_VP6F: AVCodecID = 92;
4550pub const AVCodecID_AV_CODEC_ID_TARGA: AVCodecID = 93;
4551pub const AVCodecID_AV_CODEC_ID_DSICINVIDEO: AVCodecID = 94;
4552pub const AVCodecID_AV_CODEC_ID_TIERTEXSEQVIDEO: AVCodecID = 95;
4553pub const AVCodecID_AV_CODEC_ID_TIFF: AVCodecID = 96;
4554pub const AVCodecID_AV_CODEC_ID_GIF: AVCodecID = 97;
4555pub const AVCodecID_AV_CODEC_ID_DXA: AVCodecID = 98;
4556pub const AVCodecID_AV_CODEC_ID_DNXHD: AVCodecID = 99;
4557pub const AVCodecID_AV_CODEC_ID_THP: AVCodecID = 100;
4558pub const AVCodecID_AV_CODEC_ID_SGI: AVCodecID = 101;
4559pub const AVCodecID_AV_CODEC_ID_C93: AVCodecID = 102;
4560pub const AVCodecID_AV_CODEC_ID_BETHSOFTVID: AVCodecID = 103;
4561pub const AVCodecID_AV_CODEC_ID_PTX: AVCodecID = 104;
4562pub const AVCodecID_AV_CODEC_ID_TXD: AVCodecID = 105;
4563pub const AVCodecID_AV_CODEC_ID_VP6A: AVCodecID = 106;
4564pub const AVCodecID_AV_CODEC_ID_AMV: AVCodecID = 107;
4565pub const AVCodecID_AV_CODEC_ID_VB: AVCodecID = 108;
4566pub const AVCodecID_AV_CODEC_ID_PCX: AVCodecID = 109;
4567pub const AVCodecID_AV_CODEC_ID_SUNRAST: AVCodecID = 110;
4568pub const AVCodecID_AV_CODEC_ID_INDEO4: AVCodecID = 111;
4569pub const AVCodecID_AV_CODEC_ID_INDEO5: AVCodecID = 112;
4570pub const AVCodecID_AV_CODEC_ID_MIMIC: AVCodecID = 113;
4571pub const AVCodecID_AV_CODEC_ID_RL2: AVCodecID = 114;
4572pub const AVCodecID_AV_CODEC_ID_ESCAPE124: AVCodecID = 115;
4573pub const AVCodecID_AV_CODEC_ID_DIRAC: AVCodecID = 116;
4574pub const AVCodecID_AV_CODEC_ID_BFI: AVCodecID = 117;
4575pub const AVCodecID_AV_CODEC_ID_CMV: AVCodecID = 118;
4576pub const AVCodecID_AV_CODEC_ID_MOTIONPIXELS: AVCodecID = 119;
4577pub const AVCodecID_AV_CODEC_ID_TGV: AVCodecID = 120;
4578pub const AVCodecID_AV_CODEC_ID_TGQ: AVCodecID = 121;
4579pub const AVCodecID_AV_CODEC_ID_TQI: AVCodecID = 122;
4580pub const AVCodecID_AV_CODEC_ID_AURA: AVCodecID = 123;
4581pub const AVCodecID_AV_CODEC_ID_AURA2: AVCodecID = 124;
4582pub const AVCodecID_AV_CODEC_ID_V210X: AVCodecID = 125;
4583pub const AVCodecID_AV_CODEC_ID_TMV: AVCodecID = 126;
4584pub const AVCodecID_AV_CODEC_ID_V210: AVCodecID = 127;
4585pub const AVCodecID_AV_CODEC_ID_DPX: AVCodecID = 128;
4586pub const AVCodecID_AV_CODEC_ID_MAD: AVCodecID = 129;
4587pub const AVCodecID_AV_CODEC_ID_FRWU: AVCodecID = 130;
4588pub const AVCodecID_AV_CODEC_ID_FLASHSV2: AVCodecID = 131;
4589pub const AVCodecID_AV_CODEC_ID_CDGRAPHICS: AVCodecID = 132;
4590pub const AVCodecID_AV_CODEC_ID_R210: AVCodecID = 133;
4591pub const AVCodecID_AV_CODEC_ID_ANM: AVCodecID = 134;
4592pub const AVCodecID_AV_CODEC_ID_BINKVIDEO: AVCodecID = 135;
4593pub const AVCodecID_AV_CODEC_ID_IFF_ILBM: AVCodecID = 136;
4594pub const AVCodecID_AV_CODEC_ID_KGV1: AVCodecID = 137;
4595pub const AVCodecID_AV_CODEC_ID_YOP: AVCodecID = 138;
4596pub const AVCodecID_AV_CODEC_ID_VP8: AVCodecID = 139;
4597pub const AVCodecID_AV_CODEC_ID_PICTOR: AVCodecID = 140;
4598pub const AVCodecID_AV_CODEC_ID_ANSI: AVCodecID = 141;
4599pub const AVCodecID_AV_CODEC_ID_A64_MULTI: AVCodecID = 142;
4600pub const AVCodecID_AV_CODEC_ID_A64_MULTI5: AVCodecID = 143;
4601pub const AVCodecID_AV_CODEC_ID_R10K: AVCodecID = 144;
4602pub const AVCodecID_AV_CODEC_ID_MXPEG: AVCodecID = 145;
4603pub const AVCodecID_AV_CODEC_ID_LAGARITH: AVCodecID = 146;
4604pub const AVCodecID_AV_CODEC_ID_PRORES: AVCodecID = 147;
4605pub const AVCodecID_AV_CODEC_ID_JV: AVCodecID = 148;
4606pub const AVCodecID_AV_CODEC_ID_DFA: AVCodecID = 149;
4607pub const AVCodecID_AV_CODEC_ID_WMV3IMAGE: AVCodecID = 150;
4608pub const AVCodecID_AV_CODEC_ID_VC1IMAGE: AVCodecID = 151;
4609pub const AVCodecID_AV_CODEC_ID_UTVIDEO: AVCodecID = 152;
4610pub const AVCodecID_AV_CODEC_ID_BMV_VIDEO: AVCodecID = 153;
4611pub const AVCodecID_AV_CODEC_ID_VBLE: AVCodecID = 154;
4612pub const AVCodecID_AV_CODEC_ID_DXTORY: AVCodecID = 155;
4613pub const AVCodecID_AV_CODEC_ID_V410: AVCodecID = 156;
4614pub const AVCodecID_AV_CODEC_ID_XWD: AVCodecID = 157;
4615pub const AVCodecID_AV_CODEC_ID_CDXL: AVCodecID = 158;
4616pub const AVCodecID_AV_CODEC_ID_XBM: AVCodecID = 159;
4617pub const AVCodecID_AV_CODEC_ID_ZEROCODEC: AVCodecID = 160;
4618pub const AVCodecID_AV_CODEC_ID_MSS1: AVCodecID = 161;
4619pub const AVCodecID_AV_CODEC_ID_MSA1: AVCodecID = 162;
4620pub const AVCodecID_AV_CODEC_ID_TSCC2: AVCodecID = 163;
4621pub const AVCodecID_AV_CODEC_ID_MTS2: AVCodecID = 164;
4622pub const AVCodecID_AV_CODEC_ID_CLLC: AVCodecID = 165;
4623pub const AVCodecID_AV_CODEC_ID_MSS2: AVCodecID = 166;
4624pub const AVCodecID_AV_CODEC_ID_VP9: AVCodecID = 167;
4625pub const AVCodecID_AV_CODEC_ID_AIC: AVCodecID = 168;
4626pub const AVCodecID_AV_CODEC_ID_ESCAPE130: AVCodecID = 169;
4627pub const AVCodecID_AV_CODEC_ID_G2M: AVCodecID = 170;
4628pub const AVCodecID_AV_CODEC_ID_WEBP: AVCodecID = 171;
4629pub const AVCodecID_AV_CODEC_ID_HNM4_VIDEO: AVCodecID = 172;
4630pub const AVCodecID_AV_CODEC_ID_HEVC: AVCodecID = 173;
4631pub const AVCodecID_AV_CODEC_ID_FIC: AVCodecID = 174;
4632pub const AVCodecID_AV_CODEC_ID_ALIAS_PIX: AVCodecID = 175;
4633pub const AVCodecID_AV_CODEC_ID_BRENDER_PIX: AVCodecID = 176;
4634pub const AVCodecID_AV_CODEC_ID_PAF_VIDEO: AVCodecID = 177;
4635pub const AVCodecID_AV_CODEC_ID_EXR: AVCodecID = 178;
4636pub const AVCodecID_AV_CODEC_ID_VP7: AVCodecID = 179;
4637pub const AVCodecID_AV_CODEC_ID_SANM: AVCodecID = 180;
4638pub const AVCodecID_AV_CODEC_ID_SGIRLE: AVCodecID = 181;
4639pub const AVCodecID_AV_CODEC_ID_MVC1: AVCodecID = 182;
4640pub const AVCodecID_AV_CODEC_ID_MVC2: AVCodecID = 183;
4641pub const AVCodecID_AV_CODEC_ID_HQX: AVCodecID = 184;
4642pub const AVCodecID_AV_CODEC_ID_TDSC: AVCodecID = 185;
4643pub const AVCodecID_AV_CODEC_ID_HQ_HQA: AVCodecID = 186;
4644pub const AVCodecID_AV_CODEC_ID_HAP: AVCodecID = 187;
4645pub const AVCodecID_AV_CODEC_ID_DDS: AVCodecID = 188;
4646pub const AVCodecID_AV_CODEC_ID_DXV: AVCodecID = 189;
4647pub const AVCodecID_AV_CODEC_ID_SCREENPRESSO: AVCodecID = 190;
4648pub const AVCodecID_AV_CODEC_ID_RSCC: AVCodecID = 191;
4649pub const AVCodecID_AV_CODEC_ID_AVS2: AVCodecID = 192;
4650pub const AVCodecID_AV_CODEC_ID_PGX: AVCodecID = 193;
4651pub const AVCodecID_AV_CODEC_ID_AVS3: AVCodecID = 194;
4652pub const AVCodecID_AV_CODEC_ID_MSP2: AVCodecID = 195;
4653pub const AVCodecID_AV_CODEC_ID_VVC: AVCodecID = 196;
4654pub const AVCodecID_AV_CODEC_ID_Y41P: AVCodecID = 197;
4655pub const AVCodecID_AV_CODEC_ID_AVRP: AVCodecID = 198;
4656pub const AVCodecID_AV_CODEC_ID_012V: AVCodecID = 199;
4657pub const AVCodecID_AV_CODEC_ID_AVUI: AVCodecID = 200;
4658pub const AVCodecID_AV_CODEC_ID_TARGA_Y216: AVCodecID = 201;
4659pub const AVCodecID_AV_CODEC_ID_V308: AVCodecID = 202;
4660pub const AVCodecID_AV_CODEC_ID_V408: AVCodecID = 203;
4661pub const AVCodecID_AV_CODEC_ID_YUV4: AVCodecID = 204;
4662pub const AVCodecID_AV_CODEC_ID_AVRN: AVCodecID = 205;
4663pub const AVCodecID_AV_CODEC_ID_CPIA: AVCodecID = 206;
4664pub const AVCodecID_AV_CODEC_ID_XFACE: AVCodecID = 207;
4665pub const AVCodecID_AV_CODEC_ID_SNOW: AVCodecID = 208;
4666pub const AVCodecID_AV_CODEC_ID_SMVJPEG: AVCodecID = 209;
4667pub const AVCodecID_AV_CODEC_ID_APNG: AVCodecID = 210;
4668pub const AVCodecID_AV_CODEC_ID_DAALA: AVCodecID = 211;
4669pub const AVCodecID_AV_CODEC_ID_CFHD: AVCodecID = 212;
4670pub const AVCodecID_AV_CODEC_ID_TRUEMOTION2RT: AVCodecID = 213;
4671pub const AVCodecID_AV_CODEC_ID_M101: AVCodecID = 214;
4672pub const AVCodecID_AV_CODEC_ID_MAGICYUV: AVCodecID = 215;
4673pub const AVCodecID_AV_CODEC_ID_SHEERVIDEO: AVCodecID = 216;
4674pub const AVCodecID_AV_CODEC_ID_YLC: AVCodecID = 217;
4675pub const AVCodecID_AV_CODEC_ID_PSD: AVCodecID = 218;
4676pub const AVCodecID_AV_CODEC_ID_PIXLET: AVCodecID = 219;
4677pub const AVCodecID_AV_CODEC_ID_SPEEDHQ: AVCodecID = 220;
4678pub const AVCodecID_AV_CODEC_ID_FMVC: AVCodecID = 221;
4679pub const AVCodecID_AV_CODEC_ID_SCPR: AVCodecID = 222;
4680pub const AVCodecID_AV_CODEC_ID_CLEARVIDEO: AVCodecID = 223;
4681pub const AVCodecID_AV_CODEC_ID_XPM: AVCodecID = 224;
4682pub const AVCodecID_AV_CODEC_ID_AV1: AVCodecID = 225;
4683pub const AVCodecID_AV_CODEC_ID_BITPACKED: AVCodecID = 226;
4684pub const AVCodecID_AV_CODEC_ID_MSCC: AVCodecID = 227;
4685pub const AVCodecID_AV_CODEC_ID_SRGC: AVCodecID = 228;
4686pub const AVCodecID_AV_CODEC_ID_SVG: AVCodecID = 229;
4687pub const AVCodecID_AV_CODEC_ID_GDV: AVCodecID = 230;
4688pub const AVCodecID_AV_CODEC_ID_FITS: AVCodecID = 231;
4689pub const AVCodecID_AV_CODEC_ID_IMM4: AVCodecID = 232;
4690pub const AVCodecID_AV_CODEC_ID_PROSUMER: AVCodecID = 233;
4691pub const AVCodecID_AV_CODEC_ID_MWSC: AVCodecID = 234;
4692pub const AVCodecID_AV_CODEC_ID_WCMV: AVCodecID = 235;
4693pub const AVCodecID_AV_CODEC_ID_RASC: AVCodecID = 236;
4694pub const AVCodecID_AV_CODEC_ID_HYMT: AVCodecID = 237;
4695pub const AVCodecID_AV_CODEC_ID_ARBC: AVCodecID = 238;
4696pub const AVCodecID_AV_CODEC_ID_AGM: AVCodecID = 239;
4697pub const AVCodecID_AV_CODEC_ID_LSCR: AVCodecID = 240;
4698pub const AVCodecID_AV_CODEC_ID_VP4: AVCodecID = 241;
4699pub const AVCodecID_AV_CODEC_ID_IMM5: AVCodecID = 242;
4700pub const AVCodecID_AV_CODEC_ID_MVDV: AVCodecID = 243;
4701pub const AVCodecID_AV_CODEC_ID_MVHA: AVCodecID = 244;
4702pub const AVCodecID_AV_CODEC_ID_CDTOONS: AVCodecID = 245;
4703pub const AVCodecID_AV_CODEC_ID_MV30: AVCodecID = 246;
4704pub const AVCodecID_AV_CODEC_ID_NOTCHLC: AVCodecID = 247;
4705pub const AVCodecID_AV_CODEC_ID_PFM: AVCodecID = 248;
4706pub const AVCodecID_AV_CODEC_ID_MOBICLIP: AVCodecID = 249;
4707pub const AVCodecID_AV_CODEC_ID_PHOTOCD: AVCodecID = 250;
4708pub const AVCodecID_AV_CODEC_ID_IPU: AVCodecID = 251;
4709pub const AVCodecID_AV_CODEC_ID_ARGO: AVCodecID = 252;
4710pub const AVCodecID_AV_CODEC_ID_CRI: AVCodecID = 253;
4711pub const AVCodecID_AV_CODEC_ID_SIMBIOSIS_IMX: AVCodecID = 254;
4712pub const AVCodecID_AV_CODEC_ID_SGA_VIDEO: AVCodecID = 255;
4713pub const AVCodecID_AV_CODEC_ID_GEM: AVCodecID = 256;
4714pub const AVCodecID_AV_CODEC_ID_VBN: AVCodecID = 257;
4715pub const AVCodecID_AV_CODEC_ID_JPEGXL: AVCodecID = 258;
4716pub const AVCodecID_AV_CODEC_ID_QOI: AVCodecID = 259;
4717pub const AVCodecID_AV_CODEC_ID_PHM: AVCodecID = 260;
4718pub const AVCodecID_AV_CODEC_ID_RADIANCE_HDR: AVCodecID = 261;
4719pub const AVCodecID_AV_CODEC_ID_WBMP: AVCodecID = 262;
4720pub const AVCodecID_AV_CODEC_ID_MEDIA100: AVCodecID = 263;
4721pub const AVCodecID_AV_CODEC_ID_VQC: AVCodecID = 264;
4722pub const AVCodecID_AV_CODEC_ID_PDV: AVCodecID = 265;
4723pub const AVCodecID_AV_CODEC_ID_EVC: AVCodecID = 266;
4724pub const AVCodecID_AV_CODEC_ID_RTV1: AVCodecID = 267;
4725pub const AVCodecID_AV_CODEC_ID_VMIX: AVCodecID = 268;
4726pub const AVCodecID_AV_CODEC_ID_LEAD: AVCodecID = 269;
4727#[doc = "< A dummy id pointing at the start of audio codecs"]
4728pub const AVCodecID_AV_CODEC_ID_FIRST_AUDIO: AVCodecID = 65536;
4729pub const AVCodecID_AV_CODEC_ID_PCM_S16LE: AVCodecID = 65536;
4730pub const AVCodecID_AV_CODEC_ID_PCM_S16BE: AVCodecID = 65537;
4731pub const AVCodecID_AV_CODEC_ID_PCM_U16LE: AVCodecID = 65538;
4732pub const AVCodecID_AV_CODEC_ID_PCM_U16BE: AVCodecID = 65539;
4733pub const AVCodecID_AV_CODEC_ID_PCM_S8: AVCodecID = 65540;
4734pub const AVCodecID_AV_CODEC_ID_PCM_U8: AVCodecID = 65541;
4735pub const AVCodecID_AV_CODEC_ID_PCM_MULAW: AVCodecID = 65542;
4736pub const AVCodecID_AV_CODEC_ID_PCM_ALAW: AVCodecID = 65543;
4737pub const AVCodecID_AV_CODEC_ID_PCM_S32LE: AVCodecID = 65544;
4738pub const AVCodecID_AV_CODEC_ID_PCM_S32BE: AVCodecID = 65545;
4739pub const AVCodecID_AV_CODEC_ID_PCM_U32LE: AVCodecID = 65546;
4740pub const AVCodecID_AV_CODEC_ID_PCM_U32BE: AVCodecID = 65547;
4741pub const AVCodecID_AV_CODEC_ID_PCM_S24LE: AVCodecID = 65548;
4742pub const AVCodecID_AV_CODEC_ID_PCM_S24BE: AVCodecID = 65549;
4743pub const AVCodecID_AV_CODEC_ID_PCM_U24LE: AVCodecID = 65550;
4744pub const AVCodecID_AV_CODEC_ID_PCM_U24BE: AVCodecID = 65551;
4745pub const AVCodecID_AV_CODEC_ID_PCM_S24DAUD: AVCodecID = 65552;
4746pub const AVCodecID_AV_CODEC_ID_PCM_ZORK: AVCodecID = 65553;
4747pub const AVCodecID_AV_CODEC_ID_PCM_S16LE_PLANAR: AVCodecID = 65554;
4748pub const AVCodecID_AV_CODEC_ID_PCM_DVD: AVCodecID = 65555;
4749pub const AVCodecID_AV_CODEC_ID_PCM_F32BE: AVCodecID = 65556;
4750pub const AVCodecID_AV_CODEC_ID_PCM_F32LE: AVCodecID = 65557;
4751pub const AVCodecID_AV_CODEC_ID_PCM_F64BE: AVCodecID = 65558;
4752pub const AVCodecID_AV_CODEC_ID_PCM_F64LE: AVCodecID = 65559;
4753pub const AVCodecID_AV_CODEC_ID_PCM_BLURAY: AVCodecID = 65560;
4754pub const AVCodecID_AV_CODEC_ID_PCM_LXF: AVCodecID = 65561;
4755pub const AVCodecID_AV_CODEC_ID_S302M: AVCodecID = 65562;
4756pub const AVCodecID_AV_CODEC_ID_PCM_S8_PLANAR: AVCodecID = 65563;
4757pub const AVCodecID_AV_CODEC_ID_PCM_S24LE_PLANAR: AVCodecID = 65564;
4758pub const AVCodecID_AV_CODEC_ID_PCM_S32LE_PLANAR: AVCodecID = 65565;
4759pub const AVCodecID_AV_CODEC_ID_PCM_S16BE_PLANAR: AVCodecID = 65566;
4760pub const AVCodecID_AV_CODEC_ID_PCM_S64LE: AVCodecID = 65567;
4761pub const AVCodecID_AV_CODEC_ID_PCM_S64BE: AVCodecID = 65568;
4762pub const AVCodecID_AV_CODEC_ID_PCM_F16LE: AVCodecID = 65569;
4763pub const AVCodecID_AV_CODEC_ID_PCM_F24LE: AVCodecID = 65570;
4764pub const AVCodecID_AV_CODEC_ID_PCM_VIDC: AVCodecID = 65571;
4765pub const AVCodecID_AV_CODEC_ID_PCM_SGA: AVCodecID = 65572;
4766pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_QT: AVCodecID = 69632;
4767pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_WAV: AVCodecID = 69633;
4768pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_DK3: AVCodecID = 69634;
4769pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_DK4: AVCodecID = 69635;
4770pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_WS: AVCodecID = 69636;
4771pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_SMJPEG: AVCodecID = 69637;
4772pub const AVCodecID_AV_CODEC_ID_ADPCM_MS: AVCodecID = 69638;
4773pub const AVCodecID_AV_CODEC_ID_ADPCM_4XM: AVCodecID = 69639;
4774pub const AVCodecID_AV_CODEC_ID_ADPCM_XA: AVCodecID = 69640;
4775pub const AVCodecID_AV_CODEC_ID_ADPCM_ADX: AVCodecID = 69641;
4776pub const AVCodecID_AV_CODEC_ID_ADPCM_EA: AVCodecID = 69642;
4777pub const AVCodecID_AV_CODEC_ID_ADPCM_G726: AVCodecID = 69643;
4778pub const AVCodecID_AV_CODEC_ID_ADPCM_CT: AVCodecID = 69644;
4779pub const AVCodecID_AV_CODEC_ID_ADPCM_SWF: AVCodecID = 69645;
4780pub const AVCodecID_AV_CODEC_ID_ADPCM_YAMAHA: AVCodecID = 69646;
4781pub const AVCodecID_AV_CODEC_ID_ADPCM_SBPRO_4: AVCodecID = 69647;
4782pub const AVCodecID_AV_CODEC_ID_ADPCM_SBPRO_3: AVCodecID = 69648;
4783pub const AVCodecID_AV_CODEC_ID_ADPCM_SBPRO_2: AVCodecID = 69649;
4784pub const AVCodecID_AV_CODEC_ID_ADPCM_THP: AVCodecID = 69650;
4785pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_AMV: AVCodecID = 69651;
4786pub const AVCodecID_AV_CODEC_ID_ADPCM_EA_R1: AVCodecID = 69652;
4787pub const AVCodecID_AV_CODEC_ID_ADPCM_EA_R3: AVCodecID = 69653;
4788pub const AVCodecID_AV_CODEC_ID_ADPCM_EA_R2: AVCodecID = 69654;
4789pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_EA_SEAD: AVCodecID = 69655;
4790pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_EA_EACS: AVCodecID = 69656;
4791pub const AVCodecID_AV_CODEC_ID_ADPCM_EA_XAS: AVCodecID = 69657;
4792pub const AVCodecID_AV_CODEC_ID_ADPCM_EA_MAXIS_XA: AVCodecID = 69658;
4793pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_ISS: AVCodecID = 69659;
4794pub const AVCodecID_AV_CODEC_ID_ADPCM_G722: AVCodecID = 69660;
4795pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_APC: AVCodecID = 69661;
4796pub const AVCodecID_AV_CODEC_ID_ADPCM_VIMA: AVCodecID = 69662;
4797pub const AVCodecID_AV_CODEC_ID_ADPCM_AFC: AVCodecID = 69663;
4798pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_OKI: AVCodecID = 69664;
4799pub const AVCodecID_AV_CODEC_ID_ADPCM_DTK: AVCodecID = 69665;
4800pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_RAD: AVCodecID = 69666;
4801pub const AVCodecID_AV_CODEC_ID_ADPCM_G726LE: AVCodecID = 69667;
4802pub const AVCodecID_AV_CODEC_ID_ADPCM_THP_LE: AVCodecID = 69668;
4803pub const AVCodecID_AV_CODEC_ID_ADPCM_PSX: AVCodecID = 69669;
4804pub const AVCodecID_AV_CODEC_ID_ADPCM_AICA: AVCodecID = 69670;
4805pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_DAT4: AVCodecID = 69671;
4806pub const AVCodecID_AV_CODEC_ID_ADPCM_MTAF: AVCodecID = 69672;
4807pub const AVCodecID_AV_CODEC_ID_ADPCM_AGM: AVCodecID = 69673;
4808pub const AVCodecID_AV_CODEC_ID_ADPCM_ARGO: AVCodecID = 69674;
4809pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_SSI: AVCodecID = 69675;
4810pub const AVCodecID_AV_CODEC_ID_ADPCM_ZORK: AVCodecID = 69676;
4811pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_APM: AVCodecID = 69677;
4812pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_ALP: AVCodecID = 69678;
4813pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_MTF: AVCodecID = 69679;
4814pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_CUNNING: AVCodecID = 69680;
4815pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_MOFLEX: AVCodecID = 69681;
4816pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_ACORN: AVCodecID = 69682;
4817pub const AVCodecID_AV_CODEC_ID_ADPCM_XMD: AVCodecID = 69683;
4818pub const AVCodecID_AV_CODEC_ID_AMR_NB: AVCodecID = 73728;
4819pub const AVCodecID_AV_CODEC_ID_AMR_WB: AVCodecID = 73729;
4820pub const AVCodecID_AV_CODEC_ID_RA_144: AVCodecID = 77824;
4821pub const AVCodecID_AV_CODEC_ID_RA_288: AVCodecID = 77825;
4822pub const AVCodecID_AV_CODEC_ID_ROQ_DPCM: AVCodecID = 81920;
4823pub const AVCodecID_AV_CODEC_ID_INTERPLAY_DPCM: AVCodecID = 81921;
4824pub const AVCodecID_AV_CODEC_ID_XAN_DPCM: AVCodecID = 81922;
4825pub const AVCodecID_AV_CODEC_ID_SOL_DPCM: AVCodecID = 81923;
4826pub const AVCodecID_AV_CODEC_ID_SDX2_DPCM: AVCodecID = 81924;
4827pub const AVCodecID_AV_CODEC_ID_GREMLIN_DPCM: AVCodecID = 81925;
4828pub const AVCodecID_AV_CODEC_ID_DERF_DPCM: AVCodecID = 81926;
4829pub const AVCodecID_AV_CODEC_ID_WADY_DPCM: AVCodecID = 81927;
4830pub const AVCodecID_AV_CODEC_ID_CBD2_DPCM: AVCodecID = 81928;
4831pub const AVCodecID_AV_CODEC_ID_MP2: AVCodecID = 86016;
4832#[doc = "< preferred ID for decoding MPEG audio layer 1, 2 or 3"]
4833pub const AVCodecID_AV_CODEC_ID_MP3: AVCodecID = 86017;
4834pub const AVCodecID_AV_CODEC_ID_AAC: AVCodecID = 86018;
4835pub const AVCodecID_AV_CODEC_ID_AC3: AVCodecID = 86019;
4836pub const AVCodecID_AV_CODEC_ID_DTS: AVCodecID = 86020;
4837pub const AVCodecID_AV_CODEC_ID_VORBIS: AVCodecID = 86021;
4838pub const AVCodecID_AV_CODEC_ID_DVAUDIO: AVCodecID = 86022;
4839pub const AVCodecID_AV_CODEC_ID_WMAV1: AVCodecID = 86023;
4840pub const AVCodecID_AV_CODEC_ID_WMAV2: AVCodecID = 86024;
4841pub const AVCodecID_AV_CODEC_ID_MACE3: AVCodecID = 86025;
4842pub const AVCodecID_AV_CODEC_ID_MACE6: AVCodecID = 86026;
4843pub const AVCodecID_AV_CODEC_ID_VMDAUDIO: AVCodecID = 86027;
4844pub const AVCodecID_AV_CODEC_ID_FLAC: AVCodecID = 86028;
4845pub const AVCodecID_AV_CODEC_ID_MP3ADU: AVCodecID = 86029;
4846pub const AVCodecID_AV_CODEC_ID_MP3ON4: AVCodecID = 86030;
4847pub const AVCodecID_AV_CODEC_ID_SHORTEN: AVCodecID = 86031;
4848pub const AVCodecID_AV_CODEC_ID_ALAC: AVCodecID = 86032;
4849pub const AVCodecID_AV_CODEC_ID_WESTWOOD_SND1: AVCodecID = 86033;
4850#[doc = "< as in Berlin toast format"]
4851pub const AVCodecID_AV_CODEC_ID_GSM: AVCodecID = 86034;
4852pub const AVCodecID_AV_CODEC_ID_QDM2: AVCodecID = 86035;
4853pub const AVCodecID_AV_CODEC_ID_COOK: AVCodecID = 86036;
4854pub const AVCodecID_AV_CODEC_ID_TRUESPEECH: AVCodecID = 86037;
4855pub const AVCodecID_AV_CODEC_ID_TTA: AVCodecID = 86038;
4856pub const AVCodecID_AV_CODEC_ID_SMACKAUDIO: AVCodecID = 86039;
4857pub const AVCodecID_AV_CODEC_ID_QCELP: AVCodecID = 86040;
4858pub const AVCodecID_AV_CODEC_ID_WAVPACK: AVCodecID = 86041;
4859pub const AVCodecID_AV_CODEC_ID_DSICINAUDIO: AVCodecID = 86042;
4860pub const AVCodecID_AV_CODEC_ID_IMC: AVCodecID = 86043;
4861pub const AVCodecID_AV_CODEC_ID_MUSEPACK7: AVCodecID = 86044;
4862pub const AVCodecID_AV_CODEC_ID_MLP: AVCodecID = 86045;
4863pub const AVCodecID_AV_CODEC_ID_GSM_MS: AVCodecID = 86046;
4864pub const AVCodecID_AV_CODEC_ID_ATRAC3: AVCodecID = 86047;
4865pub const AVCodecID_AV_CODEC_ID_APE: AVCodecID = 86048;
4866pub const AVCodecID_AV_CODEC_ID_NELLYMOSER: AVCodecID = 86049;
4867pub const AVCodecID_AV_CODEC_ID_MUSEPACK8: AVCodecID = 86050;
4868pub const AVCodecID_AV_CODEC_ID_SPEEX: AVCodecID = 86051;
4869pub const AVCodecID_AV_CODEC_ID_WMAVOICE: AVCodecID = 86052;
4870pub const AVCodecID_AV_CODEC_ID_WMAPRO: AVCodecID = 86053;
4871pub const AVCodecID_AV_CODEC_ID_WMALOSSLESS: AVCodecID = 86054;
4872pub const AVCodecID_AV_CODEC_ID_ATRAC3P: AVCodecID = 86055;
4873pub const AVCodecID_AV_CODEC_ID_EAC3: AVCodecID = 86056;
4874pub const AVCodecID_AV_CODEC_ID_SIPR: AVCodecID = 86057;
4875pub const AVCodecID_AV_CODEC_ID_MP1: AVCodecID = 86058;
4876pub const AVCodecID_AV_CODEC_ID_TWINVQ: AVCodecID = 86059;
4877pub const AVCodecID_AV_CODEC_ID_TRUEHD: AVCodecID = 86060;
4878pub const AVCodecID_AV_CODEC_ID_MP4ALS: AVCodecID = 86061;
4879pub const AVCodecID_AV_CODEC_ID_ATRAC1: AVCodecID = 86062;
4880pub const AVCodecID_AV_CODEC_ID_BINKAUDIO_RDFT: AVCodecID = 86063;
4881pub const AVCodecID_AV_CODEC_ID_BINKAUDIO_DCT: AVCodecID = 86064;
4882pub const AVCodecID_AV_CODEC_ID_AAC_LATM: AVCodecID = 86065;
4883pub const AVCodecID_AV_CODEC_ID_QDMC: AVCodecID = 86066;
4884pub const AVCodecID_AV_CODEC_ID_CELT: AVCodecID = 86067;
4885pub const AVCodecID_AV_CODEC_ID_G723_1: AVCodecID = 86068;
4886pub const AVCodecID_AV_CODEC_ID_G729: AVCodecID = 86069;
4887pub const AVCodecID_AV_CODEC_ID_8SVX_EXP: AVCodecID = 86070;
4888pub const AVCodecID_AV_CODEC_ID_8SVX_FIB: AVCodecID = 86071;
4889pub const AVCodecID_AV_CODEC_ID_BMV_AUDIO: AVCodecID = 86072;
4890pub const AVCodecID_AV_CODEC_ID_RALF: AVCodecID = 86073;
4891pub const AVCodecID_AV_CODEC_ID_IAC: AVCodecID = 86074;
4892pub const AVCodecID_AV_CODEC_ID_ILBC: AVCodecID = 86075;
4893pub const AVCodecID_AV_CODEC_ID_OPUS: AVCodecID = 86076;
4894pub const AVCodecID_AV_CODEC_ID_COMFORT_NOISE: AVCodecID = 86077;
4895pub const AVCodecID_AV_CODEC_ID_TAK: AVCodecID = 86078;
4896pub const AVCodecID_AV_CODEC_ID_METASOUND: AVCodecID = 86079;
4897pub const AVCodecID_AV_CODEC_ID_PAF_AUDIO: AVCodecID = 86080;
4898pub const AVCodecID_AV_CODEC_ID_ON2AVC: AVCodecID = 86081;
4899pub const AVCodecID_AV_CODEC_ID_DSS_SP: AVCodecID = 86082;
4900pub const AVCodecID_AV_CODEC_ID_CODEC2: AVCodecID = 86083;
4901pub const AVCodecID_AV_CODEC_ID_FFWAVESYNTH: AVCodecID = 86084;
4902pub const AVCodecID_AV_CODEC_ID_SONIC: AVCodecID = 86085;
4903pub const AVCodecID_AV_CODEC_ID_SONIC_LS: AVCodecID = 86086;
4904pub const AVCodecID_AV_CODEC_ID_EVRC: AVCodecID = 86087;
4905pub const AVCodecID_AV_CODEC_ID_SMV: AVCodecID = 86088;
4906pub const AVCodecID_AV_CODEC_ID_DSD_LSBF: AVCodecID = 86089;
4907pub const AVCodecID_AV_CODEC_ID_DSD_MSBF: AVCodecID = 86090;
4908pub const AVCodecID_AV_CODEC_ID_DSD_LSBF_PLANAR: AVCodecID = 86091;
4909pub const AVCodecID_AV_CODEC_ID_DSD_MSBF_PLANAR: AVCodecID = 86092;
4910pub const AVCodecID_AV_CODEC_ID_4GV: AVCodecID = 86093;
4911pub const AVCodecID_AV_CODEC_ID_INTERPLAY_ACM: AVCodecID = 86094;
4912pub const AVCodecID_AV_CODEC_ID_XMA1: AVCodecID = 86095;
4913pub const AVCodecID_AV_CODEC_ID_XMA2: AVCodecID = 86096;
4914pub const AVCodecID_AV_CODEC_ID_DST: AVCodecID = 86097;
4915pub const AVCodecID_AV_CODEC_ID_ATRAC3AL: AVCodecID = 86098;
4916pub const AVCodecID_AV_CODEC_ID_ATRAC3PAL: AVCodecID = 86099;
4917pub const AVCodecID_AV_CODEC_ID_DOLBY_E: AVCodecID = 86100;
4918pub const AVCodecID_AV_CODEC_ID_APTX: AVCodecID = 86101;
4919pub const AVCodecID_AV_CODEC_ID_APTX_HD: AVCodecID = 86102;
4920pub const AVCodecID_AV_CODEC_ID_SBC: AVCodecID = 86103;
4921pub const AVCodecID_AV_CODEC_ID_ATRAC9: AVCodecID = 86104;
4922pub const AVCodecID_AV_CODEC_ID_HCOM: AVCodecID = 86105;
4923pub const AVCodecID_AV_CODEC_ID_ACELP_KELVIN: AVCodecID = 86106;
4924pub const AVCodecID_AV_CODEC_ID_MPEGH_3D_AUDIO: AVCodecID = 86107;
4925pub const AVCodecID_AV_CODEC_ID_SIREN: AVCodecID = 86108;
4926pub const AVCodecID_AV_CODEC_ID_HCA: AVCodecID = 86109;
4927pub const AVCodecID_AV_CODEC_ID_FASTAUDIO: AVCodecID = 86110;
4928pub const AVCodecID_AV_CODEC_ID_MSNSIREN: AVCodecID = 86111;
4929pub const AVCodecID_AV_CODEC_ID_DFPWM: AVCodecID = 86112;
4930pub const AVCodecID_AV_CODEC_ID_BONK: AVCodecID = 86113;
4931pub const AVCodecID_AV_CODEC_ID_MISC4: AVCodecID = 86114;
4932pub const AVCodecID_AV_CODEC_ID_APAC: AVCodecID = 86115;
4933pub const AVCodecID_AV_CODEC_ID_FTR: AVCodecID = 86116;
4934pub const AVCodecID_AV_CODEC_ID_WAVARC: AVCodecID = 86117;
4935pub const AVCodecID_AV_CODEC_ID_RKA: AVCodecID = 86118;
4936pub const AVCodecID_AV_CODEC_ID_AC4: AVCodecID = 86119;
4937pub const AVCodecID_AV_CODEC_ID_OSQ: AVCodecID = 86120;
4938pub const AVCodecID_AV_CODEC_ID_QOA: AVCodecID = 86121;
4939pub const AVCodecID_AV_CODEC_ID_LC3: AVCodecID = 86122;
4940#[doc = "< A dummy ID pointing at the start of subtitle codecs."]
4941pub const AVCodecID_AV_CODEC_ID_FIRST_SUBTITLE: AVCodecID = 94208;
4942pub const AVCodecID_AV_CODEC_ID_DVD_SUBTITLE: AVCodecID = 94208;
4943pub const AVCodecID_AV_CODEC_ID_DVB_SUBTITLE: AVCodecID = 94209;
4944#[doc = "< raw UTF-8 text"]
4945pub const AVCodecID_AV_CODEC_ID_TEXT: AVCodecID = 94210;
4946pub const AVCodecID_AV_CODEC_ID_XSUB: AVCodecID = 94211;
4947pub const AVCodecID_AV_CODEC_ID_SSA: AVCodecID = 94212;
4948pub const AVCodecID_AV_CODEC_ID_MOV_TEXT: AVCodecID = 94213;
4949pub const AVCodecID_AV_CODEC_ID_HDMV_PGS_SUBTITLE: AVCodecID = 94214;
4950pub const AVCodecID_AV_CODEC_ID_DVB_TELETEXT: AVCodecID = 94215;
4951pub const AVCodecID_AV_CODEC_ID_SRT: AVCodecID = 94216;
4952pub const AVCodecID_AV_CODEC_ID_MICRODVD: AVCodecID = 94217;
4953pub const AVCodecID_AV_CODEC_ID_EIA_608: AVCodecID = 94218;
4954pub const AVCodecID_AV_CODEC_ID_JACOSUB: AVCodecID = 94219;
4955pub const AVCodecID_AV_CODEC_ID_SAMI: AVCodecID = 94220;
4956pub const AVCodecID_AV_CODEC_ID_REALTEXT: AVCodecID = 94221;
4957pub const AVCodecID_AV_CODEC_ID_STL: AVCodecID = 94222;
4958pub const AVCodecID_AV_CODEC_ID_SUBVIEWER1: AVCodecID = 94223;
4959pub const AVCodecID_AV_CODEC_ID_SUBVIEWER: AVCodecID = 94224;
4960pub const AVCodecID_AV_CODEC_ID_SUBRIP: AVCodecID = 94225;
4961pub const AVCodecID_AV_CODEC_ID_WEBVTT: AVCodecID = 94226;
4962pub const AVCodecID_AV_CODEC_ID_MPL2: AVCodecID = 94227;
4963pub const AVCodecID_AV_CODEC_ID_VPLAYER: AVCodecID = 94228;
4964pub const AVCodecID_AV_CODEC_ID_PJS: AVCodecID = 94229;
4965pub const AVCodecID_AV_CODEC_ID_ASS: AVCodecID = 94230;
4966pub const AVCodecID_AV_CODEC_ID_HDMV_TEXT_SUBTITLE: AVCodecID = 94231;
4967pub const AVCodecID_AV_CODEC_ID_TTML: AVCodecID = 94232;
4968pub const AVCodecID_AV_CODEC_ID_ARIB_CAPTION: AVCodecID = 94233;
4969#[doc = "< A dummy ID pointing at the start of various fake codecs."]
4970pub const AVCodecID_AV_CODEC_ID_FIRST_UNKNOWN: AVCodecID = 98304;
4971pub const AVCodecID_AV_CODEC_ID_TTF: AVCodecID = 98304;
4972#[doc = "< Contain timestamp estimated through PCR of program stream."]
4973pub const AVCodecID_AV_CODEC_ID_SCTE_35: AVCodecID = 98305;
4974pub const AVCodecID_AV_CODEC_ID_EPG: AVCodecID = 98306;
4975pub const AVCodecID_AV_CODEC_ID_BINTEXT: AVCodecID = 98307;
4976pub const AVCodecID_AV_CODEC_ID_XBIN: AVCodecID = 98308;
4977pub const AVCodecID_AV_CODEC_ID_IDF: AVCodecID = 98309;
4978pub const AVCodecID_AV_CODEC_ID_OTF: AVCodecID = 98310;
4979pub const AVCodecID_AV_CODEC_ID_SMPTE_KLV: AVCodecID = 98311;
4980pub const AVCodecID_AV_CODEC_ID_DVD_NAV: AVCodecID = 98312;
4981pub const AVCodecID_AV_CODEC_ID_TIMED_ID3: AVCodecID = 98313;
4982pub const AVCodecID_AV_CODEC_ID_BIN_DATA: AVCodecID = 98314;
4983pub const AVCodecID_AV_CODEC_ID_SMPTE_2038: AVCodecID = 98315;
4984#[doc = "< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it"]
4985pub const AVCodecID_AV_CODEC_ID_PROBE: AVCodecID = 102400;
4986#[doc = "< _FAKE_ codec to indicate a raw MPEG-2 TS\n stream (only used by libavformat)"]
4987pub const AVCodecID_AV_CODEC_ID_MPEG2TS: AVCodecID = 131072;
4988#[doc = "< _FAKE_ codec to indicate a MPEG-4 Systems\n stream (only used by libavformat)"]
4989pub const AVCodecID_AV_CODEC_ID_MPEG4SYSTEMS: AVCodecID = 131073;
4990#[doc = "< Dummy codec for streams containing only metadata information."]
4991pub const AVCodecID_AV_CODEC_ID_FFMETADATA: AVCodecID = 135168;
4992#[doc = "< Passthrough codec, AVFrames wrapped in AVPacket"]
4993pub const AVCodecID_AV_CODEC_ID_WRAPPED_AVFRAME: AVCodecID = 135169;
4994#[doc = " Dummy null video codec, useful mainly for development and debugging.\n Null encoder/decoder discard all input and never return any output."]
4995pub const AVCodecID_AV_CODEC_ID_VNULL: AVCodecID = 135170;
4996#[doc = " Dummy null audio codec, useful mainly for development and debugging.\n Null encoder/decoder discard all input and never return any output."]
4997pub const AVCodecID_AV_CODEC_ID_ANULL: AVCodecID = 135171;
4998#[doc = " Identify the syntax and semantics of the bitstream.\n The principle is roughly:\n Two decoders with the same ID can decode the same streams.\n Two encoders with the same ID can encode compatible streams.\n There may be slight deviations from the principle due to implementation\n details.\n\n If you add a codec ID to this list, add it so that\n 1. no value of an existing codec ID changes (that would break ABI),\n 2. it is as close as possible to similar codecs\n\n After adding new codec IDs, do not forget to add an entry to the codec\n descriptor list and bump libavcodec minor version."]
4999pub type AVCodecID = ::std::os::raw::c_uint;
5000extern "C" {
5001 #[doc = " Get the type of the given codec."]
5002 pub fn avcodec_get_type(codec_id: AVCodecID) -> AVMediaType;
5003}
5004extern "C" {
5005 #[doc = " Get the name of a codec.\n @return a static string identifying the codec; never NULL"]
5006 pub fn avcodec_get_name(id: AVCodecID) -> *const ::std::os::raw::c_char;
5007}
5008extern "C" {
5009 #[doc = " Return codec bits per sample.\n\n @param[in] codec_id the codec\n @return Number of bits per sample or zero if unknown for the given codec."]
5010 pub fn av_get_bits_per_sample(codec_id: AVCodecID) -> ::std::os::raw::c_int;
5011}
5012extern "C" {
5013 #[doc = " Return codec bits per sample.\n Only return non-zero if the bits per sample is exactly correct, not an\n approximation.\n\n @param[in] codec_id the codec\n @return Number of bits per sample or zero if unknown for the given codec."]
5014 pub fn av_get_exact_bits_per_sample(codec_id: AVCodecID) -> ::std::os::raw::c_int;
5015}
5016extern "C" {
5017 #[doc = " Return a name for the specified profile, if available.\n\n @param codec_id the ID of the codec to which the requested profile belongs\n @param profile the profile value for which a name is requested\n @return A name for the profile if found, NULL otherwise.\n\n @note unlike av_get_profile_name(), which searches a list of profiles\n supported by a specific decoder or encoder implementation, this\n function searches the list of profiles from the AVCodecDescriptor"]
5018 pub fn avcodec_profile_name(
5019 codec_id: AVCodecID,
5020 profile: ::std::os::raw::c_int,
5021 ) -> *const ::std::os::raw::c_char;
5022}
5023extern "C" {
5024 #[doc = " Return the PCM codec associated with a sample format.\n @param be endianness, 0 for little, 1 for big,\n -1 (or anything else) for native\n @return AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE"]
5025 pub fn av_get_pcm_codec(fmt: AVSampleFormat, be: ::std::os::raw::c_int) -> AVCodecID;
5026}
5027pub const AVFieldOrder_AV_FIELD_UNKNOWN: AVFieldOrder = 0;
5028pub const AVFieldOrder_AV_FIELD_PROGRESSIVE: AVFieldOrder = 1;
5029#[doc = "< Top coded_first, top displayed first"]
5030pub const AVFieldOrder_AV_FIELD_TT: AVFieldOrder = 2;
5031#[doc = "< Bottom coded first, bottom displayed first"]
5032pub const AVFieldOrder_AV_FIELD_BB: AVFieldOrder = 3;
5033#[doc = "< Top coded first, bottom displayed first"]
5034pub const AVFieldOrder_AV_FIELD_TB: AVFieldOrder = 4;
5035#[doc = "< Bottom coded first, top displayed first"]
5036pub const AVFieldOrder_AV_FIELD_BT: AVFieldOrder = 5;
5037pub type AVFieldOrder = ::std::os::raw::c_uint;
5038#[doc = "< discard nothing"]
5039pub const AVDiscard_AVDISCARD_NONE: AVDiscard = -16;
5040#[doc = "< discard useless packets like 0 size packets in avi"]
5041pub const AVDiscard_AVDISCARD_DEFAULT: AVDiscard = 0;
5042#[doc = "< discard all non reference"]
5043pub const AVDiscard_AVDISCARD_NONREF: AVDiscard = 8;
5044#[doc = "< discard all bidirectional frames"]
5045pub const AVDiscard_AVDISCARD_BIDIR: AVDiscard = 16;
5046#[doc = "< discard all non intra frames"]
5047pub const AVDiscard_AVDISCARD_NONINTRA: AVDiscard = 24;
5048#[doc = "< discard all frames except keyframes"]
5049pub const AVDiscard_AVDISCARD_NONKEY: AVDiscard = 32;
5050#[doc = "< discard all"]
5051pub const AVDiscard_AVDISCARD_ALL: AVDiscard = 48;
5052#[doc = " @ingroup lavc_decoding"]
5053pub type AVDiscard = ::std::os::raw::c_int;
5054pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_MAIN: AVAudioServiceType = 0;
5055pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_EFFECTS: AVAudioServiceType = 1;
5056pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED: AVAudioServiceType = 2;
5057pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED: AVAudioServiceType = 3;
5058pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_DIALOGUE: AVAudioServiceType = 4;
5059pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_COMMENTARY: AVAudioServiceType = 5;
5060pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_EMERGENCY: AVAudioServiceType = 6;
5061pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_VOICE_OVER: AVAudioServiceType = 7;
5062pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_KARAOKE: AVAudioServiceType = 8;
5063#[doc = "< Not part of ABI"]
5064pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_NB: AVAudioServiceType = 9;
5065pub type AVAudioServiceType = ::std::os::raw::c_uint;
5066#[doc = " Pan Scan area.\n This specifies the area which should be displayed.\n Note there may be multiple such areas for one frame."]
5067#[repr(C)]
5068#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5069pub struct AVPanScan {
5070 #[doc = " id\n - encoding: Set by user.\n - decoding: Set by libavcodec."]
5071 pub id: ::std::os::raw::c_int,
5072 #[doc = " width and height in 1/16 pel\n - encoding: Set by user.\n - decoding: Set by libavcodec."]
5073 pub width: ::std::os::raw::c_int,
5074 pub height: ::std::os::raw::c_int,
5075 #[doc = " position of the top left corner in 1/16 pel for up to 3 fields/frames\n - encoding: Set by user.\n - decoding: Set by libavcodec."]
5076 pub position: [[i16; 2usize]; 3usize],
5077}
5078#[doc = " This structure describes the bitrate properties of an encoded bitstream. It\n roughly corresponds to a subset the VBV parameters for MPEG-2 or HRD\n parameters for H.264/HEVC."]
5079#[repr(C)]
5080#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5081pub struct AVCPBProperties {
5082 #[doc = " Maximum bitrate of the stream, in bits per second.\n Zero if unknown or unspecified."]
5083 pub max_bitrate: i64,
5084 #[doc = " Minimum bitrate of the stream, in bits per second.\n Zero if unknown or unspecified."]
5085 pub min_bitrate: i64,
5086 #[doc = " Average bitrate of the stream, in bits per second.\n Zero if unknown or unspecified."]
5087 pub avg_bitrate: i64,
5088 #[doc = " The size of the buffer to which the ratecontrol is applied, in bits.\n Zero if unknown or unspecified."]
5089 pub buffer_size: i64,
5090 #[doc = " The delay between the time the packet this structure is associated with\n is received and the time when it should be decoded, in periods of a 27MHz\n clock.\n\n UINT64_MAX when unknown or unspecified."]
5091 pub vbv_delay: u64,
5092}
5093extern "C" {
5094 #[doc = " Allocate a CPB properties structure and initialize its fields to default\n values.\n\n @param size if non-NULL, the size of the allocated struct will be written\n here. This is useful for embedding it in side data.\n\n @return the newly allocated struct or NULL on failure"]
5095 pub fn av_cpb_properties_alloc(size: *mut usize) -> *mut AVCPBProperties;
5096}
5097#[doc = " This structure supplies correlation between a packet timestamp and a wall clock\n production time. The definition follows the Producer Reference Time ('prft')\n as defined in ISO/IEC 14496-12"]
5098#[repr(C)]
5099#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5100pub struct AVProducerReferenceTime {
5101 #[doc = " A UTC timestamp, in microseconds, since Unix epoch (e.g, av_gettime())."]
5102 pub wallclock: i64,
5103 pub flags: ::std::os::raw::c_int,
5104}
5105extern "C" {
5106 #[doc = " Encode extradata length to a buffer. Used by xiph codecs.\n\n @param s buffer to write to; must be at least (v/255+1) bytes long\n @param v size of extradata in bytes\n @return number of bytes written to the buffer."]
5107 pub fn av_xiphlacing(
5108 s: *mut ::std::os::raw::c_uchar,
5109 v: ::std::os::raw::c_uint,
5110 ) -> ::std::os::raw::c_uint;
5111}
5112#[repr(C)]
5113#[derive(Debug, Copy, Clone)]
5114pub struct AVBuffer {
5115 _unused: [u8; 0],
5116}
5117#[doc = " A reference to a data buffer.\n\n The size of this struct is not a part of the public ABI and it is not meant\n to be allocated directly."]
5118#[repr(C)]
5119#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5120pub struct AVBufferRef {
5121 pub buffer: *mut AVBuffer,
5122 #[doc = " The data buffer. It is considered writable if and only if\n this is the only reference to the buffer, in which case\n av_buffer_is_writable() returns 1."]
5123 pub data: *mut u8,
5124 #[doc = " Size of data in bytes."]
5125 pub size: usize,
5126}
5127impl Default for AVBufferRef {
5128 fn default() -> Self {
5129 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5130 unsafe {
5131 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5132 s.assume_init()
5133 }
5134 }
5135}
5136extern "C" {
5137 #[doc = " Allocate an AVBuffer of the given size using av_malloc().\n\n @return an AVBufferRef of given size or NULL when out of memory"]
5138 pub fn av_buffer_alloc(size: usize) -> *mut AVBufferRef;
5139}
5140extern "C" {
5141 #[doc = " Same as av_buffer_alloc(), except the returned buffer will be initialized\n to zero."]
5142 pub fn av_buffer_allocz(size: usize) -> *mut AVBufferRef;
5143}
5144extern "C" {
5145 #[doc = " Create an AVBuffer from an existing array.\n\n If this function is successful, data is owned by the AVBuffer. The caller may\n only access data through the returned AVBufferRef and references derived from\n it.\n If this function fails, data is left untouched.\n @param data data array\n @param size size of data in bytes\n @param free a callback for freeing this buffer's data\n @param opaque parameter to be got for processing or passed to free\n @param flags a combination of AV_BUFFER_FLAG_*\n\n @return an AVBufferRef referring to data on success, NULL on failure."]
5146 pub fn av_buffer_create(
5147 data: *mut u8,
5148 size: usize,
5149 free: ::std::option::Option<
5150 unsafe extern "C" fn(opaque: *mut ::std::os::raw::c_void, data: *mut u8),
5151 >,
5152 opaque: *mut ::std::os::raw::c_void,
5153 flags: ::std::os::raw::c_int,
5154 ) -> *mut AVBufferRef;
5155}
5156extern "C" {
5157 #[doc = " Default free callback, which calls av_free() on the buffer data.\n This function is meant to be passed to av_buffer_create(), not called\n directly."]
5158 pub fn av_buffer_default_free(opaque: *mut ::std::os::raw::c_void, data: *mut u8);
5159}
5160extern "C" {
5161 #[doc = " Create a new reference to an AVBuffer.\n\n @return a new AVBufferRef referring to the same AVBuffer as buf or NULL on\n failure."]
5162 pub fn av_buffer_ref(buf: *const AVBufferRef) -> *mut AVBufferRef;
5163}
5164extern "C" {
5165 #[doc = " Free a given reference and automatically free the buffer if there are no more\n references to it.\n\n @param buf the reference to be freed. The pointer is set to NULL on return."]
5166 pub fn av_buffer_unref(buf: *mut *mut AVBufferRef);
5167}
5168extern "C" {
5169 #[doc = " @return 1 if the caller may write to the data referred to by buf (which is\n true if and only if buf is the only reference to the underlying AVBuffer).\n Return 0 otherwise.\n A positive answer is valid until av_buffer_ref() is called on buf."]
5170 pub fn av_buffer_is_writable(buf: *const AVBufferRef) -> ::std::os::raw::c_int;
5171}
5172extern "C" {
5173 #[doc = " @return the opaque parameter set by av_buffer_create."]
5174 pub fn av_buffer_get_opaque(buf: *const AVBufferRef) -> *mut ::std::os::raw::c_void;
5175}
5176extern "C" {
5177 pub fn av_buffer_get_ref_count(buf: *const AVBufferRef) -> ::std::os::raw::c_int;
5178}
5179extern "C" {
5180 #[doc = " Create a writable reference from a given buffer reference, avoiding data copy\n if possible.\n\n @param buf buffer reference to make writable. On success, buf is either left\n untouched, or it is unreferenced and a new writable AVBufferRef is\n written in its place. On failure, buf is left untouched.\n @return 0 on success, a negative AVERROR on failure."]
5181 pub fn av_buffer_make_writable(buf: *mut *mut AVBufferRef) -> ::std::os::raw::c_int;
5182}
5183extern "C" {
5184 #[doc = " Reallocate a given buffer.\n\n @param buf a buffer reference to reallocate. On success, buf will be\n unreferenced and a new reference with the required size will be\n written in its place. On failure buf will be left untouched. *buf\n may be NULL, then a new buffer is allocated.\n @param size required new buffer size.\n @return 0 on success, a negative AVERROR on failure.\n\n @note the buffer is actually reallocated with av_realloc() only if it was\n initially allocated through av_buffer_realloc(NULL) and there is only one\n reference to it (i.e. the one passed to this function). In all other cases\n a new buffer is allocated and the data is copied."]
5185 pub fn av_buffer_realloc(buf: *mut *mut AVBufferRef, size: usize) -> ::std::os::raw::c_int;
5186}
5187extern "C" {
5188 #[doc = " Ensure dst refers to the same data as src.\n\n When *dst is already equivalent to src, do nothing. Otherwise unreference dst\n and replace it with a new reference to src.\n\n @param dst Pointer to either a valid buffer reference or NULL. On success,\n this will point to a buffer reference equivalent to src. On\n failure, dst will be left untouched.\n @param src A buffer reference to replace dst with. May be NULL, then this\n function is equivalent to av_buffer_unref(dst).\n @return 0 on success\n AVERROR(ENOMEM) on memory allocation failure."]
5189 pub fn av_buffer_replace(
5190 dst: *mut *mut AVBufferRef,
5191 src: *const AVBufferRef,
5192 ) -> ::std::os::raw::c_int;
5193}
5194#[repr(C)]
5195#[derive(Debug, Copy, Clone)]
5196pub struct AVBufferPool {
5197 _unused: [u8; 0],
5198}
5199extern "C" {
5200 #[doc = " Allocate and initialize a buffer pool.\n\n @param size size of each buffer in this pool\n @param alloc a function that will be used to allocate new buffers when the\n pool is empty. May be NULL, then the default allocator will be used\n (av_buffer_alloc()).\n @return newly created buffer pool on success, NULL on error."]
5201 pub fn av_buffer_pool_init(
5202 size: usize,
5203 alloc: ::std::option::Option<unsafe extern "C" fn(size: usize) -> *mut AVBufferRef>,
5204 ) -> *mut AVBufferPool;
5205}
5206extern "C" {
5207 #[doc = " Allocate and initialize a buffer pool with a more complex allocator.\n\n @param size size of each buffer in this pool\n @param opaque arbitrary user data used by the allocator\n @param alloc a function that will be used to allocate new buffers when the\n pool is empty. May be NULL, then the default allocator will be\n used (av_buffer_alloc()).\n @param pool_free a function that will be called immediately before the pool\n is freed. I.e. after av_buffer_pool_uninit() is called\n by the caller and all the frames are returned to the pool\n and freed. It is intended to uninitialize the user opaque\n data. May be NULL.\n @return newly created buffer pool on success, NULL on error."]
5208 pub fn av_buffer_pool_init2(
5209 size: usize,
5210 opaque: *mut ::std::os::raw::c_void,
5211 alloc: ::std::option::Option<
5212 unsafe extern "C" fn(
5213 opaque: *mut ::std::os::raw::c_void,
5214 size: usize,
5215 ) -> *mut AVBufferRef,
5216 >,
5217 pool_free: ::std::option::Option<unsafe extern "C" fn(opaque: *mut ::std::os::raw::c_void)>,
5218 ) -> *mut AVBufferPool;
5219}
5220extern "C" {
5221 #[doc = " Mark the pool as being available for freeing. It will actually be freed only\n once all the allocated buffers associated with the pool are released. Thus it\n is safe to call this function while some of the allocated buffers are still\n in use.\n\n @param pool pointer to the pool to be freed. It will be set to NULL."]
5222 pub fn av_buffer_pool_uninit(pool: *mut *mut AVBufferPool);
5223}
5224extern "C" {
5225 #[doc = " Allocate a new AVBuffer, reusing an old buffer from the pool when available.\n This function may be called simultaneously from multiple threads.\n\n @return a reference to the new buffer on success, NULL on error."]
5226 pub fn av_buffer_pool_get(pool: *mut AVBufferPool) -> *mut AVBufferRef;
5227}
5228extern "C" {
5229 #[doc = " Query the original opaque parameter of an allocated buffer in the pool.\n\n @param ref a buffer reference to a buffer returned by av_buffer_pool_get.\n @return the opaque parameter set by the buffer allocator function of the\n buffer pool.\n\n @note the opaque parameter of ref is used by the buffer pool implementation,\n therefore you have to use this function to access the original opaque\n parameter of an allocated buffer."]
5230 pub fn av_buffer_pool_buffer_get_opaque(
5231 ref_: *const AVBufferRef,
5232 ) -> *mut ::std::os::raw::c_void;
5233}
5234#[doc = " @}"]
5235#[repr(C)]
5236#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5237pub struct AVDictionaryEntry {
5238 pub key: *mut ::std::os::raw::c_char,
5239 pub value: *mut ::std::os::raw::c_char,
5240}
5241impl Default for AVDictionaryEntry {
5242 fn default() -> Self {
5243 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5244 unsafe {
5245 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5246 s.assume_init()
5247 }
5248 }
5249}
5250#[repr(C)]
5251#[derive(Debug, Copy, Clone)]
5252pub struct AVDictionary {
5253 _unused: [u8; 0],
5254}
5255extern "C" {
5256 #[doc = " Get a dictionary entry with matching key.\n\n The returned entry key or value must not be changed, or it will\n cause undefined behavior.\n\n @param prev Set to the previous matching element to find the next.\n If set to NULL the first matching element is returned.\n @param key Matching key\n @param flags A collection of AV_DICT_* flags controlling how the\n entry is retrieved\n\n @return Found entry or NULL in case no matching entry was found in the dictionary"]
5257 pub fn av_dict_get(
5258 m: *const AVDictionary,
5259 key: *const ::std::os::raw::c_char,
5260 prev: *const AVDictionaryEntry,
5261 flags: ::std::os::raw::c_int,
5262 ) -> *mut AVDictionaryEntry;
5263}
5264extern "C" {
5265 #[doc = " Iterate over a dictionary\n\n Iterates through all entries in the dictionary.\n\n @warning The returned AVDictionaryEntry key/value must not be changed.\n\n @warning As av_dict_set() invalidates all previous entries returned\n by this function, it must not be called while iterating over the dict.\n\n Typical usage:\n @code\n const AVDictionaryEntry *e = NULL;\n while ((e = av_dict_iterate(m, e))) {\n // ...\n }\n @endcode\n\n @param m The dictionary to iterate over\n @param prev Pointer to the previous AVDictionaryEntry, NULL initially\n\n @retval AVDictionaryEntry* The next element in the dictionary\n @retval NULL No more elements in the dictionary"]
5266 pub fn av_dict_iterate(
5267 m: *const AVDictionary,
5268 prev: *const AVDictionaryEntry,
5269 ) -> *const AVDictionaryEntry;
5270}
5271extern "C" {
5272 #[doc = " Get number of entries in dictionary.\n\n @param m dictionary\n @return number of entries in dictionary"]
5273 pub fn av_dict_count(m: *const AVDictionary) -> ::std::os::raw::c_int;
5274}
5275extern "C" {
5276 #[doc = " Set the given entry in *pm, overwriting an existing entry.\n\n Note: If AV_DICT_DONT_STRDUP_KEY or AV_DICT_DONT_STRDUP_VAL is set,\n these arguments will be freed on error.\n\n @warning Adding a new entry to a dictionary invalidates all existing entries\n previously returned with av_dict_get() or av_dict_iterate().\n\n @param pm Pointer to a pointer to a dictionary struct. If *pm is NULL\n a dictionary struct is allocated and put in *pm.\n @param key Entry key to add to *pm (will either be av_strduped or added as a new key depending on flags)\n @param value Entry value to add to *pm (will be av_strduped or added as a new key depending on flags).\n Passing a NULL value will cause an existing entry to be deleted.\n\n @return >= 0 on success otherwise an error code <0"]
5277 pub fn av_dict_set(
5278 pm: *mut *mut AVDictionary,
5279 key: *const ::std::os::raw::c_char,
5280 value: *const ::std::os::raw::c_char,
5281 flags: ::std::os::raw::c_int,
5282 ) -> ::std::os::raw::c_int;
5283}
5284extern "C" {
5285 #[doc = " Convenience wrapper for av_dict_set() that converts the value to a string\n and stores it.\n\n Note: If ::AV_DICT_DONT_STRDUP_KEY is set, key will be freed on error."]
5286 pub fn av_dict_set_int(
5287 pm: *mut *mut AVDictionary,
5288 key: *const ::std::os::raw::c_char,
5289 value: i64,
5290 flags: ::std::os::raw::c_int,
5291 ) -> ::std::os::raw::c_int;
5292}
5293extern "C" {
5294 #[doc = " Parse the key/value pairs list and add the parsed entries to a dictionary.\n\n In case of failure, all the successfully set entries are stored in\n *pm. You may need to manually free the created dictionary.\n\n @param key_val_sep A 0-terminated list of characters used to separate\n key from value\n @param pairs_sep A 0-terminated list of characters used to separate\n two pairs from each other\n @param flags Flags to use when adding to the dictionary.\n ::AV_DICT_DONT_STRDUP_KEY and ::AV_DICT_DONT_STRDUP_VAL\n are ignored since the key/value tokens will always\n be duplicated.\n\n @return 0 on success, negative AVERROR code on failure"]
5295 pub fn av_dict_parse_string(
5296 pm: *mut *mut AVDictionary,
5297 str_: *const ::std::os::raw::c_char,
5298 key_val_sep: *const ::std::os::raw::c_char,
5299 pairs_sep: *const ::std::os::raw::c_char,
5300 flags: ::std::os::raw::c_int,
5301 ) -> ::std::os::raw::c_int;
5302}
5303extern "C" {
5304 #[doc = " Copy entries from one AVDictionary struct into another.\n\n @note Metadata is read using the ::AV_DICT_IGNORE_SUFFIX flag\n\n @param dst Pointer to a pointer to a AVDictionary struct to copy into. If *dst is NULL,\n this function will allocate a struct for you and put it in *dst\n @param src Pointer to the source AVDictionary struct to copy items from.\n @param flags Flags to use when setting entries in *dst\n\n @return 0 on success, negative AVERROR code on failure. If dst was allocated\n by this function, callers should free the associated memory."]
5305 pub fn av_dict_copy(
5306 dst: *mut *mut AVDictionary,
5307 src: *const AVDictionary,
5308 flags: ::std::os::raw::c_int,
5309 ) -> ::std::os::raw::c_int;
5310}
5311extern "C" {
5312 #[doc = " Free all the memory allocated for an AVDictionary struct\n and all keys and values."]
5313 pub fn av_dict_free(m: *mut *mut AVDictionary);
5314}
5315extern "C" {
5316 #[doc = " Get dictionary entries as a string.\n\n Create a string containing dictionary's entries.\n Such string may be passed back to av_dict_parse_string().\n @note String is escaped with backslashes ('\\').\n\n @warning Separators cannot be neither '\\\\' nor '\\0'. They also cannot be the same.\n\n @param[in] m The dictionary\n @param[out] buffer Pointer to buffer that will be allocated with string containg entries.\n Buffer must be freed by the caller when is no longer needed.\n @param[in] key_val_sep Character used to separate key from value\n @param[in] pairs_sep Character used to separate two pairs from each other\n\n @return >= 0 on success, negative on error"]
5317 pub fn av_dict_get_string(
5318 m: *const AVDictionary,
5319 buffer: *mut *mut ::std::os::raw::c_char,
5320 key_val_sep: ::std::os::raw::c_char,
5321 pairs_sep: ::std::os::raw::c_char,
5322 ) -> ::std::os::raw::c_int;
5323}
5324#[doc = " An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE\n bytes worth of palette. This side data signals that a new palette is\n present."]
5325pub const AVPacketSideDataType_AV_PKT_DATA_PALETTE: AVPacketSideDataType = 0;
5326#[doc = " The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format\n that the extradata buffer was changed and the receiving side should\n act upon it appropriately. The new extradata is embedded in the side\n data buffer and should be immediately used for processing the current\n frame or packet."]
5327pub const AVPacketSideDataType_AV_PKT_DATA_NEW_EXTRADATA: AVPacketSideDataType = 1;
5328#[doc = " An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:\n @code\n u32le param_flags\n if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT)\n s32le channel_count\n if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)\n u64le channel_layout\n if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)\n s32le sample_rate\n if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)\n s32le width\n s32le height\n @endcode"]
5329pub const AVPacketSideDataType_AV_PKT_DATA_PARAM_CHANGE: AVPacketSideDataType = 2;
5330#[doc = " An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of\n structures with info about macroblocks relevant to splitting the\n packet into smaller packets on macroblock edges (e.g. as for RFC 2190).\n That is, it does not necessarily contain info about all macroblocks,\n as long as the distance between macroblocks in the info is smaller\n than the target payload size.\n Each MB info structure is 12 bytes, and is laid out as follows:\n @code\n u32le bit offset from the start of the packet\n u8 current quantizer at the start of the macroblock\n u8 GOB number\n u16le macroblock address within the GOB\n u8 horizontal MV predictor\n u8 vertical MV predictor\n u8 horizontal MV predictor for block number 3\n u8 vertical MV predictor for block number 3\n @endcode"]
5331pub const AVPacketSideDataType_AV_PKT_DATA_H263_MB_INFO: AVPacketSideDataType = 3;
5332#[doc = " This side data should be associated with an audio stream and contains\n ReplayGain information in form of the AVReplayGain struct."]
5333pub const AVPacketSideDataType_AV_PKT_DATA_REPLAYGAIN: AVPacketSideDataType = 4;
5334#[doc = " This side data contains a 3x3 transformation matrix describing an affine\n transformation that needs to be applied to the decoded video frames for\n correct presentation.\n\n See libavutil/display.h for a detailed description of the data."]
5335pub const AVPacketSideDataType_AV_PKT_DATA_DISPLAYMATRIX: AVPacketSideDataType = 5;
5336#[doc = " This side data should be associated with a video stream and contains\n Stereoscopic 3D information in form of the AVStereo3D struct."]
5337pub const AVPacketSideDataType_AV_PKT_DATA_STEREO3D: AVPacketSideDataType = 6;
5338#[doc = " This side data should be associated with an audio stream and corresponds\n to enum AVAudioServiceType."]
5339pub const AVPacketSideDataType_AV_PKT_DATA_AUDIO_SERVICE_TYPE: AVPacketSideDataType = 7;
5340#[doc = " This side data contains quality related information from the encoder.\n @code\n u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad).\n u8 picture type\n u8 error count\n u16 reserved\n u64le[error count] sum of squared differences between encoder in and output\n @endcode"]
5341pub const AVPacketSideDataType_AV_PKT_DATA_QUALITY_STATS: AVPacketSideDataType = 8;
5342#[doc = " This side data contains an integer value representing the stream index\n of a \"fallback\" track. A fallback track indicates an alternate\n track to use when the current track can not be decoded for some reason.\n e.g. no decoder available for codec."]
5343pub const AVPacketSideDataType_AV_PKT_DATA_FALLBACK_TRACK: AVPacketSideDataType = 9;
5344#[doc = " This side data corresponds to the AVCPBProperties struct."]
5345pub const AVPacketSideDataType_AV_PKT_DATA_CPB_PROPERTIES: AVPacketSideDataType = 10;
5346#[doc = " Recommmends skipping the specified number of samples\n @code\n u32le number of samples to skip from start of this packet\n u32le number of samples to skip from end of this packet\n u8 reason for start skip\n u8 reason for end skip (0=padding silence, 1=convergence)\n @endcode"]
5347pub const AVPacketSideDataType_AV_PKT_DATA_SKIP_SAMPLES: AVPacketSideDataType = 11;
5348#[doc = " An AV_PKT_DATA_JP_DUALMONO side data packet indicates that\n the packet may contain \"dual mono\" audio specific to Japanese DTV\n and if it is true, recommends only the selected channel to be used.\n @code\n u8 selected channels (0=main/left, 1=sub/right, 2=both)\n @endcode"]
5349pub const AVPacketSideDataType_AV_PKT_DATA_JP_DUALMONO: AVPacketSideDataType = 12;
5350#[doc = " A list of zero terminated key/value strings. There is no end marker for\n the list, so it is required to rely on the side data size to stop."]
5351pub const AVPacketSideDataType_AV_PKT_DATA_STRINGS_METADATA: AVPacketSideDataType = 13;
5352#[doc = " Subtitle event position\n @code\n u32le x1\n u32le y1\n u32le x2\n u32le y2\n @endcode"]
5353pub const AVPacketSideDataType_AV_PKT_DATA_SUBTITLE_POSITION: AVPacketSideDataType = 14;
5354#[doc = " Data found in BlockAdditional element of matroska container. There is\n no end marker for the data, so it is required to rely on the side data\n size to recognize the end. 8 byte id (as found in BlockAddId) followed\n by data."]
5355pub const AVPacketSideDataType_AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL: AVPacketSideDataType = 15;
5356#[doc = " The optional first identifier line of a WebVTT cue."]
5357pub const AVPacketSideDataType_AV_PKT_DATA_WEBVTT_IDENTIFIER: AVPacketSideDataType = 16;
5358#[doc = " The optional settings (rendering instructions) that immediately\n follow the timestamp specifier of a WebVTT cue."]
5359pub const AVPacketSideDataType_AV_PKT_DATA_WEBVTT_SETTINGS: AVPacketSideDataType = 17;
5360#[doc = " A list of zero terminated key/value strings. There is no end marker for\n the list, so it is required to rely on the side data size to stop. This\n side data includes updated metadata which appeared in the stream."]
5361pub const AVPacketSideDataType_AV_PKT_DATA_METADATA_UPDATE: AVPacketSideDataType = 18;
5362#[doc = " MPEGTS stream ID as uint8_t, this is required to pass the stream ID\n information from the demuxer to the corresponding muxer."]
5363pub const AVPacketSideDataType_AV_PKT_DATA_MPEGTS_STREAM_ID: AVPacketSideDataType = 19;
5364#[doc = " Mastering display metadata (based on SMPTE-2086:2014). This metadata\n should be associated with a video stream and contains data in the form\n of the AVMasteringDisplayMetadata struct."]
5365pub const AVPacketSideDataType_AV_PKT_DATA_MASTERING_DISPLAY_METADATA: AVPacketSideDataType = 20;
5366#[doc = " This side data should be associated with a video stream and corresponds\n to the AVSphericalMapping structure."]
5367pub const AVPacketSideDataType_AV_PKT_DATA_SPHERICAL: AVPacketSideDataType = 21;
5368#[doc = " Content light level (based on CTA-861.3). This metadata should be\n associated with a video stream and contains data in the form of the\n AVContentLightMetadata struct."]
5369pub const AVPacketSideDataType_AV_PKT_DATA_CONTENT_LIGHT_LEVEL: AVPacketSideDataType = 22;
5370#[doc = " ATSC A53 Part 4 Closed Captions. This metadata should be associated with\n a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data.\n The number of bytes of CC data is AVPacketSideData.size."]
5371pub const AVPacketSideDataType_AV_PKT_DATA_A53_CC: AVPacketSideDataType = 23;
5372#[doc = " This side data is encryption initialization data.\n The format is not part of ABI, use av_encryption_init_info_* methods to\n access."]
5373pub const AVPacketSideDataType_AV_PKT_DATA_ENCRYPTION_INIT_INFO: AVPacketSideDataType = 24;
5374#[doc = " This side data contains encryption info for how to decrypt the packet.\n The format is not part of ABI, use av_encryption_info_* methods to access."]
5375pub const AVPacketSideDataType_AV_PKT_DATA_ENCRYPTION_INFO: AVPacketSideDataType = 25;
5376#[doc = " Active Format Description data consisting of a single byte as specified\n in ETSI TS 101 154 using AVActiveFormatDescription enum."]
5377pub const AVPacketSideDataType_AV_PKT_DATA_AFD: AVPacketSideDataType = 26;
5378#[doc = " Producer Reference Time data corresponding to the AVProducerReferenceTime struct,\n usually exported by some encoders (on demand through the prft flag set in the\n AVCodecContext export_side_data field)."]
5379pub const AVPacketSideDataType_AV_PKT_DATA_PRFT: AVPacketSideDataType = 27;
5380#[doc = " ICC profile data consisting of an opaque octet buffer following the\n format described by ISO 15076-1."]
5381pub const AVPacketSideDataType_AV_PKT_DATA_ICC_PROFILE: AVPacketSideDataType = 28;
5382#[doc = " DOVI configuration\n ref:\n dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2, section 2.2\n dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2, section 3.3\n Tags are stored in struct AVDOVIDecoderConfigurationRecord."]
5383pub const AVPacketSideDataType_AV_PKT_DATA_DOVI_CONF: AVPacketSideDataType = 29;
5384#[doc = " Timecode which conforms to SMPTE ST 12-1:2014. The data is an array of 4 uint32_t\n where the first uint32_t describes how many (1-3) of the other timecodes are used.\n The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()\n function in libavutil/timecode.h."]
5385pub const AVPacketSideDataType_AV_PKT_DATA_S12M_TIMECODE: AVPacketSideDataType = 30;
5386#[doc = " HDR10+ dynamic metadata associated with a video frame. The metadata is in\n the form of the AVDynamicHDRPlus struct and contains\n information for color volume transform - application 4 of\n SMPTE 2094-40:2016 standard."]
5387pub const AVPacketSideDataType_AV_PKT_DATA_DYNAMIC_HDR10_PLUS: AVPacketSideDataType = 31;
5388#[doc = " IAMF Mix Gain Parameter Data associated with the audio frame. This metadata\n is in the form of the AVIAMFParamDefinition struct and contains information\n defined in sections 3.6.1 and 3.8.1 of the Immersive Audio Model and\n Formats standard."]
5389pub const AVPacketSideDataType_AV_PKT_DATA_IAMF_MIX_GAIN_PARAM: AVPacketSideDataType = 32;
5390#[doc = " IAMF Demixing Info Parameter Data associated with the audio frame. This\n metadata is in the form of the AVIAMFParamDefinition struct and contains\n information defined in sections 3.6.1 and 3.8.2 of the Immersive Audio Model\n and Formats standard."]
5391pub const AVPacketSideDataType_AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM: AVPacketSideDataType = 33;
5392#[doc = " IAMF Recon Gain Info Parameter Data associated with the audio frame. This\n metadata is in the form of the AVIAMFParamDefinition struct and contains\n information defined in sections 3.6.1 and 3.8.3 of the Immersive Audio Model\n and Formats standard."]
5393pub const AVPacketSideDataType_AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM: AVPacketSideDataType = 34;
5394#[doc = " Ambient viewing environment metadata, as defined by H.274. This metadata\n should be associated with a video stream and contains data in the form\n of the AVAmbientViewingEnvironment struct."]
5395pub const AVPacketSideDataType_AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT: AVPacketSideDataType = 35;
5396#[doc = " The number of side data types.\n This is not part of the public API/ABI in the sense that it may\n change when new side data types are added.\n This must stay the last enum value.\n If its value becomes huge, some code using it\n needs to be updated as it assumes it to be smaller than other limits."]
5397pub const AVPacketSideDataType_AV_PKT_DATA_NB: AVPacketSideDataType = 36;
5398#[doc = " @defgroup lavc_packet_side_data AVPacketSideData\n\n Types and functions for working with AVPacketSideData.\n @{"]
5399pub type AVPacketSideDataType = ::std::os::raw::c_uint;
5400#[doc = " This structure stores auxiliary information for decoding, presenting, or\n otherwise processing the coded stream. It is typically exported by demuxers\n and encoders and can be fed to decoders and muxers either in a per packet\n basis, or as global side data (applying to the entire coded stream).\n\n Global side data is handled as follows:\n - During demuxing, it may be exported through\n @ref AVStream.codecpar.side_data \"AVStream's codec parameters\", which can\n then be passed as input to decoders through the\n @ref AVCodecContext.coded_side_data \"decoder context's side data\", for\n initialization.\n - For muxing, it can be fed through @ref AVStream.codecpar.side_data\n \"AVStream's codec parameters\", typically the output of encoders through\n the @ref AVCodecContext.coded_side_data \"encoder context's side data\", for\n initialization.\n\n Packet specific side data is handled as follows:\n - During demuxing, it may be exported through @ref AVPacket.side_data\n \"AVPacket's side data\", which can then be passed as input to decoders.\n - For muxing, it can be fed through @ref AVPacket.side_data \"AVPacket's\n side data\", typically the output of encoders.\n\n Different modules may accept or export different types of side data\n depending on media type and codec. Refer to @ref AVPacketSideDataType for a\n list of defined types and where they may be found or used."]
5401#[repr(C)]
5402#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5403pub struct AVPacketSideData {
5404 pub data: *mut u8,
5405 pub size: usize,
5406 pub type_: AVPacketSideDataType,
5407}
5408impl Default for AVPacketSideData {
5409 fn default() -> Self {
5410 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5411 unsafe {
5412 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5413 s.assume_init()
5414 }
5415 }
5416}
5417extern "C" {
5418 #[doc = " Allocate a new packet side data.\n\n @param sd pointer to an array of side data to which the side data should\n be added. *sd may be NULL, in which case the array will be\n initialized.\n @param nb_sd pointer to an integer containing the number of entries in\n the array. The integer value will be increased by 1 on success.\n @param type side data type\n @param size desired side data size\n @param flags currently unused. Must be zero\n\n @return pointer to freshly allocated side data on success, or NULL otherwise."]
5419 pub fn av_packet_side_data_new(
5420 psd: *mut *mut AVPacketSideData,
5421 pnb_sd: *mut ::std::os::raw::c_int,
5422 type_: AVPacketSideDataType,
5423 size: usize,
5424 flags: ::std::os::raw::c_int,
5425 ) -> *mut AVPacketSideData;
5426}
5427extern "C" {
5428 #[doc = " Wrap existing data as packet side data.\n\n @param sd pointer to an array of side data to which the side data should\n be added. *sd may be NULL, in which case the array will be\n initialized\n @param nb_sd pointer to an integer containing the number of entries in\n the array. The integer value will be increased by 1 on success.\n @param type side data type\n @param data a data array. It must be allocated with the av_malloc() family\n of functions. The ownership of the data is transferred to the\n side data array on success\n @param size size of the data array\n @param flags currently unused. Must be zero\n\n @return pointer to freshly allocated side data on success, or NULL otherwise\n On failure, the side data array is unchanged and the data remains\n owned by the caller."]
5429 pub fn av_packet_side_data_add(
5430 sd: *mut *mut AVPacketSideData,
5431 nb_sd: *mut ::std::os::raw::c_int,
5432 type_: AVPacketSideDataType,
5433 data: *mut ::std::os::raw::c_void,
5434 size: usize,
5435 flags: ::std::os::raw::c_int,
5436 ) -> *mut AVPacketSideData;
5437}
5438extern "C" {
5439 #[doc = " Get side information from a side data array.\n\n @param sd the array from which the side data should be fetched\n @param nb_sd value containing the number of entries in the array.\n @param type desired side information type\n\n @return pointer to side data if present or NULL otherwise"]
5440 pub fn av_packet_side_data_get(
5441 sd: *const AVPacketSideData,
5442 nb_sd: ::std::os::raw::c_int,
5443 type_: AVPacketSideDataType,
5444 ) -> *const AVPacketSideData;
5445}
5446extern "C" {
5447 #[doc = " Remove side data of the given type from a side data array.\n\n @param sd the array from which the side data should be removed\n @param nb_sd pointer to an integer containing the number of entries in\n the array. Will be reduced by the amount of entries removed\n upon return\n @param type side information type"]
5448 pub fn av_packet_side_data_remove(
5449 sd: *mut AVPacketSideData,
5450 nb_sd: *mut ::std::os::raw::c_int,
5451 type_: AVPacketSideDataType,
5452 );
5453}
5454extern "C" {
5455 #[doc = " Convenience function to free all the side data stored in an array, and\n the array itself.\n\n @param sd pointer to array of side data to free. Will be set to NULL\n upon return.\n @param nb_sd pointer to an integer containing the number of entries in\n the array. Will be set to 0 upon return."]
5456 pub fn av_packet_side_data_free(
5457 sd: *mut *mut AVPacketSideData,
5458 nb_sd: *mut ::std::os::raw::c_int,
5459 );
5460}
5461extern "C" {
5462 pub fn av_packet_side_data_name(type_: AVPacketSideDataType) -> *const ::std::os::raw::c_char;
5463}
5464#[doc = " This structure stores compressed data. It is typically exported by demuxers\n and then passed as input to decoders, or received as output from encoders and\n then passed to muxers.\n\n For video, it should typically contain one compressed frame. For audio it may\n contain several compressed frames. Encoders are allowed to output empty\n packets, with no compressed data, containing only side data\n (e.g. to update some stream parameters at the end of encoding).\n\n The semantics of data ownership depends on the buf field.\n If it is set, the packet data is dynamically allocated and is\n valid indefinitely until a call to av_packet_unref() reduces the\n reference count to 0.\n\n If the buf field is not set av_packet_ref() would make a copy instead\n of increasing the reference count.\n\n The side data is always allocated with av_malloc(), copied by\n av_packet_ref() and freed by av_packet_unref().\n\n sizeof(AVPacket) being a part of the public ABI is deprecated. once\n av_init_packet() is removed, new packets will only be able to be allocated\n with av_packet_alloc(), and new fields may be added to the end of the struct\n with a minor bump.\n\n @see av_packet_alloc\n @see av_packet_ref\n @see av_packet_unref"]
5465#[repr(C)]
5466#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5467pub struct AVPacket {
5468 #[doc = " A reference to the reference-counted buffer where the packet data is\n stored.\n May be NULL, then the packet data is not reference-counted."]
5469 pub buf: *mut AVBufferRef,
5470 #[doc = " Presentation timestamp in AVStream->time_base units; the time at which\n the decompressed packet will be presented to the user.\n Can be AV_NOPTS_VALUE if it is not stored in the file.\n pts MUST be larger or equal to dts as presentation cannot happen before\n decompression, unless one wants to view hex dumps. Some formats misuse\n the terms dts and pts/cts to mean something different. Such timestamps\n must be converted to true pts/dts before they are stored in AVPacket."]
5471 pub pts: i64,
5472 #[doc = " Decompression timestamp in AVStream->time_base units; the time at which\n the packet is decompressed.\n Can be AV_NOPTS_VALUE if it is not stored in the file."]
5473 pub dts: i64,
5474 pub data: *mut u8,
5475 pub size: ::std::os::raw::c_int,
5476 pub stream_index: ::std::os::raw::c_int,
5477 #[doc = " A combination of AV_PKT_FLAG values"]
5478 pub flags: ::std::os::raw::c_int,
5479 #[doc = " Additional packet data that can be provided by the container.\n Packet can contain several types of side information."]
5480 pub side_data: *mut AVPacketSideData,
5481 pub side_data_elems: ::std::os::raw::c_int,
5482 #[doc = " Duration of this packet in AVStream->time_base units, 0 if unknown.\n Equals next_pts - this_pts in presentation order."]
5483 pub duration: i64,
5484 #[doc = "< byte position in stream, -1 if unknown"]
5485 pub pos: i64,
5486 #[doc = " for some private data of the user"]
5487 pub opaque: *mut ::std::os::raw::c_void,
5488 #[doc = " AVBufferRef for free use by the API user. FFmpeg will never check the\n contents of the buffer ref. FFmpeg calls av_buffer_unref() on it when\n the packet is unreferenced. av_packet_copy_props() calls create a new\n reference with av_buffer_ref() for the target packet's opaque_ref field.\n\n This is unrelated to the opaque field, although it serves a similar\n purpose."]
5489 pub opaque_ref: *mut AVBufferRef,
5490 #[doc = " Time base of the packet's timestamps.\n In the future, this field may be set on packets output by encoders or\n demuxers, but its value will be by default ignored on input to decoders\n or muxers."]
5491 pub time_base: AVRational,
5492}
5493impl Default for AVPacket {
5494 fn default() -> Self {
5495 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5496 unsafe {
5497 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5498 s.assume_init()
5499 }
5500 }
5501}
5502#[repr(C)]
5503#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5504pub struct AVPacketList {
5505 pub pkt: AVPacket,
5506 pub next: *mut AVPacketList,
5507}
5508impl Default for AVPacketList {
5509 fn default() -> Self {
5510 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5511 unsafe {
5512 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5513 s.assume_init()
5514 }
5515 }
5516}
5517pub const AVSideDataParamChangeFlags_AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE:
5518 AVSideDataParamChangeFlags = 4;
5519pub const AVSideDataParamChangeFlags_AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS:
5520 AVSideDataParamChangeFlags = 8;
5521pub type AVSideDataParamChangeFlags = ::std::os::raw::c_uint;
5522extern "C" {
5523 #[doc = " Allocate an AVPacket and set its fields to default values. The resulting\n struct must be freed using av_packet_free().\n\n @return An AVPacket filled with default values or NULL on failure.\n\n @note this only allocates the AVPacket itself, not the data buffers. Those\n must be allocated through other means such as av_new_packet.\n\n @see av_new_packet"]
5524 pub fn av_packet_alloc() -> *mut AVPacket;
5525}
5526extern "C" {
5527 #[doc = " Create a new packet that references the same data as src.\n\n This is a shortcut for av_packet_alloc()+av_packet_ref().\n\n @return newly created AVPacket on success, NULL on error.\n\n @see av_packet_alloc\n @see av_packet_ref"]
5528 pub fn av_packet_clone(src: *const AVPacket) -> *mut AVPacket;
5529}
5530extern "C" {
5531 #[doc = " Free the packet, if the packet is reference counted, it will be\n unreferenced first.\n\n @param pkt packet to be freed. The pointer will be set to NULL.\n @note passing NULL is a no-op."]
5532 pub fn av_packet_free(pkt: *mut *mut AVPacket);
5533}
5534extern "C" {
5535 #[doc = " Initialize optional fields of a packet with default values.\n\n Note, this does not touch the data and size members, which have to be\n initialized separately.\n\n @param pkt packet\n\n @see av_packet_alloc\n @see av_packet_unref\n\n @deprecated This function is deprecated. Once it's removed,\nsizeof(AVPacket) will not be a part of the ABI anymore."]
5536 pub fn av_init_packet(pkt: *mut AVPacket);
5537}
5538extern "C" {
5539 #[doc = " Allocate the payload of a packet and initialize its fields with\n default values.\n\n @param pkt packet\n @param size wanted payload size\n @return 0 if OK, AVERROR_xxx otherwise"]
5540 pub fn av_new_packet(pkt: *mut AVPacket, size: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
5541}
5542extern "C" {
5543 #[doc = " Reduce packet size, correctly zeroing padding\n\n @param pkt packet\n @param size new size"]
5544 pub fn av_shrink_packet(pkt: *mut AVPacket, size: ::std::os::raw::c_int);
5545}
5546extern "C" {
5547 #[doc = " Increase packet size, correctly zeroing padding\n\n @param pkt packet\n @param grow_by number of bytes by which to increase the size of the packet"]
5548 pub fn av_grow_packet(
5549 pkt: *mut AVPacket,
5550 grow_by: ::std::os::raw::c_int,
5551 ) -> ::std::os::raw::c_int;
5552}
5553extern "C" {
5554 #[doc = " Initialize a reference-counted packet from av_malloc()ed data.\n\n @param pkt packet to be initialized. This function will set the data, size,\n and buf fields, all others are left untouched.\n @param data Data allocated by av_malloc() to be used as packet data. If this\n function returns successfully, the data is owned by the underlying AVBuffer.\n The caller may not access the data through other means.\n @param size size of data in bytes, without the padding. I.e. the full buffer\n size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE.\n\n @return 0 on success, a negative AVERROR on error"]
5555 pub fn av_packet_from_data(
5556 pkt: *mut AVPacket,
5557 data: *mut u8,
5558 size: ::std::os::raw::c_int,
5559 ) -> ::std::os::raw::c_int;
5560}
5561extern "C" {
5562 #[doc = " Allocate new information of a packet.\n\n @param pkt packet\n @param type side information type\n @param size side information size\n @return pointer to fresh allocated data or NULL otherwise"]
5563 pub fn av_packet_new_side_data(
5564 pkt: *mut AVPacket,
5565 type_: AVPacketSideDataType,
5566 size: usize,
5567 ) -> *mut u8;
5568}
5569extern "C" {
5570 #[doc = " Wrap an existing array as a packet side data.\n\n @param pkt packet\n @param type side information type\n @param data the side data array. It must be allocated with the av_malloc()\n family of functions. The ownership of the data is transferred to\n pkt.\n @param size side information size\n @return a non-negative number on success, a negative AVERROR code on\n failure. On failure, the packet is unchanged and the data remains\n owned by the caller."]
5571 pub fn av_packet_add_side_data(
5572 pkt: *mut AVPacket,
5573 type_: AVPacketSideDataType,
5574 data: *mut u8,
5575 size: usize,
5576 ) -> ::std::os::raw::c_int;
5577}
5578extern "C" {
5579 #[doc = " Shrink the already allocated side data buffer\n\n @param pkt packet\n @param type side information type\n @param size new side information size\n @return 0 on success, < 0 on failure"]
5580 pub fn av_packet_shrink_side_data(
5581 pkt: *mut AVPacket,
5582 type_: AVPacketSideDataType,
5583 size: usize,
5584 ) -> ::std::os::raw::c_int;
5585}
5586extern "C" {
5587 #[doc = " Get side information from packet.\n\n @param pkt packet\n @param type desired side information type\n @param size If supplied, *size will be set to the size of the side data\n or to zero if the desired side data is not present.\n @return pointer to data if present or NULL otherwise"]
5588 pub fn av_packet_get_side_data(
5589 pkt: *const AVPacket,
5590 type_: AVPacketSideDataType,
5591 size: *mut usize,
5592 ) -> *mut u8;
5593}
5594extern "C" {
5595 #[doc = " Pack a dictionary for use in side_data.\n\n @param dict The dictionary to pack.\n @param size pointer to store the size of the returned data\n @return pointer to data if successful, NULL otherwise"]
5596 pub fn av_packet_pack_dictionary(dict: *mut AVDictionary, size: *mut usize) -> *mut u8;
5597}
5598extern "C" {
5599 #[doc = " Unpack a dictionary from side_data.\n\n @param data data from side_data\n @param size size of the data\n @param dict the metadata storage dictionary\n @return 0 on success, < 0 on failure"]
5600 pub fn av_packet_unpack_dictionary(
5601 data: *const u8,
5602 size: usize,
5603 dict: *mut *mut AVDictionary,
5604 ) -> ::std::os::raw::c_int;
5605}
5606extern "C" {
5607 #[doc = " Convenience function to free all the side data stored.\n All the other fields stay untouched.\n\n @param pkt packet"]
5608 pub fn av_packet_free_side_data(pkt: *mut AVPacket);
5609}
5610extern "C" {
5611 #[doc = " Setup a new reference to the data described by a given packet\n\n If src is reference-counted, setup dst as a new reference to the\n buffer in src. Otherwise allocate a new buffer in dst and copy the\n data from src into it.\n\n All the other fields are copied from src.\n\n @see av_packet_unref\n\n @param dst Destination packet. Will be completely overwritten.\n @param src Source packet\n\n @return 0 on success, a negative AVERROR on error. On error, dst\n will be blank (as if returned by av_packet_alloc())."]
5612 pub fn av_packet_ref(dst: *mut AVPacket, src: *const AVPacket) -> ::std::os::raw::c_int;
5613}
5614extern "C" {
5615 #[doc = " Wipe the packet.\n\n Unreference the buffer referenced by the packet and reset the\n remaining packet fields to their default values.\n\n @param pkt The packet to be unreferenced."]
5616 pub fn av_packet_unref(pkt: *mut AVPacket);
5617}
5618extern "C" {
5619 #[doc = " Move every field in src to dst and reset src.\n\n @see av_packet_unref\n\n @param src Source packet, will be reset\n @param dst Destination packet"]
5620 pub fn av_packet_move_ref(dst: *mut AVPacket, src: *mut AVPacket);
5621}
5622extern "C" {
5623 #[doc = " Copy only \"properties\" fields from src to dst.\n\n Properties for the purpose of this function are all the fields\n beside those related to the packet data (buf, data, size)\n\n @param dst Destination packet\n @param src Source packet\n\n @return 0 on success AVERROR on failure."]
5624 pub fn av_packet_copy_props(dst: *mut AVPacket, src: *const AVPacket) -> ::std::os::raw::c_int;
5625}
5626extern "C" {
5627 #[doc = " Ensure the data described by a given packet is reference counted.\n\n @note This function does not ensure that the reference will be writable.\n Use av_packet_make_writable instead for that purpose.\n\n @see av_packet_ref\n @see av_packet_make_writable\n\n @param pkt packet whose data should be made reference counted.\n\n @return 0 on success, a negative AVERROR on error. On failure, the\n packet is unchanged."]
5628 pub fn av_packet_make_refcounted(pkt: *mut AVPacket) -> ::std::os::raw::c_int;
5629}
5630extern "C" {
5631 #[doc = " Create a writable reference for the data described by a given packet,\n avoiding data copy if possible.\n\n @param pkt Packet whose data should be made writable.\n\n @return 0 on success, a negative AVERROR on failure. On failure, the\n packet is unchanged."]
5632 pub fn av_packet_make_writable(pkt: *mut AVPacket) -> ::std::os::raw::c_int;
5633}
5634extern "C" {
5635 #[doc = " Convert valid timing fields (timestamps / durations) in a packet from one\n timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be\n ignored.\n\n @param pkt packet on which the conversion will be performed\n @param tb_src source timebase, in which the timing fields in pkt are\n expressed\n @param tb_dst destination timebase, to which the timing fields will be\n converted"]
5636 pub fn av_packet_rescale_ts(pkt: *mut AVPacket, tb_src: AVRational, tb_dst: AVRational);
5637}
5638#[doc = " This struct describes the properties of an encoded stream.\n\n sizeof(AVCodecParameters) is not a part of the public ABI, this struct must\n be allocated with avcodec_parameters_alloc() and freed with\n avcodec_parameters_free()."]
5639#[repr(C)]
5640#[derive(Copy, Clone)]
5641pub struct AVCodecParameters {
5642 #[doc = " General type of the encoded data."]
5643 pub codec_type: AVMediaType,
5644 #[doc = " Specific type of the encoded data (the codec used)."]
5645 pub codec_id: AVCodecID,
5646 #[doc = " Additional information about the codec (corresponds to the AVI FOURCC)."]
5647 pub codec_tag: u32,
5648 #[doc = " Extra binary data needed for initializing the decoder, codec-dependent.\n\n Must be allocated with av_malloc() and will be freed by\n avcodec_parameters_free(). The allocated size of extradata must be at\n least extradata_size + AV_INPUT_BUFFER_PADDING_SIZE, with the padding\n bytes zeroed."]
5649 pub extradata: *mut u8,
5650 #[doc = " Size of the extradata content in bytes."]
5651 pub extradata_size: ::std::os::raw::c_int,
5652 #[doc = " Additional data associated with the entire stream.\n\n Should be allocated with av_packet_side_data_new() or\n av_packet_side_data_add(), and will be freed by avcodec_parameters_free()."]
5653 pub coded_side_data: *mut AVPacketSideData,
5654 #[doc = " Amount of entries in @ref coded_side_data."]
5655 pub nb_coded_side_data: ::std::os::raw::c_int,
5656 #[doc = " - video: the pixel format, the value corresponds to enum AVPixelFormat.\n - audio: the sample format, the value corresponds to enum AVSampleFormat."]
5657 pub format: ::std::os::raw::c_int,
5658 #[doc = " The average bitrate of the encoded data (in bits per second)."]
5659 pub bit_rate: i64,
5660 #[doc = " The number of bits per sample in the codedwords.\n\n This is basically the bitrate per sample. It is mandatory for a bunch of\n formats to actually decode them. It's the number of bits for one sample in\n the actual coded bitstream.\n\n This could be for example 4 for ADPCM\n For PCM formats this matches bits_per_raw_sample\n Can be 0"]
5661 pub bits_per_coded_sample: ::std::os::raw::c_int,
5662 #[doc = " This is the number of valid bits in each output sample. If the\n sample format has more bits, the least significant bits are additional\n padding bits, which are always 0. Use right shifts to reduce the sample\n to its actual size. For example, audio formats with 24 bit samples will\n have bits_per_raw_sample set to 24, and format set to AV_SAMPLE_FMT_S32.\n To get the original sample use \"(int32_t)sample >> 8\".\"\n\n For ADPCM this might be 12 or 16 or similar\n Can be 0"]
5663 pub bits_per_raw_sample: ::std::os::raw::c_int,
5664 #[doc = " Codec-specific bitstream restrictions that the stream conforms to."]
5665 pub profile: ::std::os::raw::c_int,
5666 pub level: ::std::os::raw::c_int,
5667 #[doc = " Video only. The dimensions of the video frame in pixels."]
5668 pub width: ::std::os::raw::c_int,
5669 pub height: ::std::os::raw::c_int,
5670 #[doc = " Video only. The aspect ratio (width / height) which a single pixel\n should have when displayed.\n\n When the aspect ratio is unknown / undefined, the numerator should be\n set to 0 (the denominator may have any value)."]
5671 pub sample_aspect_ratio: AVRational,
5672 #[doc = " Video only. Number of frames per second, for streams with constant frame\n durations. Should be set to { 0, 1 } when some frames have differing\n durations or if the value is not known.\n\n @note This field correponds to values that are stored in codec-level\n headers and is typically overridden by container/transport-layer\n timestamps, when available. It should thus be used only as a last resort,\n when no higher-level timing information is available."]
5673 pub framerate: AVRational,
5674 #[doc = " Video only. The order of the fields in interlaced video."]
5675 pub field_order: AVFieldOrder,
5676 #[doc = " Video only. Additional colorspace characteristics."]
5677 pub color_range: AVColorRange,
5678 pub color_primaries: AVColorPrimaries,
5679 pub color_trc: AVColorTransferCharacteristic,
5680 pub color_space: AVColorSpace,
5681 pub chroma_location: AVChromaLocation,
5682 #[doc = " Video only. Number of delayed frames."]
5683 pub video_delay: ::std::os::raw::c_int,
5684 #[doc = " Audio only. The channel layout and number of channels."]
5685 pub ch_layout: AVChannelLayout,
5686 #[doc = " Audio only. The number of audio samples per second."]
5687 pub sample_rate: ::std::os::raw::c_int,
5688 #[doc = " Audio only. The number of bytes per coded audio frame, required by some\n formats.\n\n Corresponds to nBlockAlign in WAVEFORMATEX."]
5689 pub block_align: ::std::os::raw::c_int,
5690 #[doc = " Audio only. Audio frame size, if known. Required by some formats to be static."]
5691 pub frame_size: ::std::os::raw::c_int,
5692 #[doc = " Audio only. The amount of padding (in samples) inserted by the encoder at\n the beginning of the audio. I.e. this number of leading decoded samples\n must be discarded by the caller to get the original audio without leading\n padding."]
5693 pub initial_padding: ::std::os::raw::c_int,
5694 #[doc = " Audio only. The amount of padding (in samples) appended by the encoder to\n the end of the audio. I.e. this number of decoded samples must be\n discarded by the caller from the end of the stream to get the original\n audio without any trailing padding."]
5695 pub trailing_padding: ::std::os::raw::c_int,
5696 #[doc = " Audio only. Number of samples to skip after a discontinuity."]
5697 pub seek_preroll: ::std::os::raw::c_int,
5698}
5699impl Default for AVCodecParameters {
5700 fn default() -> Self {
5701 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5702 unsafe {
5703 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5704 s.assume_init()
5705 }
5706 }
5707}
5708extern "C" {
5709 #[doc = " Allocate a new AVCodecParameters and set its fields to default values\n (unknown/invalid/0). The returned struct must be freed with\n avcodec_parameters_free()."]
5710 pub fn avcodec_parameters_alloc() -> *mut AVCodecParameters;
5711}
5712extern "C" {
5713 #[doc = " Free an AVCodecParameters instance and everything associated with it and\n write NULL to the supplied pointer."]
5714 pub fn avcodec_parameters_free(par: *mut *mut AVCodecParameters);
5715}
5716extern "C" {
5717 #[doc = " Copy the contents of src to dst. Any allocated fields in dst are freed and\n replaced with newly allocated duplicates of the corresponding fields in src.\n\n @return >= 0 on success, a negative AVERROR code on failure."]
5718 pub fn avcodec_parameters_copy(
5719 dst: *mut AVCodecParameters,
5720 src: *const AVCodecParameters,
5721 ) -> ::std::os::raw::c_int;
5722}
5723extern "C" {
5724 #[doc = " This function is the same as av_get_audio_frame_duration(), except it works\n with AVCodecParameters instead of an AVCodecContext."]
5725 pub fn av_get_audio_frame_duration2(
5726 par: *mut AVCodecParameters,
5727 frame_bytes: ::std::os::raw::c_int,
5728 ) -> ::std::os::raw::c_int;
5729}
5730#[doc = " Callback for checking whether to abort blocking functions.\n AVERROR_EXIT is returned in this case by the interrupted\n function. During blocking operations, callback is called with\n opaque as parameter. If the callback returns 1, the\n blocking operation will be aborted.\n\n No members can be added to this struct without a major bump, if\n new elements have been added after this struct in AVFormatContext\n or AVIOContext."]
5731#[repr(C)]
5732#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5733pub struct AVIOInterruptCB {
5734 pub callback: ::std::option::Option<
5735 unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
5736 >,
5737 pub opaque: *mut ::std::os::raw::c_void,
5738}
5739impl Default for AVIOInterruptCB {
5740 fn default() -> Self {
5741 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5742 unsafe {
5743 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5744 s.assume_init()
5745 }
5746 }
5747}
5748pub const AVIODirEntryType_AVIO_ENTRY_UNKNOWN: AVIODirEntryType = 0;
5749pub const AVIODirEntryType_AVIO_ENTRY_BLOCK_DEVICE: AVIODirEntryType = 1;
5750pub const AVIODirEntryType_AVIO_ENTRY_CHARACTER_DEVICE: AVIODirEntryType = 2;
5751pub const AVIODirEntryType_AVIO_ENTRY_DIRECTORY: AVIODirEntryType = 3;
5752pub const AVIODirEntryType_AVIO_ENTRY_NAMED_PIPE: AVIODirEntryType = 4;
5753pub const AVIODirEntryType_AVIO_ENTRY_SYMBOLIC_LINK: AVIODirEntryType = 5;
5754pub const AVIODirEntryType_AVIO_ENTRY_SOCKET: AVIODirEntryType = 6;
5755pub const AVIODirEntryType_AVIO_ENTRY_FILE: AVIODirEntryType = 7;
5756pub const AVIODirEntryType_AVIO_ENTRY_SERVER: AVIODirEntryType = 8;
5757pub const AVIODirEntryType_AVIO_ENTRY_SHARE: AVIODirEntryType = 9;
5758pub const AVIODirEntryType_AVIO_ENTRY_WORKGROUP: AVIODirEntryType = 10;
5759#[doc = " Directory entry types."]
5760pub type AVIODirEntryType = ::std::os::raw::c_uint;
5761#[doc = " Describes single entry of the directory.\n\n Only name and type fields are guaranteed be set.\n Rest of fields are protocol or/and platform dependent and might be unknown."]
5762#[repr(C)]
5763#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5764pub struct AVIODirEntry {
5765 #[doc = "< Filename"]
5766 pub name: *mut ::std::os::raw::c_char,
5767 #[doc = "< Type of the entry"]
5768 pub type_: ::std::os::raw::c_int,
5769 #[doc = "< Set to 1 when name is encoded with UTF-8, 0 otherwise.\nName can be encoded with UTF-8 even though 0 is set."]
5770 pub utf8: ::std::os::raw::c_int,
5771 #[doc = "< File size in bytes, -1 if unknown."]
5772 pub size: i64,
5773 #[doc = "< Time of last modification in microseconds since unix\nepoch, -1 if unknown."]
5774 pub modification_timestamp: i64,
5775 #[doc = "< Time of last access in microseconds since unix epoch,\n-1 if unknown."]
5776 pub access_timestamp: i64,
5777 #[doc = "< Time of last status change in microseconds since unix\nepoch, -1 if unknown."]
5778 pub status_change_timestamp: i64,
5779 #[doc = "< User ID of owner, -1 if unknown."]
5780 pub user_id: i64,
5781 #[doc = "< Group ID of owner, -1 if unknown."]
5782 pub group_id: i64,
5783 #[doc = "< Unix file mode, -1 if unknown."]
5784 pub filemode: i64,
5785}
5786impl Default for AVIODirEntry {
5787 fn default() -> Self {
5788 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5789 unsafe {
5790 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5791 s.assume_init()
5792 }
5793 }
5794}
5795#[repr(C)]
5796#[derive(Debug, Copy, Clone)]
5797pub struct AVIODirContext {
5798 _unused: [u8; 0],
5799}
5800#[doc = " Header data; this needs to be present for the stream to be decodeable."]
5801pub const AVIODataMarkerType_AVIO_DATA_MARKER_HEADER: AVIODataMarkerType = 0;
5802#[doc = " A point in the output bytestream where a decoder can start decoding\n (i.e. a keyframe). A demuxer/decoder given the data flagged with\n AVIO_DATA_MARKER_HEADER, followed by any AVIO_DATA_MARKER_SYNC_POINT,\n should give decodeable results."]
5803pub const AVIODataMarkerType_AVIO_DATA_MARKER_SYNC_POINT: AVIODataMarkerType = 1;
5804#[doc = " A point in the output bytestream where a demuxer can start parsing\n (for non self synchronizing bytestream formats). That is, any\n non-keyframe packet start point."]
5805pub const AVIODataMarkerType_AVIO_DATA_MARKER_BOUNDARY_POINT: AVIODataMarkerType = 2;
5806#[doc = " This is any, unlabelled data. It can either be a muxer not marking\n any positions at all, it can be an actual boundary/sync point\n that the muxer chooses not to mark, or a later part of a packet/fragment\n that is cut into multiple write callbacks due to limited IO buffer size."]
5807pub const AVIODataMarkerType_AVIO_DATA_MARKER_UNKNOWN: AVIODataMarkerType = 3;
5808#[doc = " Trailer data, which doesn't contain actual content, but only for\n finalizing the output file."]
5809pub const AVIODataMarkerType_AVIO_DATA_MARKER_TRAILER: AVIODataMarkerType = 4;
5810#[doc = " A point in the output bytestream where the underlying AVIOContext might\n flush the buffer depending on latency or buffering requirements. Typically\n means the end of a packet."]
5811pub const AVIODataMarkerType_AVIO_DATA_MARKER_FLUSH_POINT: AVIODataMarkerType = 5;
5812#[doc = " Different data types that can be returned via the AVIO\n write_data_type callback."]
5813pub type AVIODataMarkerType = ::std::os::raw::c_uint;
5814#[doc = " Bytestream IO Context.\n New public fields can be added with minor version bumps.\n Removal, reordering and changes to existing public fields require\n a major version bump.\n sizeof(AVIOContext) must not be used outside libav*.\n\n @note None of the function pointers in AVIOContext should be called\n directly, they should only be set by the client application\n when implementing custom I/O. Normally these are set to the\n function pointers specified in avio_alloc_context()"]
5815#[repr(C)]
5816#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5817pub struct AVIOContext {
5818 #[doc = " A class for private options.\n\n If this AVIOContext is created by avio_open2(), av_class is set and\n passes the options down to protocols.\n\n If this AVIOContext is manually allocated, then av_class may be set by\n the caller.\n\n warning -- this field can be NULL, be sure to not pass this AVIOContext\n to any av_opt_* functions in that case."]
5819 pub av_class: *const AVClass,
5820 #[doc = "< Start of the buffer."]
5821 pub buffer: *mut ::std::os::raw::c_uchar,
5822 #[doc = "< Maximum buffer size"]
5823 pub buffer_size: ::std::os::raw::c_int,
5824 #[doc = "< Current position in the buffer"]
5825 pub buf_ptr: *mut ::std::os::raw::c_uchar,
5826 #[doc = "< End of the data, may be less than\nbuffer+buffer_size if the read function returned\nless data than requested, e.g. for streams where\nno more data has been received yet."]
5827 pub buf_end: *mut ::std::os::raw::c_uchar,
5828 #[doc = "< A private pointer, passed to the read/write/seek/...\nfunctions."]
5829 pub opaque: *mut ::std::os::raw::c_void,
5830 pub read_packet: ::std::option::Option<
5831 unsafe extern "C" fn(
5832 opaque: *mut ::std::os::raw::c_void,
5833 buf: *mut u8,
5834 buf_size: ::std::os::raw::c_int,
5835 ) -> ::std::os::raw::c_int,
5836 >,
5837 pub write_packet: ::std::option::Option<
5838 unsafe extern "C" fn(
5839 opaque: *mut ::std::os::raw::c_void,
5840 buf: *const u8,
5841 buf_size: ::std::os::raw::c_int,
5842 ) -> ::std::os::raw::c_int,
5843 >,
5844 pub seek: ::std::option::Option<
5845 unsafe extern "C" fn(
5846 opaque: *mut ::std::os::raw::c_void,
5847 offset: i64,
5848 whence: ::std::os::raw::c_int,
5849 ) -> i64,
5850 >,
5851 #[doc = "< position in the file of the current buffer"]
5852 pub pos: i64,
5853 #[doc = "< true if was unable to read due to error or eof"]
5854 pub eof_reached: ::std::os::raw::c_int,
5855 #[doc = "< contains the error code or 0 if no error happened"]
5856 pub error: ::std::os::raw::c_int,
5857 #[doc = "< true if open for writing"]
5858 pub write_flag: ::std::os::raw::c_int,
5859 pub max_packet_size: ::std::os::raw::c_int,
5860 #[doc = "< Try to buffer at least this amount of data\nbefore flushing it."]
5861 pub min_packet_size: ::std::os::raw::c_int,
5862 pub checksum: ::std::os::raw::c_ulong,
5863 pub checksum_ptr: *mut ::std::os::raw::c_uchar,
5864 pub update_checksum: ::std::option::Option<
5865 unsafe extern "C" fn(
5866 checksum: ::std::os::raw::c_ulong,
5867 buf: *const u8,
5868 size: ::std::os::raw::c_uint,
5869 ) -> ::std::os::raw::c_ulong,
5870 >,
5871 #[doc = " Pause or resume playback for network streaming protocols - e.g. MMS."]
5872 pub read_pause: ::std::option::Option<
5873 unsafe extern "C" fn(
5874 opaque: *mut ::std::os::raw::c_void,
5875 pause: ::std::os::raw::c_int,
5876 ) -> ::std::os::raw::c_int,
5877 >,
5878 #[doc = " Seek to a given timestamp in stream with the specified stream_index.\n Needed for some network streaming protocols which don't support seeking\n to byte position."]
5879 pub read_seek: ::std::option::Option<
5880 unsafe extern "C" fn(
5881 opaque: *mut ::std::os::raw::c_void,
5882 stream_index: ::std::os::raw::c_int,
5883 timestamp: i64,
5884 flags: ::std::os::raw::c_int,
5885 ) -> i64,
5886 >,
5887 #[doc = " A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable."]
5888 pub seekable: ::std::os::raw::c_int,
5889 #[doc = " avio_read and avio_write should if possible be satisfied directly\n instead of going through a buffer, and avio_seek will always\n call the underlying seek function directly."]
5890 pub direct: ::std::os::raw::c_int,
5891 #[doc = " ',' separated list of allowed protocols."]
5892 pub protocol_whitelist: *const ::std::os::raw::c_char,
5893 #[doc = " ',' separated list of disallowed protocols."]
5894 pub protocol_blacklist: *const ::std::os::raw::c_char,
5895 #[doc = " A callback that is used instead of write_packet."]
5896 pub write_data_type: ::std::option::Option<
5897 unsafe extern "C" fn(
5898 opaque: *mut ::std::os::raw::c_void,
5899 buf: *const u8,
5900 buf_size: ::std::os::raw::c_int,
5901 type_: AVIODataMarkerType,
5902 time: i64,
5903 ) -> ::std::os::raw::c_int,
5904 >,
5905 #[doc = " If set, don't call write_data_type separately for AVIO_DATA_MARKER_BOUNDARY_POINT,\n but ignore them and treat them as AVIO_DATA_MARKER_UNKNOWN (to avoid needlessly\n small chunks of data returned from the callback)."]
5906 pub ignore_boundary_point: ::std::os::raw::c_int,
5907 #[doc = " Maximum reached position before a backward seek in the write buffer,\n used keeping track of already written data for a later flush."]
5908 pub buf_ptr_max: *mut ::std::os::raw::c_uchar,
5909 #[doc = " Read-only statistic of bytes read for this AVIOContext."]
5910 pub bytes_read: i64,
5911 #[doc = " Read-only statistic of bytes written for this AVIOContext."]
5912 pub bytes_written: i64,
5913}
5914impl Default for AVIOContext {
5915 fn default() -> Self {
5916 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5917 unsafe {
5918 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5919 s.assume_init()
5920 }
5921 }
5922}
5923extern "C" {
5924 #[doc = " Return the name of the protocol that will handle the passed URL.\n\n NULL is returned if no protocol could be found for the given URL.\n\n @return Name of the protocol or NULL."]
5925 pub fn avio_find_protocol_name(
5926 url: *const ::std::os::raw::c_char,
5927 ) -> *const ::std::os::raw::c_char;
5928}
5929extern "C" {
5930 #[doc = " Return AVIO_FLAG_* access flags corresponding to the access permissions\n of the resource in url, or a negative value corresponding to an\n AVERROR code in case of failure. The returned access flags are\n masked by the value in flags.\n\n @note This function is intrinsically unsafe, in the sense that the\n checked resource may change its existence or permission status from\n one call to another. Thus you should not trust the returned value,\n unless you are sure that no other processes are accessing the\n checked resource."]
5931 pub fn avio_check(
5932 url: *const ::std::os::raw::c_char,
5933 flags: ::std::os::raw::c_int,
5934 ) -> ::std::os::raw::c_int;
5935}
5936extern "C" {
5937 #[doc = " Open directory for reading.\n\n @param s directory read context. Pointer to a NULL pointer must be passed.\n @param url directory to be listed.\n @param options A dictionary filled with protocol-private options. On return\n this parameter will be destroyed and replaced with a dictionary\n containing options that were not found. May be NULL.\n @return >=0 on success or negative on error."]
5938 pub fn avio_open_dir(
5939 s: *mut *mut AVIODirContext,
5940 url: *const ::std::os::raw::c_char,
5941 options: *mut *mut AVDictionary,
5942 ) -> ::std::os::raw::c_int;
5943}
5944extern "C" {
5945 #[doc = " Get next directory entry.\n\n Returned entry must be freed with avio_free_directory_entry(). In particular\n it may outlive AVIODirContext.\n\n @param s directory read context.\n @param[out] next next entry or NULL when no more entries.\n @return >=0 on success or negative on error. End of list is not considered an\n error."]
5946 pub fn avio_read_dir(
5947 s: *mut AVIODirContext,
5948 next: *mut *mut AVIODirEntry,
5949 ) -> ::std::os::raw::c_int;
5950}
5951extern "C" {
5952 #[doc = " Close directory.\n\n @note Entries created using avio_read_dir() are not deleted and must be\n freeded with avio_free_directory_entry().\n\n @param s directory read context.\n @return >=0 on success or negative on error."]
5953 pub fn avio_close_dir(s: *mut *mut AVIODirContext) -> ::std::os::raw::c_int;
5954}
5955extern "C" {
5956 #[doc = " Free entry allocated by avio_read_dir().\n\n @param entry entry to be freed."]
5957 pub fn avio_free_directory_entry(entry: *mut *mut AVIODirEntry);
5958}
5959extern "C" {
5960 #[doc = " Allocate and initialize an AVIOContext for buffered I/O. It must be later\n freed with avio_context_free().\n\n @param buffer Memory block for input/output operations via AVIOContext.\n The buffer must be allocated with av_malloc() and friends.\n It may be freed and replaced with a new buffer by libavformat.\n AVIOContext.buffer holds the buffer currently in use,\n which must be later freed with av_free().\n @param buffer_size The buffer size is very important for performance.\n For protocols with fixed blocksize it should be set to this blocksize.\n For others a typical size is a cache page, e.g. 4kb.\n @param write_flag Set to 1 if the buffer should be writable, 0 otherwise.\n @param opaque An opaque pointer to user-specific data.\n @param read_packet A function for refilling the buffer, may be NULL.\n For stream protocols, must never return 0 but rather\n a proper AVERROR code.\n @param write_packet A function for writing the buffer contents, may be NULL.\n The function may not change the input buffers content.\n @param seek A function for seeking to specified byte position, may be NULL.\n\n @return Allocated AVIOContext or NULL on failure."]
5961 pub fn avio_alloc_context(
5962 buffer: *mut ::std::os::raw::c_uchar,
5963 buffer_size: ::std::os::raw::c_int,
5964 write_flag: ::std::os::raw::c_int,
5965 opaque: *mut ::std::os::raw::c_void,
5966 read_packet: ::std::option::Option<
5967 unsafe extern "C" fn(
5968 opaque: *mut ::std::os::raw::c_void,
5969 buf: *mut u8,
5970 buf_size: ::std::os::raw::c_int,
5971 ) -> ::std::os::raw::c_int,
5972 >,
5973 write_packet: ::std::option::Option<
5974 unsafe extern "C" fn(
5975 opaque: *mut ::std::os::raw::c_void,
5976 buf: *const u8,
5977 buf_size: ::std::os::raw::c_int,
5978 ) -> ::std::os::raw::c_int,
5979 >,
5980 seek: ::std::option::Option<
5981 unsafe extern "C" fn(
5982 opaque: *mut ::std::os::raw::c_void,
5983 offset: i64,
5984 whence: ::std::os::raw::c_int,
5985 ) -> i64,
5986 >,
5987 ) -> *mut AVIOContext;
5988}
5989extern "C" {
5990 #[doc = " Free the supplied IO context and everything associated with it.\n\n @param s Double pointer to the IO context. This function will write NULL\n into s."]
5991 pub fn avio_context_free(s: *mut *mut AVIOContext);
5992}
5993extern "C" {
5994 pub fn avio_w8(s: *mut AVIOContext, b: ::std::os::raw::c_int);
5995}
5996extern "C" {
5997 pub fn avio_write(
5998 s: *mut AVIOContext,
5999 buf: *const ::std::os::raw::c_uchar,
6000 size: ::std::os::raw::c_int,
6001 );
6002}
6003extern "C" {
6004 pub fn avio_wl64(s: *mut AVIOContext, val: u64);
6005}
6006extern "C" {
6007 pub fn avio_wb64(s: *mut AVIOContext, val: u64);
6008}
6009extern "C" {
6010 pub fn avio_wl32(s: *mut AVIOContext, val: ::std::os::raw::c_uint);
6011}
6012extern "C" {
6013 pub fn avio_wb32(s: *mut AVIOContext, val: ::std::os::raw::c_uint);
6014}
6015extern "C" {
6016 pub fn avio_wl24(s: *mut AVIOContext, val: ::std::os::raw::c_uint);
6017}
6018extern "C" {
6019 pub fn avio_wb24(s: *mut AVIOContext, val: ::std::os::raw::c_uint);
6020}
6021extern "C" {
6022 pub fn avio_wl16(s: *mut AVIOContext, val: ::std::os::raw::c_uint);
6023}
6024extern "C" {
6025 pub fn avio_wb16(s: *mut AVIOContext, val: ::std::os::raw::c_uint);
6026}
6027extern "C" {
6028 #[doc = " Write a NULL-terminated string.\n @return number of bytes written."]
6029 pub fn avio_put_str(
6030 s: *mut AVIOContext,
6031 str_: *const ::std::os::raw::c_char,
6032 ) -> ::std::os::raw::c_int;
6033}
6034extern "C" {
6035 #[doc = " Convert an UTF-8 string to UTF-16LE and write it.\n @param s the AVIOContext\n @param str NULL-terminated UTF-8 string\n\n @return number of bytes written."]
6036 pub fn avio_put_str16le(
6037 s: *mut AVIOContext,
6038 str_: *const ::std::os::raw::c_char,
6039 ) -> ::std::os::raw::c_int;
6040}
6041extern "C" {
6042 #[doc = " Convert an UTF-8 string to UTF-16BE and write it.\n @param s the AVIOContext\n @param str NULL-terminated UTF-8 string\n\n @return number of bytes written."]
6043 pub fn avio_put_str16be(
6044 s: *mut AVIOContext,
6045 str_: *const ::std::os::raw::c_char,
6046 ) -> ::std::os::raw::c_int;
6047}
6048extern "C" {
6049 #[doc = " Mark the written bytestream as a specific type.\n\n Zero-length ranges are omitted from the output.\n\n @param s the AVIOContext\n @param time the stream time the current bytestream pos corresponds to\n (in AV_TIME_BASE units), or AV_NOPTS_VALUE if unknown or not\n applicable\n @param type the kind of data written starting at the current pos"]
6050 pub fn avio_write_marker(s: *mut AVIOContext, time: i64, type_: AVIODataMarkerType);
6051}
6052extern "C" {
6053 #[doc = " fseek() equivalent for AVIOContext.\n @return new position or AVERROR."]
6054 pub fn avio_seek(s: *mut AVIOContext, offset: i64, whence: ::std::os::raw::c_int) -> i64;
6055}
6056extern "C" {
6057 #[doc = " Skip given number of bytes forward\n @return new position or AVERROR."]
6058 pub fn avio_skip(s: *mut AVIOContext, offset: i64) -> i64;
6059}
6060extern "C" {
6061 #[doc = " Get the filesize.\n @return filesize or AVERROR"]
6062 pub fn avio_size(s: *mut AVIOContext) -> i64;
6063}
6064extern "C" {
6065 #[doc = " Similar to feof() but also returns nonzero on read errors.\n @return non zero if and only if at end of file or a read error happened when reading."]
6066 pub fn avio_feof(s: *mut AVIOContext) -> ::std::os::raw::c_int;
6067}
6068extern "C" {
6069 #[doc = " Writes a formatted string to the context taking a va_list.\n @return number of bytes written, < 0 on error."]
6070 pub fn avio_vprintf(
6071 s: *mut AVIOContext,
6072 fmt: *const ::std::os::raw::c_char,
6073 ap: va_list,
6074 ) -> ::std::os::raw::c_int;
6075}
6076extern "C" {
6077 #[doc = " Writes a formatted string to the context.\n @return number of bytes written, < 0 on error."]
6078 pub fn avio_printf(
6079 s: *mut AVIOContext,
6080 fmt: *const ::std::os::raw::c_char,
6081 ...
6082 ) -> ::std::os::raw::c_int;
6083}
6084extern "C" {
6085 #[doc = " Write a NULL terminated array of strings to the context.\n Usually you don't need to use this function directly but its macro wrapper,\n avio_print."]
6086 pub fn avio_print_string_array(
6087 s: *mut AVIOContext,
6088 strings: *const *const ::std::os::raw::c_char,
6089 );
6090}
6091extern "C" {
6092 #[doc = " Force flushing of buffered data.\n\n For write streams, force the buffered data to be immediately written to the output,\n without to wait to fill the internal buffer.\n\n For read streams, discard all currently buffered data, and advance the\n reported file position to that of the underlying stream. This does not\n read new data, and does not perform any seeks."]
6093 pub fn avio_flush(s: *mut AVIOContext);
6094}
6095extern "C" {
6096 #[doc = " Read size bytes from AVIOContext into buf.\n @return number of bytes read or AVERROR"]
6097 pub fn avio_read(
6098 s: *mut AVIOContext,
6099 buf: *mut ::std::os::raw::c_uchar,
6100 size: ::std::os::raw::c_int,
6101 ) -> ::std::os::raw::c_int;
6102}
6103extern "C" {
6104 #[doc = " Read size bytes from AVIOContext into buf. Unlike avio_read(), this is allowed\n to read fewer bytes than requested. The missing bytes can be read in the next\n call. This always tries to read at least 1 byte.\n Useful to reduce latency in certain cases.\n @return number of bytes read or AVERROR"]
6105 pub fn avio_read_partial(
6106 s: *mut AVIOContext,
6107 buf: *mut ::std::os::raw::c_uchar,
6108 size: ::std::os::raw::c_int,
6109 ) -> ::std::os::raw::c_int;
6110}
6111extern "C" {
6112 #[doc = " @name Functions for reading from AVIOContext\n @{\n\n @note return 0 if EOF, so you cannot use it if EOF handling is\n necessary"]
6113 pub fn avio_r8(s: *mut AVIOContext) -> ::std::os::raw::c_int;
6114}
6115extern "C" {
6116 pub fn avio_rl16(s: *mut AVIOContext) -> ::std::os::raw::c_uint;
6117}
6118extern "C" {
6119 pub fn avio_rl24(s: *mut AVIOContext) -> ::std::os::raw::c_uint;
6120}
6121extern "C" {
6122 pub fn avio_rl32(s: *mut AVIOContext) -> ::std::os::raw::c_uint;
6123}
6124extern "C" {
6125 pub fn avio_rl64(s: *mut AVIOContext) -> u64;
6126}
6127extern "C" {
6128 pub fn avio_rb16(s: *mut AVIOContext) -> ::std::os::raw::c_uint;
6129}
6130extern "C" {
6131 pub fn avio_rb24(s: *mut AVIOContext) -> ::std::os::raw::c_uint;
6132}
6133extern "C" {
6134 pub fn avio_rb32(s: *mut AVIOContext) -> ::std::os::raw::c_uint;
6135}
6136extern "C" {
6137 pub fn avio_rb64(s: *mut AVIOContext) -> u64;
6138}
6139extern "C" {
6140 #[doc = " Read a string from pb into buf. The reading will terminate when either\n a NULL character was encountered, maxlen bytes have been read, or nothing\n more can be read from pb. The result is guaranteed to be NULL-terminated, it\n will be truncated if buf is too small.\n Note that the string is not interpreted or validated in any way, it\n might get truncated in the middle of a sequence for multi-byte encodings.\n\n @return number of bytes read (is always <= maxlen).\n If reading ends on EOF or error, the return value will be one more than\n bytes actually read."]
6141 pub fn avio_get_str(
6142 pb: *mut AVIOContext,
6143 maxlen: ::std::os::raw::c_int,
6144 buf: *mut ::std::os::raw::c_char,
6145 buflen: ::std::os::raw::c_int,
6146 ) -> ::std::os::raw::c_int;
6147}
6148extern "C" {
6149 #[doc = " Read a UTF-16 string from pb and convert it to UTF-8.\n The reading will terminate when either a null or invalid character was\n encountered or maxlen bytes have been read.\n @return number of bytes read (is always <= maxlen)"]
6150 pub fn avio_get_str16le(
6151 pb: *mut AVIOContext,
6152 maxlen: ::std::os::raw::c_int,
6153 buf: *mut ::std::os::raw::c_char,
6154 buflen: ::std::os::raw::c_int,
6155 ) -> ::std::os::raw::c_int;
6156}
6157extern "C" {
6158 pub fn avio_get_str16be(
6159 pb: *mut AVIOContext,
6160 maxlen: ::std::os::raw::c_int,
6161 buf: *mut ::std::os::raw::c_char,
6162 buflen: ::std::os::raw::c_int,
6163 ) -> ::std::os::raw::c_int;
6164}
6165extern "C" {
6166 #[doc = " Create and initialize a AVIOContext for accessing the\n resource indicated by url.\n @note When the resource indicated by url has been opened in\n read+write mode, the AVIOContext can be used only for writing.\n\n @param s Used to return the pointer to the created AVIOContext.\n In case of failure the pointed to value is set to NULL.\n @param url resource to access\n @param flags flags which control how the resource indicated by url\n is to be opened\n @return >= 0 in case of success, a negative value corresponding to an\n AVERROR code in case of failure"]
6167 pub fn avio_open(
6168 s: *mut *mut AVIOContext,
6169 url: *const ::std::os::raw::c_char,
6170 flags: ::std::os::raw::c_int,
6171 ) -> ::std::os::raw::c_int;
6172}
6173extern "C" {
6174 #[doc = " Create and initialize a AVIOContext for accessing the\n resource indicated by url.\n @note When the resource indicated by url has been opened in\n read+write mode, the AVIOContext can be used only for writing.\n\n @param s Used to return the pointer to the created AVIOContext.\n In case of failure the pointed to value is set to NULL.\n @param url resource to access\n @param flags flags which control how the resource indicated by url\n is to be opened\n @param int_cb an interrupt callback to be used at the protocols level\n @param options A dictionary filled with protocol-private options. On return\n this parameter will be destroyed and replaced with a dict containing options\n that were not found. May be NULL.\n @return >= 0 in case of success, a negative value corresponding to an\n AVERROR code in case of failure"]
6175 pub fn avio_open2(
6176 s: *mut *mut AVIOContext,
6177 url: *const ::std::os::raw::c_char,
6178 flags: ::std::os::raw::c_int,
6179 int_cb: *const AVIOInterruptCB,
6180 options: *mut *mut AVDictionary,
6181 ) -> ::std::os::raw::c_int;
6182}
6183extern "C" {
6184 #[doc = " Close the resource accessed by the AVIOContext s and free it.\n This function can only be used if s was opened by avio_open().\n\n The internal buffer is automatically flushed before closing the\n resource.\n\n @return 0 on success, an AVERROR < 0 on error.\n @see avio_closep"]
6185 pub fn avio_close(s: *mut AVIOContext) -> ::std::os::raw::c_int;
6186}
6187extern "C" {
6188 #[doc = " Close the resource accessed by the AVIOContext *s, free it\n and set the pointer pointing to it to NULL.\n This function can only be used if s was opened by avio_open().\n\n The internal buffer is automatically flushed before closing the\n resource.\n\n @return 0 on success, an AVERROR < 0 on error.\n @see avio_close"]
6189 pub fn avio_closep(s: *mut *mut AVIOContext) -> ::std::os::raw::c_int;
6190}
6191extern "C" {
6192 #[doc = " Open a write only memory stream.\n\n @param s new IO context\n @return zero if no error."]
6193 pub fn avio_open_dyn_buf(s: *mut *mut AVIOContext) -> ::std::os::raw::c_int;
6194}
6195extern "C" {
6196 #[doc = " Return the written size and a pointer to the buffer.\n The AVIOContext stream is left intact.\n The buffer must NOT be freed.\n No padding is added to the buffer.\n\n @param s IO context\n @param pbuffer pointer to a byte buffer\n @return the length of the byte buffer"]
6197 pub fn avio_get_dyn_buf(s: *mut AVIOContext, pbuffer: *mut *mut u8) -> ::std::os::raw::c_int;
6198}
6199extern "C" {
6200 #[doc = " Return the written size and a pointer to the buffer. The buffer\n must be freed with av_free().\n Padding of AV_INPUT_BUFFER_PADDING_SIZE is added to the buffer.\n\n @param s IO context\n @param pbuffer pointer to a byte buffer\n @return the length of the byte buffer"]
6201 pub fn avio_close_dyn_buf(s: *mut AVIOContext, pbuffer: *mut *mut u8) -> ::std::os::raw::c_int;
6202}
6203extern "C" {
6204 #[doc = " Iterate through names of available protocols.\n\n @param opaque A private pointer representing current protocol.\n It must be a pointer to NULL on first iteration and will\n be updated by successive calls to avio_enum_protocols.\n @param output If set to 1, iterate over output protocols,\n otherwise over input protocols.\n\n @return A static string containing the name of current protocol or NULL"]
6205 pub fn avio_enum_protocols(
6206 opaque: *mut *mut ::std::os::raw::c_void,
6207 output: ::std::os::raw::c_int,
6208 ) -> *const ::std::os::raw::c_char;
6209}
6210extern "C" {
6211 #[doc = " Get AVClass by names of available protocols.\n\n @return A AVClass of input protocol name or NULL"]
6212 pub fn avio_protocol_get_class(name: *const ::std::os::raw::c_char) -> *const AVClass;
6213}
6214extern "C" {
6215 #[doc = " Pause and resume playing - only meaningful if using a network streaming\n protocol (e.g. MMS).\n\n @param h IO context from which to call the read_pause function pointer\n @param pause 1 for pause, 0 for resume"]
6216 pub fn avio_pause(h: *mut AVIOContext, pause: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
6217}
6218extern "C" {
6219 #[doc = " Seek to a given timestamp relative to some component stream.\n Only meaningful if using a network streaming protocol (e.g. MMS.).\n\n @param h IO context from which to call the seek function pointers\n @param stream_index The stream index that the timestamp is relative to.\n If stream_index is (-1) the timestamp should be in AV_TIME_BASE\n units from the beginning of the presentation.\n If a stream_index >= 0 is used and the protocol does not support\n seeking based on component streams, the call will fail.\n @param timestamp timestamp in AVStream.time_base units\n or if there is no stream specified then in AV_TIME_BASE units.\n @param flags Optional combination of AVSEEK_FLAG_BACKWARD, AVSEEK_FLAG_BYTE\n and AVSEEK_FLAG_ANY. The protocol may silently ignore\n AVSEEK_FLAG_BACKWARD and AVSEEK_FLAG_ANY, but AVSEEK_FLAG_BYTE will\n fail if used and not supported.\n @return >= 0 on success\n @see AVInputFormat::read_seek"]
6220 pub fn avio_seek_time(
6221 h: *mut AVIOContext,
6222 stream_index: ::std::os::raw::c_int,
6223 timestamp: i64,
6224 flags: ::std::os::raw::c_int,
6225 ) -> i64;
6226}
6227extern "C" {
6228 #[doc = " Read contents of h into print buffer, up to max_size bytes, or up to EOF.\n\n @return 0 for success (max_size bytes read or EOF reached), negative error\n code otherwise"]
6229 pub fn avio_read_to_bprint(
6230 h: *mut AVIOContext,
6231 pb: *mut AVBPrint,
6232 max_size: usize,
6233 ) -> ::std::os::raw::c_int;
6234}
6235extern "C" {
6236 #[doc = " Accept and allocate a client context on a server context.\n @param s the server context\n @param c the client context, must be unallocated\n @return >= 0 on success or a negative value corresponding\n to an AVERROR on failure"]
6237 pub fn avio_accept(s: *mut AVIOContext, c: *mut *mut AVIOContext) -> ::std::os::raw::c_int;
6238}
6239extern "C" {
6240 #[doc = " Perform one step of the protocol handshake to accept a new client.\n This function must be called on a client returned by avio_accept() before\n using it as a read/write context.\n It is separate from avio_accept() because it may block.\n A step of the handshake is defined by places where the application may\n decide to change the proceedings.\n For example, on a protocol with a request header and a reply header, each\n one can constitute a step because the application may use the parameters\n from the request to change parameters in the reply; or each individual\n chunk of the request can constitute a step.\n If the handshake is already finished, avio_handshake() does nothing and\n returns 0 immediately.\n\n @param c the client context to perform the handshake on\n @return 0 on a complete and successful handshake\n > 0 if the handshake progressed, but is not complete\n < 0 for an AVERROR code"]
6241 pub fn avio_handshake(c: *mut AVIOContext) -> ::std::os::raw::c_int;
6242}
6243#[doc = " The data is the AVPanScan struct defined in libavcodec."]
6244pub const AVFrameSideDataType_AV_FRAME_DATA_PANSCAN: AVFrameSideDataType = 0;
6245#[doc = " ATSC A53 Part 4 Closed Captions.\n A53 CC bitstream is stored as uint8_t in AVFrameSideData.data.\n The number of bytes of CC data is AVFrameSideData.size."]
6246pub const AVFrameSideDataType_AV_FRAME_DATA_A53_CC: AVFrameSideDataType = 1;
6247#[doc = " Stereoscopic 3d metadata.\n The data is the AVStereo3D struct defined in libavutil/stereo3d.h."]
6248pub const AVFrameSideDataType_AV_FRAME_DATA_STEREO3D: AVFrameSideDataType = 2;
6249#[doc = " The data is the AVMatrixEncoding enum defined in libavutil/channel_layout.h."]
6250pub const AVFrameSideDataType_AV_FRAME_DATA_MATRIXENCODING: AVFrameSideDataType = 3;
6251#[doc = " Metadata relevant to a downmix procedure.\n The data is the AVDownmixInfo struct defined in libavutil/downmix_info.h."]
6252pub const AVFrameSideDataType_AV_FRAME_DATA_DOWNMIX_INFO: AVFrameSideDataType = 4;
6253#[doc = " ReplayGain information in the form of the AVReplayGain struct."]
6254pub const AVFrameSideDataType_AV_FRAME_DATA_REPLAYGAIN: AVFrameSideDataType = 5;
6255#[doc = " This side data contains a 3x3 transformation matrix describing an affine\n transformation that needs to be applied to the frame for correct\n presentation.\n\n See libavutil/display.h for a detailed description of the data."]
6256pub const AVFrameSideDataType_AV_FRAME_DATA_DISPLAYMATRIX: AVFrameSideDataType = 6;
6257#[doc = " Active Format Description data consisting of a single byte as specified\n in ETSI TS 101 154 using AVActiveFormatDescription enum."]
6258pub const AVFrameSideDataType_AV_FRAME_DATA_AFD: AVFrameSideDataType = 7;
6259#[doc = " Motion vectors exported by some codecs (on demand through the export_mvs\n flag set in the libavcodec AVCodecContext flags2 option).\n The data is the AVMotionVector struct defined in\n libavutil/motion_vector.h."]
6260pub const AVFrameSideDataType_AV_FRAME_DATA_MOTION_VECTORS: AVFrameSideDataType = 8;
6261#[doc = " Recommmends skipping the specified number of samples. This is exported\n only if the \"skip_manual\" AVOption is set in libavcodec.\n This has the same format as AV_PKT_DATA_SKIP_SAMPLES.\n @code\n u32le number of samples to skip from start of this packet\n u32le number of samples to skip from end of this packet\n u8 reason for start skip\n u8 reason for end skip (0=padding silence, 1=convergence)\n @endcode"]
6262pub const AVFrameSideDataType_AV_FRAME_DATA_SKIP_SAMPLES: AVFrameSideDataType = 9;
6263#[doc = " This side data must be associated with an audio frame and corresponds to\n enum AVAudioServiceType defined in avcodec.h."]
6264pub const AVFrameSideDataType_AV_FRAME_DATA_AUDIO_SERVICE_TYPE: AVFrameSideDataType = 10;
6265#[doc = " Mastering display metadata associated with a video frame. The payload is\n an AVMasteringDisplayMetadata type and contains information about the\n mastering display color volume."]
6266pub const AVFrameSideDataType_AV_FRAME_DATA_MASTERING_DISPLAY_METADATA: AVFrameSideDataType = 11;
6267#[doc = " The GOP timecode in 25 bit timecode format. Data format is 64-bit integer.\n This is set on the first frame of a GOP that has a temporal reference of 0."]
6268pub const AVFrameSideDataType_AV_FRAME_DATA_GOP_TIMECODE: AVFrameSideDataType = 12;
6269#[doc = " The data represents the AVSphericalMapping structure defined in\n libavutil/spherical.h."]
6270pub const AVFrameSideDataType_AV_FRAME_DATA_SPHERICAL: AVFrameSideDataType = 13;
6271#[doc = " Content light level (based on CTA-861.3). This payload contains data in\n the form of the AVContentLightMetadata struct."]
6272pub const AVFrameSideDataType_AV_FRAME_DATA_CONTENT_LIGHT_LEVEL: AVFrameSideDataType = 14;
6273#[doc = " The data contains an ICC profile as an opaque octet buffer following the\n format described by ISO 15076-1 with an optional name defined in the\n metadata key entry \"name\"."]
6274pub const AVFrameSideDataType_AV_FRAME_DATA_ICC_PROFILE: AVFrameSideDataType = 15;
6275#[doc = " Timecode which conforms to SMPTE ST 12-1. The data is an array of 4 uint32_t\n where the first uint32_t describes how many (1-3) of the other timecodes are used.\n The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()\n function in libavutil/timecode.h."]
6276pub const AVFrameSideDataType_AV_FRAME_DATA_S12M_TIMECODE: AVFrameSideDataType = 16;
6277#[doc = " HDR dynamic metadata associated with a video frame. The payload is\n an AVDynamicHDRPlus type and contains information for color\n volume transform - application 4 of SMPTE 2094-40:2016 standard."]
6278pub const AVFrameSideDataType_AV_FRAME_DATA_DYNAMIC_HDR_PLUS: AVFrameSideDataType = 17;
6279#[doc = " Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of\n array element is implied by AVFrameSideData.size / AVRegionOfInterest.self_size."]
6280pub const AVFrameSideDataType_AV_FRAME_DATA_REGIONS_OF_INTEREST: AVFrameSideDataType = 18;
6281#[doc = " Encoding parameters for a video frame, as described by AVVideoEncParams."]
6282pub const AVFrameSideDataType_AV_FRAME_DATA_VIDEO_ENC_PARAMS: AVFrameSideDataType = 19;
6283#[doc = " User data unregistered metadata associated with a video frame.\n This is the H.26[45] UDU SEI message, and shouldn't be used for any other purpose\n The data is stored as uint8_t in AVFrameSideData.data which is 16 bytes of\n uuid_iso_iec_11578 followed by AVFrameSideData.size - 16 bytes of user_data_payload_byte."]
6284pub const AVFrameSideDataType_AV_FRAME_DATA_SEI_UNREGISTERED: AVFrameSideDataType = 20;
6285#[doc = " Film grain parameters for a frame, described by AVFilmGrainParams.\n Must be present for every frame which should have film grain applied.\n\n May be present multiple times, for example when there are multiple\n alternative parameter sets for different video signal characteristics.\n The user should select the most appropriate set for the application."]
6286pub const AVFrameSideDataType_AV_FRAME_DATA_FILM_GRAIN_PARAMS: AVFrameSideDataType = 21;
6287#[doc = " Bounding boxes for object detection and classification,\n as described by AVDetectionBBoxHeader."]
6288pub const AVFrameSideDataType_AV_FRAME_DATA_DETECTION_BBOXES: AVFrameSideDataType = 22;
6289#[doc = " Dolby Vision RPU raw data, suitable for passing to x265\n or other libraries. Array of uint8_t, with NAL emulation\n bytes intact."]
6290pub const AVFrameSideDataType_AV_FRAME_DATA_DOVI_RPU_BUFFER: AVFrameSideDataType = 23;
6291#[doc = " Parsed Dolby Vision metadata, suitable for passing to a software\n implementation. The payload is the AVDOVIMetadata struct defined in\n libavutil/dovi_meta.h."]
6292pub const AVFrameSideDataType_AV_FRAME_DATA_DOVI_METADATA: AVFrameSideDataType = 24;
6293#[doc = " HDR Vivid dynamic metadata associated with a video frame. The payload is\n an AVDynamicHDRVivid type and contains information for color\n volume transform - CUVA 005.1-2021."]
6294pub const AVFrameSideDataType_AV_FRAME_DATA_DYNAMIC_HDR_VIVID: AVFrameSideDataType = 25;
6295#[doc = " Ambient viewing environment metadata, as defined by H.274."]
6296pub const AVFrameSideDataType_AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT: AVFrameSideDataType = 26;
6297#[doc = " Provide encoder-specific hinting information about changed/unchanged\n portions of a frame. It can be used to pass information about which\n macroblocks can be skipped because they didn't change from the\n corresponding ones in the previous frame. This could be useful for\n applications which know this information in advance to speed up\n encoding."]
6298pub const AVFrameSideDataType_AV_FRAME_DATA_VIDEO_HINT: AVFrameSideDataType = 27;
6299#[doc = " @defgroup lavu_frame AVFrame\n @ingroup lavu_data\n\n @{\n AVFrame is an abstraction for reference-counted raw multimedia data."]
6300pub type AVFrameSideDataType = ::std::os::raw::c_uint;
6301pub const AVActiveFormatDescription_AV_AFD_SAME: AVActiveFormatDescription = 8;
6302pub const AVActiveFormatDescription_AV_AFD_4_3: AVActiveFormatDescription = 9;
6303pub const AVActiveFormatDescription_AV_AFD_16_9: AVActiveFormatDescription = 10;
6304pub const AVActiveFormatDescription_AV_AFD_14_9: AVActiveFormatDescription = 11;
6305pub const AVActiveFormatDescription_AV_AFD_4_3_SP_14_9: AVActiveFormatDescription = 13;
6306pub const AVActiveFormatDescription_AV_AFD_16_9_SP_14_9: AVActiveFormatDescription = 14;
6307pub const AVActiveFormatDescription_AV_AFD_SP_4_3: AVActiveFormatDescription = 15;
6308pub type AVActiveFormatDescription = ::std::os::raw::c_uint;
6309#[doc = " Structure to hold side data for an AVFrame.\n\n sizeof(AVFrameSideData) is not a part of the public ABI, so new fields may be added\n to the end with a minor bump."]
6310#[repr(C)]
6311#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6312pub struct AVFrameSideData {
6313 pub type_: AVFrameSideDataType,
6314 pub data: *mut u8,
6315 pub size: usize,
6316 pub metadata: *mut AVDictionary,
6317 pub buf: *mut AVBufferRef,
6318}
6319impl Default for AVFrameSideData {
6320 fn default() -> Self {
6321 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6322 unsafe {
6323 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6324 s.assume_init()
6325 }
6326 }
6327}
6328#[doc = " The side data type can be used in stream-global structures.\n Side data types without this property are only meaningful on per-frame\n basis."]
6329pub const AVSideDataProps_AV_SIDE_DATA_PROP_GLOBAL: AVSideDataProps = 1;
6330#[doc = " Multiple instances of this side data type can be meaningfully present in\n a single side data array."]
6331pub const AVSideDataProps_AV_SIDE_DATA_PROP_MULTI: AVSideDataProps = 2;
6332pub type AVSideDataProps = ::std::os::raw::c_uint;
6333#[doc = " This struct describes the properties of a side data type. Its instance\n corresponding to a given type can be obtained from av_frame_side_data_desc()."]
6334#[repr(C)]
6335#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6336pub struct AVSideDataDescriptor {
6337 #[doc = " Human-readable side data description."]
6338 pub name: *const ::std::os::raw::c_char,
6339 #[doc = " Side data property flags, a combination of AVSideDataProps values."]
6340 pub props: ::std::os::raw::c_uint,
6341}
6342impl Default for AVSideDataDescriptor {
6343 fn default() -> Self {
6344 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6345 unsafe {
6346 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6347 s.assume_init()
6348 }
6349 }
6350}
6351#[doc = " Structure describing a single Region Of Interest.\n\n When multiple regions are defined in a single side-data block, they\n should be ordered from most to least important - some encoders are only\n capable of supporting a limited number of distinct regions, so will have\n to truncate the list.\n\n When overlapping regions are defined, the first region containing a given\n area of the frame applies."]
6352#[repr(C)]
6353#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6354pub struct AVRegionOfInterest {
6355 #[doc = " Must be set to the size of this data structure (that is,\n sizeof(AVRegionOfInterest))."]
6356 pub self_size: u32,
6357 #[doc = " Distance in pixels from the top edge of the frame to the top and\n bottom edges and from the left edge of the frame to the left and\n right edges of the rectangle defining this region of interest.\n\n The constraints on a region are encoder dependent, so the region\n actually affected may be slightly larger for alignment or other\n reasons."]
6358 pub top: ::std::os::raw::c_int,
6359 pub bottom: ::std::os::raw::c_int,
6360 pub left: ::std::os::raw::c_int,
6361 pub right: ::std::os::raw::c_int,
6362 #[doc = " Quantisation offset.\n\n Must be in the range -1 to +1. A value of zero indicates no quality\n change. A negative value asks for better quality (less quantisation),\n while a positive value asks for worse quality (greater quantisation).\n\n The range is calibrated so that the extreme values indicate the\n largest possible offset - if the rest of the frame is encoded with the\n worst possible quality, an offset of -1 indicates that this region\n should be encoded with the best possible quality anyway. Intermediate\n values are then interpolated in some codec-dependent way.\n\n For example, in 10-bit H.264 the quantisation parameter varies between\n -12 and 51. A typical qoffset value of -1/10 therefore indicates that\n this region should be encoded with a QP around one-tenth of the full\n range better than the rest of the frame. So, if most of the frame\n were to be encoded with a QP of around 30, this region would get a QP\n of around 24 (an offset of approximately -1/10 * (51 - -12) = -6.3).\n An extreme value of -1 would indicate that this region should be\n encoded with the best possible quality regardless of the treatment of\n the rest of the frame - that is, should be encoded at a QP of -12."]
6363 pub qoffset: AVRational,
6364}
6365#[doc = " This structure describes decoded (raw) audio or video data.\n\n AVFrame must be allocated using av_frame_alloc(). Note that this only\n allocates the AVFrame itself, the buffers for the data must be managed\n through other means (see below).\n AVFrame must be freed with av_frame_free().\n\n AVFrame is typically allocated once and then reused multiple times to hold\n different data (e.g. a single AVFrame to hold frames received from a\n decoder). In such a case, av_frame_unref() will free any references held by\n the frame and reset it to its original clean state before it\n is reused again.\n\n The data described by an AVFrame is usually reference counted through the\n AVBuffer API. The underlying buffer references are stored in AVFrame.buf /\n AVFrame.extended_buf. An AVFrame is considered to be reference counted if at\n least one reference is set, i.e. if AVFrame.buf[0] != NULL. In such a case,\n every single data plane must be contained in one of the buffers in\n AVFrame.buf or AVFrame.extended_buf.\n There may be a single buffer for all the data, or one separate buffer for\n each plane, or anything in between.\n\n sizeof(AVFrame) is not a part of the public ABI, so new fields may be added\n to the end with a minor bump.\n\n Fields can be accessed through AVOptions, the name string used, matches the\n C structure field name for fields accessible through AVOptions."]
6366#[repr(C)]
6367#[derive(Copy, Clone)]
6368pub struct AVFrame {
6369 #[doc = " pointer to the picture/channel planes.\n This might be different from the first allocated byte. For video,\n it could even point to the end of the image data.\n\n All pointers in data and extended_data must point into one of the\n AVBufferRef in buf or extended_buf.\n\n Some decoders access areas outside 0,0 - width,height, please\n see avcodec_align_dimensions2(). Some filters and swscale can read\n up to 16 bytes beyond the planes, if these filters are to be used,\n then 16 extra bytes must be allocated.\n\n NOTE: Pointers not needed by the format MUST be set to NULL.\n\n @attention In case of video, the data[] pointers can point to the\n end of image data in order to reverse line order, when used in\n combination with negative values in the linesize[] array."]
6370 pub data: [*mut u8; 8usize],
6371 #[doc = " For video, a positive or negative value, which is typically indicating\n the size in bytes of each picture line, but it can also be:\n - the negative byte size of lines for vertical flipping\n (with data[n] pointing to the end of the data\n - a positive or negative multiple of the byte size as for accessing\n even and odd fields of a frame (possibly flipped)\n\n For audio, only linesize[0] may be set. For planar audio, each channel\n plane must be the same size.\n\n For video the linesizes should be multiples of the CPUs alignment\n preference, this is 16 or 32 for modern desktop CPUs.\n Some code requires such alignment other code can be slower without\n correct alignment, for yet other it makes no difference.\n\n @note The linesize may be larger than the size of usable data -- there\n may be extra padding present for performance reasons.\n\n @attention In case of video, line size values can be negative to achieve\n a vertically inverted iteration over image lines."]
6372 pub linesize: [::std::os::raw::c_int; 8usize],
6373 #[doc = " pointers to the data planes/channels.\n\n For video, this should simply point to data[].\n\n For planar audio, each channel has a separate data pointer, and\n linesize[0] contains the size of each channel buffer.\n For packed audio, there is just one data pointer, and linesize[0]\n contains the total size of the buffer for all channels.\n\n Note: Both data and extended_data should always be set in a valid frame,\n but for planar audio with more channels that can fit in data,\n extended_data must be used in order to access all channels."]
6374 pub extended_data: *mut *mut u8,
6375 #[doc = " @name Video dimensions\n Video frames only. The coded dimensions (in pixels) of the video frame,\n i.e. the size of the rectangle that contains some well-defined values.\n\n @note The part of the frame intended for display/presentation is further\n restricted by the @ref cropping \"Cropping rectangle\".\n @{"]
6376 pub width: ::std::os::raw::c_int,
6377 #[doc = " @name Video dimensions\n Video frames only. The coded dimensions (in pixels) of the video frame,\n i.e. the size of the rectangle that contains some well-defined values.\n\n @note The part of the frame intended for display/presentation is further\n restricted by the @ref cropping \"Cropping rectangle\".\n @{"]
6378 pub height: ::std::os::raw::c_int,
6379 #[doc = " number of audio samples (per channel) described by this frame"]
6380 pub nb_samples: ::std::os::raw::c_int,
6381 #[doc = " format of the frame, -1 if unknown or unset\n Values correspond to enum AVPixelFormat for video frames,\n enum AVSampleFormat for audio)"]
6382 pub format: ::std::os::raw::c_int,
6383 #[doc = " 1 -> keyframe, 0-> not\n\n @deprecated Use AV_FRAME_FLAG_KEY instead"]
6384 pub key_frame: ::std::os::raw::c_int,
6385 #[doc = " Picture type of the frame."]
6386 pub pict_type: AVPictureType,
6387 #[doc = " Sample aspect ratio for the video frame, 0/1 if unknown/unspecified."]
6388 pub sample_aspect_ratio: AVRational,
6389 #[doc = " Presentation timestamp in time_base units (time when frame should be shown to user)."]
6390 pub pts: i64,
6391 #[doc = " DTS copied from the AVPacket that triggered returning this frame. (if frame threading isn't used)\n This is also the Presentation time of this AVFrame calculated from\n only AVPacket.dts values without pts values."]
6392 pub pkt_dts: i64,
6393 #[doc = " Time base for the timestamps in this frame.\n In the future, this field may be set on frames output by decoders or\n filters, but its value will be by default ignored on input to encoders\n or filters."]
6394 pub time_base: AVRational,
6395 #[doc = " quality (between 1 (good) and FF_LAMBDA_MAX (bad))"]
6396 pub quality: ::std::os::raw::c_int,
6397 #[doc = " Frame owner's private data.\n\n This field may be set by the code that allocates/owns the frame data.\n It is then not touched by any library functions, except:\n - it is copied to other references by av_frame_copy_props() (and hence by\n av_frame_ref());\n - it is set to NULL when the frame is cleared by av_frame_unref()\n - on the caller's explicit request. E.g. libavcodec encoders/decoders\n will copy this field to/from @ref AVPacket \"AVPackets\" if the caller sets\n @ref AV_CODEC_FLAG_COPY_OPAQUE.\n\n @see opaque_ref the reference-counted analogue"]
6398 pub opaque: *mut ::std::os::raw::c_void,
6399 #[doc = " Number of fields in this frame which should be repeated, i.e. the total\n duration of this frame should be repeat_pict + 2 normal field durations.\n\n For interlaced frames this field may be set to 1, which signals that this\n frame should be presented as 3 fields: beginning with the first field (as\n determined by AV_FRAME_FLAG_TOP_FIELD_FIRST being set or not), followed\n by the second field, and then the first field again.\n\n For progressive frames this field may be set to a multiple of 2, which\n signals that this frame's duration should be (repeat_pict + 2) / 2\n normal frame durations.\n\n @note This field is computed from MPEG2 repeat_first_field flag and its\n associated flags, H.264 pic_struct from picture timing SEI, and\n their analogues in other codecs. Typically it should only be used when\n higher-layer timing information is not available."]
6400 pub repeat_pict: ::std::os::raw::c_int,
6401 #[doc = " The content of the picture is interlaced.\n\n @deprecated Use AV_FRAME_FLAG_INTERLACED instead"]
6402 pub interlaced_frame: ::std::os::raw::c_int,
6403 #[doc = " If the content is interlaced, is top field displayed first.\n\n @deprecated Use AV_FRAME_FLAG_TOP_FIELD_FIRST instead"]
6404 pub top_field_first: ::std::os::raw::c_int,
6405 #[doc = " Tell user application that palette has changed from previous frame."]
6406 pub palette_has_changed: ::std::os::raw::c_int,
6407 #[doc = " Sample rate of the audio data."]
6408 pub sample_rate: ::std::os::raw::c_int,
6409 #[doc = " AVBuffer references backing the data for this frame. All the pointers in\n data and extended_data must point inside one of the buffers in buf or\n extended_buf. This array must be filled contiguously -- if buf[i] is\n non-NULL then buf[j] must also be non-NULL for all j < i.\n\n There may be at most one AVBuffer per data plane, so for video this array\n always contains all the references. For planar audio with more than\n AV_NUM_DATA_POINTERS channels, there may be more buffers than can fit in\n this array. Then the extra AVBufferRef pointers are stored in the\n extended_buf array."]
6410 pub buf: [*mut AVBufferRef; 8usize],
6411 #[doc = " For planar audio which requires more than AV_NUM_DATA_POINTERS\n AVBufferRef pointers, this array will hold all the references which\n cannot fit into AVFrame.buf.\n\n Note that this is different from AVFrame.extended_data, which always\n contains all the pointers. This array only contains the extra pointers,\n which cannot fit into AVFrame.buf.\n\n This array is always allocated using av_malloc() by whoever constructs\n the frame. It is freed in av_frame_unref()."]
6412 pub extended_buf: *mut *mut AVBufferRef,
6413 #[doc = " Number of elements in extended_buf."]
6414 pub nb_extended_buf: ::std::os::raw::c_int,
6415 pub side_data: *mut *mut AVFrameSideData,
6416 pub nb_side_data: ::std::os::raw::c_int,
6417 #[doc = " Frame flags, a combination of @ref lavu_frame_flags"]
6418 pub flags: ::std::os::raw::c_int,
6419 #[doc = " MPEG vs JPEG YUV range.\n - encoding: Set by user\n - decoding: Set by libavcodec"]
6420 pub color_range: AVColorRange,
6421 pub color_primaries: AVColorPrimaries,
6422 pub color_trc: AVColorTransferCharacteristic,
6423 #[doc = " YUV colorspace type.\n - encoding: Set by user\n - decoding: Set by libavcodec"]
6424 pub colorspace: AVColorSpace,
6425 pub chroma_location: AVChromaLocation,
6426 #[doc = " frame timestamp estimated using various heuristics, in stream time base\n - encoding: unused\n - decoding: set by libavcodec, read by user."]
6427 pub best_effort_timestamp: i64,
6428 #[doc = " reordered pos from the last AVPacket that has been input into the decoder\n - encoding: unused\n - decoding: Read by user.\n @deprecated use AV_CODEC_FLAG_COPY_OPAQUE to pass through arbitrary user\n data from packets to frames"]
6429 pub pkt_pos: i64,
6430 #[doc = " metadata.\n - encoding: Set by user.\n - decoding: Set by libavcodec."]
6431 pub metadata: *mut AVDictionary,
6432 #[doc = " decode error flags of the frame, set to a combination of\n FF_DECODE_ERROR_xxx flags if the decoder produced a frame, but there\n were errors during the decoding.\n - encoding: unused\n - decoding: set by libavcodec, read by user."]
6433 pub decode_error_flags: ::std::os::raw::c_int,
6434 #[doc = " size of the corresponding packet containing the compressed\n frame.\n It is set to a negative value if unknown.\n - encoding: unused\n - decoding: set by libavcodec, read by user.\n @deprecated use AV_CODEC_FLAG_COPY_OPAQUE to pass through arbitrary user\n data from packets to frames"]
6435 pub pkt_size: ::std::os::raw::c_int,
6436 #[doc = " For hwaccel-format frames, this should be a reference to the\n AVHWFramesContext describing the frame."]
6437 pub hw_frames_ctx: *mut AVBufferRef,
6438 #[doc = " Frame owner's private data.\n\n This field may be set by the code that allocates/owns the frame data.\n It is then not touched by any library functions, except:\n - a new reference to the underlying buffer is propagated by\n av_frame_copy_props() (and hence by av_frame_ref());\n - it is unreferenced in av_frame_unref();\n - on the caller's explicit request. E.g. libavcodec encoders/decoders\n will propagate a new reference to/from @ref AVPacket \"AVPackets\" if the\n caller sets @ref AV_CODEC_FLAG_COPY_OPAQUE.\n\n @see opaque the plain pointer analogue"]
6439 pub opaque_ref: *mut AVBufferRef,
6440 #[doc = " @anchor cropping\n @name Cropping\n Video frames only. The number of pixels to discard from the the\n top/bottom/left/right border of the frame to obtain the sub-rectangle of\n the frame intended for presentation.\n @{"]
6441 pub crop_top: usize,
6442 pub crop_bottom: usize,
6443 pub crop_left: usize,
6444 pub crop_right: usize,
6445 #[doc = " AVBufferRef for internal use by a single libav* library.\n Must not be used to transfer data between libraries.\n Has to be NULL when ownership of the frame leaves the respective library.\n\n Code outside the FFmpeg libs should never check or change the contents of the buffer ref.\n\n FFmpeg calls av_buffer_unref() on it when the frame is unreferenced.\n av_frame_copy_props() calls create a new reference with av_buffer_ref()\n for the target frame's private_ref field."]
6446 pub private_ref: *mut AVBufferRef,
6447 #[doc = " Channel layout of the audio data."]
6448 pub ch_layout: AVChannelLayout,
6449 #[doc = " Duration of the frame, in the same units as pts. 0 if unknown."]
6450 pub duration: i64,
6451}
6452impl Default for AVFrame {
6453 fn default() -> Self {
6454 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6455 unsafe {
6456 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6457 s.assume_init()
6458 }
6459 }
6460}
6461extern "C" {
6462 #[doc = " Allocate an AVFrame and set its fields to default values. The resulting\n struct must be freed using av_frame_free().\n\n @return An AVFrame filled with default values or NULL on failure.\n\n @note this only allocates the AVFrame itself, not the data buffers. Those\n must be allocated through other means, e.g. with av_frame_get_buffer() or\n manually."]
6463 pub fn av_frame_alloc() -> *mut AVFrame;
6464}
6465extern "C" {
6466 #[doc = " Free the frame and any dynamically allocated objects in it,\n e.g. extended_data. If the frame is reference counted, it will be\n unreferenced first.\n\n @param frame frame to be freed. The pointer will be set to NULL."]
6467 pub fn av_frame_free(frame: *mut *mut AVFrame);
6468}
6469extern "C" {
6470 #[doc = " Set up a new reference to the data described by the source frame.\n\n Copy frame properties from src to dst and create a new reference for each\n AVBufferRef from src.\n\n If src is not reference counted, new buffers are allocated and the data is\n copied.\n\n @warning: dst MUST have been either unreferenced with av_frame_unref(dst),\n or newly allocated with av_frame_alloc() before calling this\n function, or undefined behavior will occur.\n\n @return 0 on success, a negative AVERROR on error"]
6471 pub fn av_frame_ref(dst: *mut AVFrame, src: *const AVFrame) -> ::std::os::raw::c_int;
6472}
6473extern "C" {
6474 #[doc = " Ensure the destination frame refers to the same data described by the source\n frame, either by creating a new reference for each AVBufferRef from src if\n they differ from those in dst, by allocating new buffers and copying data if\n src is not reference counted, or by unrefencing it if src is empty.\n\n Frame properties on dst will be replaced by those from src.\n\n @return 0 on success, a negative AVERROR on error. On error, dst is\n unreferenced."]
6475 pub fn av_frame_replace(dst: *mut AVFrame, src: *const AVFrame) -> ::std::os::raw::c_int;
6476}
6477extern "C" {
6478 #[doc = " Create a new frame that references the same data as src.\n\n This is a shortcut for av_frame_alloc()+av_frame_ref().\n\n @return newly created AVFrame on success, NULL on error."]
6479 pub fn av_frame_clone(src: *const AVFrame) -> *mut AVFrame;
6480}
6481extern "C" {
6482 #[doc = " Unreference all the buffers referenced by frame and reset the frame fields."]
6483 pub fn av_frame_unref(frame: *mut AVFrame);
6484}
6485extern "C" {
6486 #[doc = " Move everything contained in src to dst and reset src.\n\n @warning: dst is not unreferenced, but directly overwritten without reading\n or deallocating its contents. Call av_frame_unref(dst) manually\n before calling this function to ensure that no memory is leaked."]
6487 pub fn av_frame_move_ref(dst: *mut AVFrame, src: *mut AVFrame);
6488}
6489extern "C" {
6490 #[doc = " Allocate new buffer(s) for audio or video data.\n\n The following fields must be set on frame before calling this function:\n - format (pixel format for video, sample format for audio)\n - width and height for video\n - nb_samples and ch_layout for audio\n\n This function will fill AVFrame.data and AVFrame.buf arrays and, if\n necessary, allocate and fill AVFrame.extended_data and AVFrame.extended_buf.\n For planar formats, one buffer will be allocated for each plane.\n\n @warning: if frame already has been allocated, calling this function will\n leak memory. In addition, undefined behavior can occur in certain\n cases.\n\n @param frame frame in which to store the new buffers.\n @param align Required buffer size alignment. If equal to 0, alignment will be\n chosen automatically for the current CPU. It is highly\n recommended to pass 0 here unless you know what you are doing.\n\n @return 0 on success, a negative AVERROR on error."]
6491 pub fn av_frame_get_buffer(
6492 frame: *mut AVFrame,
6493 align: ::std::os::raw::c_int,
6494 ) -> ::std::os::raw::c_int;
6495}
6496extern "C" {
6497 #[doc = " Check if the frame data is writable.\n\n @return A positive value if the frame data is writable (which is true if and\n only if each of the underlying buffers has only one reference, namely the one\n stored in this frame). Return 0 otherwise.\n\n If 1 is returned the answer is valid until av_buffer_ref() is called on any\n of the underlying AVBufferRefs (e.g. through av_frame_ref() or directly).\n\n @see av_frame_make_writable(), av_buffer_is_writable()"]
6498 pub fn av_frame_is_writable(frame: *mut AVFrame) -> ::std::os::raw::c_int;
6499}
6500extern "C" {
6501 #[doc = " Ensure that the frame data is writable, avoiding data copy if possible.\n\n Do nothing if the frame is writable, allocate new buffers and copy the data\n if it is not. Non-refcounted frames behave as non-writable, i.e. a copy\n is always made.\n\n @return 0 on success, a negative AVERROR on error.\n\n @see av_frame_is_writable(), av_buffer_is_writable(),\n av_buffer_make_writable()"]
6502 pub fn av_frame_make_writable(frame: *mut AVFrame) -> ::std::os::raw::c_int;
6503}
6504extern "C" {
6505 #[doc = " Copy the frame data from src to dst.\n\n This function does not allocate anything, dst must be already initialized and\n allocated with the same parameters as src.\n\n This function only copies the frame data (i.e. the contents of the data /\n extended data arrays), not any other properties.\n\n @return >= 0 on success, a negative AVERROR on error."]
6506 pub fn av_frame_copy(dst: *mut AVFrame, src: *const AVFrame) -> ::std::os::raw::c_int;
6507}
6508extern "C" {
6509 #[doc = " Copy only \"metadata\" fields from src to dst.\n\n Metadata for the purpose of this function are those fields that do not affect\n the data layout in the buffers. E.g. pts, sample rate (for audio) or sample\n aspect ratio (for video), but not width/height or channel layout.\n Side data is also copied."]
6510 pub fn av_frame_copy_props(dst: *mut AVFrame, src: *const AVFrame) -> ::std::os::raw::c_int;
6511}
6512extern "C" {
6513 #[doc = " Get the buffer reference a given data plane is stored in.\n\n @param frame the frame to get the plane's buffer from\n @param plane index of the data plane of interest in frame->extended_data.\n\n @return the buffer reference that contains the plane or NULL if the input\n frame is not valid."]
6514 pub fn av_frame_get_plane_buffer(
6515 frame: *const AVFrame,
6516 plane: ::std::os::raw::c_int,
6517 ) -> *mut AVBufferRef;
6518}
6519extern "C" {
6520 #[doc = " Add a new side data to a frame.\n\n @param frame a frame to which the side data should be added\n @param type type of the added side data\n @param size size of the side data\n\n @return newly added side data on success, NULL on error"]
6521 pub fn av_frame_new_side_data(
6522 frame: *mut AVFrame,
6523 type_: AVFrameSideDataType,
6524 size: usize,
6525 ) -> *mut AVFrameSideData;
6526}
6527extern "C" {
6528 #[doc = " Add a new side data to a frame from an existing AVBufferRef\n\n @param frame a frame to which the side data should be added\n @param type the type of the added side data\n @param buf an AVBufferRef to add as side data. The ownership of\n the reference is transferred to the frame.\n\n @return newly added side data on success, NULL on error. On failure\n the frame is unchanged and the AVBufferRef remains owned by\n the caller."]
6529 pub fn av_frame_new_side_data_from_buf(
6530 frame: *mut AVFrame,
6531 type_: AVFrameSideDataType,
6532 buf: *mut AVBufferRef,
6533 ) -> *mut AVFrameSideData;
6534}
6535extern "C" {
6536 #[doc = " @return a pointer to the side data of a given type on success, NULL if there\n is no side data with such type in this frame."]
6537 pub fn av_frame_get_side_data(
6538 frame: *const AVFrame,
6539 type_: AVFrameSideDataType,
6540 ) -> *mut AVFrameSideData;
6541}
6542extern "C" {
6543 #[doc = " Remove and free all side data instances of the given type."]
6544 pub fn av_frame_remove_side_data(frame: *mut AVFrame, type_: AVFrameSideDataType);
6545}
6546#[doc = " Apply the maximum possible cropping, even if it requires setting the\n AVFrame.data[] entries to unaligned pointers. Passing unaligned data\n to FFmpeg API is generally not allowed, and causes undefined behavior\n (such as crashes). You can pass unaligned data only to FFmpeg APIs that\n are explicitly documented to accept it. Use this flag only if you\n absolutely know what you are doing."]
6547pub const AV_FRAME_CROP_UNALIGNED: _bindgen_ty_1 = 1;
6548#[doc = " Flags for frame cropping."]
6549pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
6550extern "C" {
6551 #[doc = " Crop the given video AVFrame according to its crop_left/crop_top/crop_right/\n crop_bottom fields. If cropping is successful, the function will adjust the\n data pointers and the width/height fields, and set the crop fields to 0.\n\n In all cases, the cropping boundaries will be rounded to the inherent\n alignment of the pixel format. In some cases, such as for opaque hwaccel\n formats, the left/top cropping is ignored. The crop fields are set to 0 even\n if the cropping was rounded or ignored.\n\n @param frame the frame which should be cropped\n @param flags Some combination of AV_FRAME_CROP_* flags, or 0.\n\n @return >= 0 on success, a negative AVERROR on error. If the cropping fields\n were invalid, AVERROR(ERANGE) is returned, and nothing is changed."]
6552 pub fn av_frame_apply_cropping(
6553 frame: *mut AVFrame,
6554 flags: ::std::os::raw::c_int,
6555 ) -> ::std::os::raw::c_int;
6556}
6557extern "C" {
6558 #[doc = " @return a string identifying the side data type"]
6559 pub fn av_frame_side_data_name(type_: AVFrameSideDataType) -> *const ::std::os::raw::c_char;
6560}
6561extern "C" {
6562 #[doc = " @return side data descriptor corresponding to a given side data type, NULL\n when not available."]
6563 pub fn av_frame_side_data_desc(type_: AVFrameSideDataType) -> *const AVSideDataDescriptor;
6564}
6565extern "C" {
6566 #[doc = " Free all side data entries and their contents, then zeroes out the\n values which the pointers are pointing to.\n\n @param sd pointer to array of side data to free. Will be set to NULL\n upon return.\n @param nb_sd pointer to an integer containing the number of entries in\n the array. Will be set to 0 upon return."]
6567 pub fn av_frame_side_data_free(
6568 sd: *mut *mut *mut AVFrameSideData,
6569 nb_sd: *mut ::std::os::raw::c_int,
6570 );
6571}
6572extern "C" {
6573 #[doc = " Add new side data entry to an array.\n\n @param sd pointer to array of side data to which to add another entry,\n or to NULL in order to start a new array.\n @param nb_sd pointer to an integer containing the number of entries in\n the array.\n @param type type of the added side data\n @param size size of the side data\n @param flags Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, or 0.\n\n @return newly added side data on success, NULL on error.\n @note In case of AV_FRAME_SIDE_DATA_FLAG_UNIQUE being set, entries of\n matching AVFrameSideDataType will be removed before the addition\n is attempted.\n @note In case of AV_FRAME_SIDE_DATA_FLAG_REPLACE being set, if an\n entry of the same type already exists, it will be replaced instead."]
6574 pub fn av_frame_side_data_new(
6575 sd: *mut *mut *mut AVFrameSideData,
6576 nb_sd: *mut ::std::os::raw::c_int,
6577 type_: AVFrameSideDataType,
6578 size: usize,
6579 flags: ::std::os::raw::c_uint,
6580 ) -> *mut AVFrameSideData;
6581}
6582extern "C" {
6583 #[doc = " Add a new side data entry to an array from an existing AVBufferRef.\n\n @param sd pointer to array of side data to which to add another entry,\n or to NULL in order to start a new array.\n @param nb_sd pointer to an integer containing the number of entries in\n the array.\n @param type type of the added side data\n @param buf Pointer to AVBufferRef to add to the array. On success,\n the function takes ownership of the AVBufferRef and *buf is\n set to NULL, unless AV_FRAME_SIDE_DATA_FLAG_NEW_REF is set\n in which case the ownership will remain with the caller.\n @param flags Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, or 0.\n\n @return newly added side data on success, NULL on error.\n @note In case of AV_FRAME_SIDE_DATA_FLAG_UNIQUE being set, entries of\n matching AVFrameSideDataType will be removed before the addition\n is attempted.\n @note In case of AV_FRAME_SIDE_DATA_FLAG_REPLACE being set, if an\n entry of the same type already exists, it will be replaced instead.\n"]
6584 pub fn av_frame_side_data_add(
6585 sd: *mut *mut *mut AVFrameSideData,
6586 nb_sd: *mut ::std::os::raw::c_int,
6587 type_: AVFrameSideDataType,
6588 buf: *mut *mut AVBufferRef,
6589 flags: ::std::os::raw::c_uint,
6590 ) -> *mut AVFrameSideData;
6591}
6592extern "C" {
6593 #[doc = " Add a new side data entry to an array based on existing side data, taking\n a reference towards the contained AVBufferRef.\n\n @param sd pointer to array of side data to which to add another entry,\n or to NULL in order to start a new array.\n @param nb_sd pointer to an integer containing the number of entries in\n the array.\n @param src side data to be cloned, with a new reference utilized\n for the buffer.\n @param flags Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, or 0.\n\n @return negative error code on failure, >=0 on success.\n @note In case of AV_FRAME_SIDE_DATA_FLAG_UNIQUE being set, entries of\n matching AVFrameSideDataType will be removed before the addition\n is attempted.\n @note In case of AV_FRAME_SIDE_DATA_FLAG_REPLACE being set, if an\n entry of the same type already exists, it will be replaced instead."]
6594 pub fn av_frame_side_data_clone(
6595 sd: *mut *mut *mut AVFrameSideData,
6596 nb_sd: *mut ::std::os::raw::c_int,
6597 src: *const AVFrameSideData,
6598 flags: ::std::os::raw::c_uint,
6599 ) -> ::std::os::raw::c_int;
6600}
6601extern "C" {
6602 #[doc = " Get a side data entry of a specific type from an array.\n\n @param sd array of side data.\n @param nb_sd integer containing the number of entries in the array.\n @param type type of side data to be queried\n\n @return a pointer to the side data of a given type on success, NULL if there\n is no side data with such type in this set."]
6603 pub fn av_frame_side_data_get_c(
6604 sd: *const *const AVFrameSideData,
6605 nb_sd: ::std::os::raw::c_int,
6606 type_: AVFrameSideDataType,
6607 ) -> *const AVFrameSideData;
6608}
6609extern "C" {
6610 #[doc = " Remove and free all side data instances of the given type from an array."]
6611 pub fn av_frame_side_data_remove(
6612 sd: *mut *mut *mut AVFrameSideData,
6613 nb_sd: *mut ::std::os::raw::c_int,
6614 type_: AVFrameSideDataType,
6615 );
6616}
6617pub const AVHWDeviceType_AV_HWDEVICE_TYPE_NONE: AVHWDeviceType = 0;
6618pub const AVHWDeviceType_AV_HWDEVICE_TYPE_VDPAU: AVHWDeviceType = 1;
6619pub const AVHWDeviceType_AV_HWDEVICE_TYPE_CUDA: AVHWDeviceType = 2;
6620pub const AVHWDeviceType_AV_HWDEVICE_TYPE_VAAPI: AVHWDeviceType = 3;
6621pub const AVHWDeviceType_AV_HWDEVICE_TYPE_DXVA2: AVHWDeviceType = 4;
6622pub const AVHWDeviceType_AV_HWDEVICE_TYPE_QSV: AVHWDeviceType = 5;
6623pub const AVHWDeviceType_AV_HWDEVICE_TYPE_VIDEOTOOLBOX: AVHWDeviceType = 6;
6624pub const AVHWDeviceType_AV_HWDEVICE_TYPE_D3D11VA: AVHWDeviceType = 7;
6625pub const AVHWDeviceType_AV_HWDEVICE_TYPE_DRM: AVHWDeviceType = 8;
6626pub const AVHWDeviceType_AV_HWDEVICE_TYPE_OPENCL: AVHWDeviceType = 9;
6627pub const AVHWDeviceType_AV_HWDEVICE_TYPE_MEDIACODEC: AVHWDeviceType = 10;
6628pub const AVHWDeviceType_AV_HWDEVICE_TYPE_VULKAN: AVHWDeviceType = 11;
6629pub const AVHWDeviceType_AV_HWDEVICE_TYPE_D3D12VA: AVHWDeviceType = 12;
6630pub type AVHWDeviceType = ::std::os::raw::c_uint;
6631#[doc = " This struct aggregates all the (hardware/vendor-specific) \"high-level\" state,\n i.e. state that is not tied to a concrete processing configuration.\n E.g., in an API that supports hardware-accelerated encoding and decoding,\n this struct will (if possible) wrap the state that is common to both encoding\n and decoding and from which specific instances of encoders or decoders can be\n derived.\n\n This struct is reference-counted with the AVBuffer mechanism. The\n av_hwdevice_ctx_alloc() constructor yields a reference, whose data field\n points to the actual AVHWDeviceContext. Further objects derived from\n AVHWDeviceContext (such as AVHWFramesContext, describing a frame pool with\n specific properties) will hold an internal reference to it. After all the\n references are released, the AVHWDeviceContext itself will be freed,\n optionally invoking a user-specified callback for uninitializing the hardware\n state."]
6632#[repr(C)]
6633#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6634pub struct AVHWDeviceContext {
6635 #[doc = " A class for logging. Set by av_hwdevice_ctx_alloc()."]
6636 pub av_class: *const AVClass,
6637 #[doc = " This field identifies the underlying API used for hardware access.\n\n This field is set when this struct is allocated and never changed\n afterwards."]
6638 pub type_: AVHWDeviceType,
6639 #[doc = " The format-specific data, allocated and freed by libavutil along with\n this context.\n\n Should be cast by the user to the format-specific context defined in the\n corresponding header (hwcontext_*.h) and filled as described in the\n documentation before calling av_hwdevice_ctx_init().\n\n After calling av_hwdevice_ctx_init() this struct should not be modified\n by the caller."]
6640 pub hwctx: *mut ::std::os::raw::c_void,
6641 #[doc = " This field may be set by the caller before calling av_hwdevice_ctx_init().\n\n If non-NULL, this callback will be called when the last reference to\n this context is unreferenced, immediately before it is freed.\n\n @note when other objects (e.g an AVHWFramesContext) are derived from this\n struct, this callback will be invoked after all such child objects\n are fully uninitialized and their respective destructors invoked."]
6642 pub free: ::std::option::Option<unsafe extern "C" fn(ctx: *mut AVHWDeviceContext)>,
6643 #[doc = " Arbitrary user data, to be used e.g. by the free() callback."]
6644 pub user_opaque: *mut ::std::os::raw::c_void,
6645}
6646impl Default for AVHWDeviceContext {
6647 fn default() -> Self {
6648 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6649 unsafe {
6650 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6651 s.assume_init()
6652 }
6653 }
6654}
6655#[doc = " This struct describes a set or pool of \"hardware\" frames (i.e. those with\n data not located in normal system memory). All the frames in the pool are\n assumed to be allocated in the same way and interchangeable.\n\n This struct is reference-counted with the AVBuffer mechanism and tied to a\n given AVHWDeviceContext instance. The av_hwframe_ctx_alloc() constructor\n yields a reference, whose data field points to the actual AVHWFramesContext\n struct."]
6656#[repr(C)]
6657#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6658pub struct AVHWFramesContext {
6659 #[doc = " A class for logging."]
6660 pub av_class: *const AVClass,
6661 #[doc = " A reference to the parent AVHWDeviceContext. This reference is owned and\n managed by the enclosing AVHWFramesContext, but the caller may derive\n additional references from it."]
6662 pub device_ref: *mut AVBufferRef,
6663 #[doc = " The parent AVHWDeviceContext. This is simply a pointer to\n device_ref->data provided for convenience.\n\n Set by libavutil in av_hwframe_ctx_init()."]
6664 pub device_ctx: *mut AVHWDeviceContext,
6665 #[doc = " The format-specific data, allocated and freed automatically along with\n this context.\n\n The user shall ignore this field if the corresponding format-specific\n header (hwcontext_*.h) does not define a context to be used as\n AVHWFramesContext.hwctx.\n\n Otherwise, it should be cast by the user to said context and filled\n as described in the documentation before calling av_hwframe_ctx_init().\n\n After any frames using this context are created, the contents of this\n struct should not be modified by the caller."]
6666 pub hwctx: *mut ::std::os::raw::c_void,
6667 #[doc = " This field may be set by the caller before calling av_hwframe_ctx_init().\n\n If non-NULL, this callback will be called when the last reference to\n this context is unreferenced, immediately before it is freed."]
6668 pub free: ::std::option::Option<unsafe extern "C" fn(ctx: *mut AVHWFramesContext)>,
6669 #[doc = " Arbitrary user data, to be used e.g. by the free() callback."]
6670 pub user_opaque: *mut ::std::os::raw::c_void,
6671 #[doc = " A pool from which the frames are allocated by av_hwframe_get_buffer().\n This field may be set by the caller before calling av_hwframe_ctx_init().\n The buffers returned by calling av_buffer_pool_get() on this pool must\n have the properties described in the documentation in the corresponding hw\n type's header (hwcontext_*.h). The pool will be freed strictly before\n this struct's free() callback is invoked.\n\n This field may be NULL, then libavutil will attempt to allocate a pool\n internally. Note that certain device types enforce pools allocated at\n fixed size (frame count), which cannot be extended dynamically. In such a\n case, initial_pool_size must be set appropriately."]
6672 pub pool: *mut AVBufferPool,
6673 #[doc = " Initial size of the frame pool. If a device type does not support\n dynamically resizing the pool, then this is also the maximum pool size.\n\n May be set by the caller before calling av_hwframe_ctx_init(). Must be\n set if pool is NULL and the device type does not support dynamic pools."]
6674 pub initial_pool_size: ::std::os::raw::c_int,
6675 #[doc = " The pixel format identifying the underlying HW surface type.\n\n Must be a hwaccel format, i.e. the corresponding descriptor must have the\n AV_PIX_FMT_FLAG_HWACCEL flag set.\n\n Must be set by the user before calling av_hwframe_ctx_init()."]
6676 pub format: AVPixelFormat,
6677 #[doc = " The pixel format identifying the actual data layout of the hardware\n frames.\n\n Must be set by the caller before calling av_hwframe_ctx_init().\n\n @note when the underlying API does not provide the exact data layout, but\n only the colorspace/bit depth, this field should be set to the fully\n planar version of that format (e.g. for 8-bit 420 YUV it should be\n AV_PIX_FMT_YUV420P, not AV_PIX_FMT_NV12 or anything else)."]
6678 pub sw_format: AVPixelFormat,
6679 #[doc = " The allocated dimensions of the frames in this pool.\n\n Must be set by the user before calling av_hwframe_ctx_init()."]
6680 pub width: ::std::os::raw::c_int,
6681 #[doc = " The allocated dimensions of the frames in this pool.\n\n Must be set by the user before calling av_hwframe_ctx_init()."]
6682 pub height: ::std::os::raw::c_int,
6683}
6684impl Default for AVHWFramesContext {
6685 fn default() -> Self {
6686 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6687 unsafe {
6688 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6689 s.assume_init()
6690 }
6691 }
6692}
6693extern "C" {
6694 #[doc = " Look up an AVHWDeviceType by name.\n\n @param name String name of the device type (case-insensitive).\n @return The type from enum AVHWDeviceType, or AV_HWDEVICE_TYPE_NONE if\n not found."]
6695 pub fn av_hwdevice_find_type_by_name(name: *const ::std::os::raw::c_char) -> AVHWDeviceType;
6696}
6697extern "C" {
6698 #[doc = " Get the string name of an AVHWDeviceType.\n\n @param type Type from enum AVHWDeviceType.\n @return Pointer to a static string containing the name, or NULL if the type\n is not valid."]
6699 pub fn av_hwdevice_get_type_name(type_: AVHWDeviceType) -> *const ::std::os::raw::c_char;
6700}
6701extern "C" {
6702 #[doc = " Iterate over supported device types.\n\n @param prev AV_HWDEVICE_TYPE_NONE initially, then the previous type\n returned by this function in subsequent iterations.\n @return The next usable device type from enum AVHWDeviceType, or\n AV_HWDEVICE_TYPE_NONE if there are no more."]
6703 pub fn av_hwdevice_iterate_types(prev: AVHWDeviceType) -> AVHWDeviceType;
6704}
6705extern "C" {
6706 #[doc = " Allocate an AVHWDeviceContext for a given hardware type.\n\n @param type the type of the hardware device to allocate.\n @return a reference to the newly created AVHWDeviceContext on success or NULL\n on failure."]
6707 pub fn av_hwdevice_ctx_alloc(type_: AVHWDeviceType) -> *mut AVBufferRef;
6708}
6709extern "C" {
6710 #[doc = " Finalize the device context before use. This function must be called after\n the context is filled with all the required information and before it is\n used in any way.\n\n @param ref a reference to the AVHWDeviceContext\n @return 0 on success, a negative AVERROR code on failure"]
6711 pub fn av_hwdevice_ctx_init(ref_: *mut AVBufferRef) -> ::std::os::raw::c_int;
6712}
6713extern "C" {
6714 #[doc = " Open a device of the specified type and create an AVHWDeviceContext for it.\n\n This is a convenience function intended to cover the simple cases. Callers\n who need to fine-tune device creation/management should open the device\n manually and then wrap it in an AVHWDeviceContext using\n av_hwdevice_ctx_alloc()/av_hwdevice_ctx_init().\n\n The returned context is already initialized and ready for use, the caller\n should not call av_hwdevice_ctx_init() on it. The user_opaque/free fields of\n the created AVHWDeviceContext are set by this function and should not be\n touched by the caller.\n\n @param device_ctx On success, a reference to the newly-created device context\n will be written here. The reference is owned by the caller\n and must be released with av_buffer_unref() when no longer\n needed. On failure, NULL will be written to this pointer.\n @param type The type of the device to create.\n @param device A type-specific string identifying the device to open.\n @param opts A dictionary of additional (type-specific) options to use in\n opening the device. The dictionary remains owned by the caller.\n @param flags currently unused\n\n @return 0 on success, a negative AVERROR code on failure."]
6715 pub fn av_hwdevice_ctx_create(
6716 device_ctx: *mut *mut AVBufferRef,
6717 type_: AVHWDeviceType,
6718 device: *const ::std::os::raw::c_char,
6719 opts: *mut AVDictionary,
6720 flags: ::std::os::raw::c_int,
6721 ) -> ::std::os::raw::c_int;
6722}
6723extern "C" {
6724 #[doc = " Create a new device of the specified type from an existing device.\n\n If the source device is a device of the target type or was originally\n derived from such a device (possibly through one or more intermediate\n devices of other types), then this will return a reference to the\n existing device of the same type as is requested.\n\n Otherwise, it will attempt to derive a new device from the given source\n device. If direct derivation to the new type is not implemented, it will\n attempt the same derivation from each ancestor of the source device in\n turn looking for an implemented derivation method.\n\n @param dst_ctx On success, a reference to the newly-created\n AVHWDeviceContext.\n @param type The type of the new device to create.\n @param src_ctx A reference to an existing AVHWDeviceContext which will be\n used to create the new device.\n @param flags Currently unused; should be set to zero.\n @return Zero on success, a negative AVERROR code on failure."]
6725 pub fn av_hwdevice_ctx_create_derived(
6726 dst_ctx: *mut *mut AVBufferRef,
6727 type_: AVHWDeviceType,
6728 src_ctx: *mut AVBufferRef,
6729 flags: ::std::os::raw::c_int,
6730 ) -> ::std::os::raw::c_int;
6731}
6732extern "C" {
6733 #[doc = " Create a new device of the specified type from an existing device.\n\n This function performs the same action as av_hwdevice_ctx_create_derived,\n however, it is able to set options for the new device to be derived.\n\n @param dst_ctx On success, a reference to the newly-created\n AVHWDeviceContext.\n @param type The type of the new device to create.\n @param src_ctx A reference to an existing AVHWDeviceContext which will be\n used to create the new device.\n @param options Options for the new device to create, same format as in\n av_hwdevice_ctx_create.\n @param flags Currently unused; should be set to zero.\n @return Zero on success, a negative AVERROR code on failure."]
6734 pub fn av_hwdevice_ctx_create_derived_opts(
6735 dst_ctx: *mut *mut AVBufferRef,
6736 type_: AVHWDeviceType,
6737 src_ctx: *mut AVBufferRef,
6738 options: *mut AVDictionary,
6739 flags: ::std::os::raw::c_int,
6740 ) -> ::std::os::raw::c_int;
6741}
6742extern "C" {
6743 #[doc = " Allocate an AVHWFramesContext tied to a given device context.\n\n @param device_ctx a reference to a AVHWDeviceContext. This function will make\n a new reference for internal use, the one passed to the\n function remains owned by the caller.\n @return a reference to the newly created AVHWFramesContext on success or NULL\n on failure."]
6744 pub fn av_hwframe_ctx_alloc(device_ctx: *mut AVBufferRef) -> *mut AVBufferRef;
6745}
6746extern "C" {
6747 #[doc = " Finalize the context before use. This function must be called after the\n context is filled with all the required information and before it is attached\n to any frames.\n\n @param ref a reference to the AVHWFramesContext\n @return 0 on success, a negative AVERROR code on failure"]
6748 pub fn av_hwframe_ctx_init(ref_: *mut AVBufferRef) -> ::std::os::raw::c_int;
6749}
6750extern "C" {
6751 #[doc = " Allocate a new frame attached to the given AVHWFramesContext.\n\n @param hwframe_ctx a reference to an AVHWFramesContext\n @param frame an empty (freshly allocated or unreffed) frame to be filled with\n newly allocated buffers.\n @param flags currently unused, should be set to zero\n @return 0 on success, a negative AVERROR code on failure"]
6752 pub fn av_hwframe_get_buffer(
6753 hwframe_ctx: *mut AVBufferRef,
6754 frame: *mut AVFrame,
6755 flags: ::std::os::raw::c_int,
6756 ) -> ::std::os::raw::c_int;
6757}
6758extern "C" {
6759 #[doc = " Copy data to or from a hw surface. At least one of dst/src must have an\n AVHWFramesContext attached.\n\n If src has an AVHWFramesContext attached, then the format of dst (if set)\n must use one of the formats returned by av_hwframe_transfer_get_formats(src,\n AV_HWFRAME_TRANSFER_DIRECTION_FROM).\n If dst has an AVHWFramesContext attached, then the format of src must use one\n of the formats returned by av_hwframe_transfer_get_formats(dst,\n AV_HWFRAME_TRANSFER_DIRECTION_TO)\n\n dst may be \"clean\" (i.e. with data/buf pointers unset), in which case the\n data buffers will be allocated by this function using av_frame_get_buffer().\n If dst->format is set, then this format will be used, otherwise (when\n dst->format is AV_PIX_FMT_NONE) the first acceptable format will be chosen.\n\n The two frames must have matching allocated dimensions (i.e. equal to\n AVHWFramesContext.width/height), since not all device types support\n transferring a sub-rectangle of the whole surface. The display dimensions\n (i.e. AVFrame.width/height) may be smaller than the allocated dimensions, but\n also have to be equal for both frames. When the display dimensions are\n smaller than the allocated dimensions, the content of the padding in the\n destination frame is unspecified.\n\n @param dst the destination frame. dst is not touched on failure.\n @param src the source frame.\n @param flags currently unused, should be set to zero\n @return 0 on success, a negative AVERROR error code on failure."]
6760 pub fn av_hwframe_transfer_data(
6761 dst: *mut AVFrame,
6762 src: *const AVFrame,
6763 flags: ::std::os::raw::c_int,
6764 ) -> ::std::os::raw::c_int;
6765}
6766#[doc = " Transfer the data from the queried hw frame."]
6767pub const AVHWFrameTransferDirection_AV_HWFRAME_TRANSFER_DIRECTION_FROM:
6768 AVHWFrameTransferDirection = 0;
6769#[doc = " Transfer the data to the queried hw frame."]
6770pub const AVHWFrameTransferDirection_AV_HWFRAME_TRANSFER_DIRECTION_TO: AVHWFrameTransferDirection =
6771 1;
6772pub type AVHWFrameTransferDirection = ::std::os::raw::c_uint;
6773extern "C" {
6774 #[doc = " Get a list of possible source or target formats usable in\n av_hwframe_transfer_data().\n\n @param hwframe_ctx the frame context to obtain the information for\n @param dir the direction of the transfer\n @param formats the pointer to the output format list will be written here.\n The list is terminated with AV_PIX_FMT_NONE and must be freed\n by the caller when no longer needed using av_free().\n If this function returns successfully, the format list will\n have at least one item (not counting the terminator).\n On failure, the contents of this pointer are unspecified.\n @param flags currently unused, should be set to zero\n @return 0 on success, a negative AVERROR code on failure."]
6775 pub fn av_hwframe_transfer_get_formats(
6776 hwframe_ctx: *mut AVBufferRef,
6777 dir: AVHWFrameTransferDirection,
6778 formats: *mut *mut AVPixelFormat,
6779 flags: ::std::os::raw::c_int,
6780 ) -> ::std::os::raw::c_int;
6781}
6782#[doc = " This struct describes the constraints on hardware frames attached to\n a given device with a hardware-specific configuration. This is returned\n by av_hwdevice_get_hwframe_constraints() and must be freed by\n av_hwframe_constraints_free() after use."]
6783#[repr(C)]
6784#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6785pub struct AVHWFramesConstraints {
6786 #[doc = " A list of possible values for format in the hw_frames_ctx,\n terminated by AV_PIX_FMT_NONE. This member will always be filled."]
6787 pub valid_hw_formats: *mut AVPixelFormat,
6788 #[doc = " A list of possible values for sw_format in the hw_frames_ctx,\n terminated by AV_PIX_FMT_NONE. Can be NULL if this information is\n not known."]
6789 pub valid_sw_formats: *mut AVPixelFormat,
6790 #[doc = " The minimum size of frames in this hw_frames_ctx.\n (Zero if not known.)"]
6791 pub min_width: ::std::os::raw::c_int,
6792 pub min_height: ::std::os::raw::c_int,
6793 #[doc = " The maximum size of frames in this hw_frames_ctx.\n (INT_MAX if not known / no limit.)"]
6794 pub max_width: ::std::os::raw::c_int,
6795 pub max_height: ::std::os::raw::c_int,
6796}
6797impl Default for AVHWFramesConstraints {
6798 fn default() -> Self {
6799 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6800 unsafe {
6801 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6802 s.assume_init()
6803 }
6804 }
6805}
6806extern "C" {
6807 #[doc = " Allocate a HW-specific configuration structure for a given HW device.\n After use, the user must free all members as required by the specific\n hardware structure being used, then free the structure itself with\n av_free().\n\n @param device_ctx a reference to the associated AVHWDeviceContext.\n @return The newly created HW-specific configuration structure on\n success or NULL on failure."]
6808 pub fn av_hwdevice_hwconfig_alloc(device_ctx: *mut AVBufferRef) -> *mut ::std::os::raw::c_void;
6809}
6810extern "C" {
6811 #[doc = " Get the constraints on HW frames given a device and the HW-specific\n configuration to be used with that device. If no HW-specific\n configuration is provided, returns the maximum possible capabilities\n of the device.\n\n @param ref a reference to the associated AVHWDeviceContext.\n @param hwconfig a filled HW-specific configuration structure, or NULL\n to return the maximum possible capabilities of the device.\n @return AVHWFramesConstraints structure describing the constraints\n on the device, or NULL if not available."]
6812 pub fn av_hwdevice_get_hwframe_constraints(
6813 ref_: *mut AVBufferRef,
6814 hwconfig: *const ::std::os::raw::c_void,
6815 ) -> *mut AVHWFramesConstraints;
6816}
6817extern "C" {
6818 #[doc = " Free an AVHWFrameConstraints structure.\n\n @param constraints The (filled or unfilled) AVHWFrameConstraints structure."]
6819 pub fn av_hwframe_constraints_free(constraints: *mut *mut AVHWFramesConstraints);
6820}
6821#[doc = " The mapping must be readable."]
6822pub const AV_HWFRAME_MAP_READ: _bindgen_ty_2 = 1;
6823#[doc = " The mapping must be writeable."]
6824pub const AV_HWFRAME_MAP_WRITE: _bindgen_ty_2 = 2;
6825#[doc = " The mapped frame will be overwritten completely in subsequent\n operations, so the current frame data need not be loaded. Any values\n which are not overwritten are unspecified."]
6826pub const AV_HWFRAME_MAP_OVERWRITE: _bindgen_ty_2 = 4;
6827#[doc = " The mapping must be direct. That is, there must not be any copying in\n the map or unmap steps. Note that performance of direct mappings may\n be much lower than normal memory."]
6828pub const AV_HWFRAME_MAP_DIRECT: _bindgen_ty_2 = 8;
6829#[doc = " Flags to apply to frame mappings."]
6830pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
6831extern "C" {
6832 #[doc = " Map a hardware frame.\n\n This has a number of different possible effects, depending on the format\n and origin of the src and dst frames. On input, src should be a usable\n frame with valid buffers and dst should be blank (typically as just created\n by av_frame_alloc()). src should have an associated hwframe context, and\n dst may optionally have a format and associated hwframe context.\n\n If src was created by mapping a frame from the hwframe context of dst,\n then this function undoes the mapping - dst is replaced by a reference to\n the frame that src was originally mapped from.\n\n If both src and dst have an associated hwframe context, then this function\n attempts to map the src frame from its hardware context to that of dst and\n then fill dst with appropriate data to be usable there. This will only be\n possible if the hwframe contexts and associated devices are compatible -\n given compatible devices, av_hwframe_ctx_create_derived() can be used to\n create a hwframe context for dst in which mapping should be possible.\n\n If src has a hwframe context but dst does not, then the src frame is\n mapped to normal memory and should thereafter be usable as a normal frame.\n If the format is set on dst, then the mapping will attempt to create dst\n with that format and fail if it is not possible. If format is unset (is\n AV_PIX_FMT_NONE) then dst will be mapped with whatever the most appropriate\n format to use is (probably the sw_format of the src hwframe context).\n\n A return value of AVERROR(ENOSYS) indicates that the mapping is not\n possible with the given arguments and hwframe setup, while other return\n values indicate that it failed somehow.\n\n On failure, the destination frame will be left blank, except for the\n hw_frames_ctx/format fields thay may have been set by the caller - those will\n be preserved as they were.\n\n @param dst Destination frame, to contain the mapping.\n @param src Source frame, to be mapped.\n @param flags Some combination of AV_HWFRAME_MAP_* flags.\n @return Zero on success, negative AVERROR code on failure."]
6833 pub fn av_hwframe_map(
6834 dst: *mut AVFrame,
6835 src: *const AVFrame,
6836 flags: ::std::os::raw::c_int,
6837 ) -> ::std::os::raw::c_int;
6838}
6839extern "C" {
6840 #[doc = " Create and initialise an AVHWFramesContext as a mapping of another existing\n AVHWFramesContext on a different device.\n\n av_hwframe_ctx_init() should not be called after this.\n\n @param derived_frame_ctx On success, a reference to the newly created\n AVHWFramesContext.\n @param format The AVPixelFormat for the derived context.\n @param derived_device_ctx A reference to the device to create the new\n AVHWFramesContext on.\n @param source_frame_ctx A reference to an existing AVHWFramesContext\n which will be mapped to the derived context.\n @param flags Some combination of AV_HWFRAME_MAP_* flags, defining the\n mapping parameters to apply to frames which are allocated\n in the derived device.\n @return Zero on success, negative AVERROR code on failure."]
6841 pub fn av_hwframe_ctx_create_derived(
6842 derived_frame_ctx: *mut *mut AVBufferRef,
6843 format: AVPixelFormat,
6844 derived_device_ctx: *mut AVBufferRef,
6845 source_frame_ctx: *mut AVBufferRef,
6846 flags: ::std::os::raw::c_int,
6847 ) -> ::std::os::raw::c_int;
6848}
6849#[doc = " AVProfile."]
6850#[repr(C)]
6851#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6852pub struct AVProfile {
6853 pub profile: ::std::os::raw::c_int,
6854 #[doc = "< short name for the profile"]
6855 pub name: *const ::std::os::raw::c_char,
6856}
6857impl Default for AVProfile {
6858 fn default() -> Self {
6859 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6860 unsafe {
6861 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6862 s.assume_init()
6863 }
6864 }
6865}
6866#[doc = " AVCodec."]
6867#[repr(C)]
6868#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6869pub struct AVCodec {
6870 #[doc = " Name of the codec implementation.\n The name is globally unique among encoders and among decoders (but an\n encoder and a decoder can share the same name).\n This is the primary way to find a codec from the user perspective."]
6871 pub name: *const ::std::os::raw::c_char,
6872 #[doc = " Descriptive name for the codec, meant to be more human readable than name.\n You should use the NULL_IF_CONFIG_SMALL() macro to define it."]
6873 pub long_name: *const ::std::os::raw::c_char,
6874 pub type_: AVMediaType,
6875 pub id: AVCodecID,
6876 #[doc = " Codec capabilities.\n see AV_CODEC_CAP_*"]
6877 pub capabilities: ::std::os::raw::c_int,
6878 #[doc = "< maximum value for lowres supported by the decoder"]
6879 pub max_lowres: u8,
6880 #[doc = "< array of supported framerates, or NULL if any, array is terminated by {0,0}"]
6881 pub supported_framerates: *const AVRational,
6882 #[doc = "< array of supported pixel formats, or NULL if unknown, array is terminated by -1"]
6883 pub pix_fmts: *const AVPixelFormat,
6884 #[doc = "< array of supported audio samplerates, or NULL if unknown, array is terminated by 0"]
6885 pub supported_samplerates: *const ::std::os::raw::c_int,
6886 #[doc = "< array of supported sample formats, or NULL if unknown, array is terminated by -1"]
6887 pub sample_fmts: *const AVSampleFormat,
6888 #[doc = "< AVClass for the private context"]
6889 pub priv_class: *const AVClass,
6890 #[doc = "< array of recognized profiles, or NULL if unknown, array is terminated by {AV_PROFILE_UNKNOWN}"]
6891 pub profiles: *const AVProfile,
6892 #[doc = " Group name of the codec implementation.\n This is a short symbolic name of the wrapper backing this codec. A\n wrapper uses some kind of external implementation for the codec, such\n as an external library, or a codec implementation provided by the OS or\n the hardware.\n If this field is NULL, this is a builtin, libavcodec native codec.\n If non-NULL, this will be the suffix in AVCodec.name in most cases\n (usually AVCodec.name will be of the form \"<codec_name>_<wrapper_name>\")."]
6893 pub wrapper_name: *const ::std::os::raw::c_char,
6894 #[doc = " Array of supported channel layouts, terminated with a zeroed layout."]
6895 pub ch_layouts: *const AVChannelLayout,
6896}
6897impl Default for AVCodec {
6898 fn default() -> Self {
6899 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6900 unsafe {
6901 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6902 s.assume_init()
6903 }
6904 }
6905}
6906extern "C" {
6907 #[doc = " Iterate over all registered codecs.\n\n @param opaque a pointer where libavcodec will store the iteration state. Must\n point to NULL to start the iteration.\n\n @return the next registered codec or NULL when the iteration is\n finished"]
6908 pub fn av_codec_iterate(opaque: *mut *mut ::std::os::raw::c_void) -> *const AVCodec;
6909}
6910extern "C" {
6911 #[doc = " Find a registered decoder with a matching codec ID.\n\n @param id AVCodecID of the requested decoder\n @return A decoder if one was found, NULL otherwise."]
6912 pub fn avcodec_find_decoder(id: AVCodecID) -> *const AVCodec;
6913}
6914extern "C" {
6915 #[doc = " Find a registered decoder with the specified name.\n\n @param name name of the requested decoder\n @return A decoder if one was found, NULL otherwise."]
6916 pub fn avcodec_find_decoder_by_name(name: *const ::std::os::raw::c_char) -> *const AVCodec;
6917}
6918extern "C" {
6919 #[doc = " Find a registered encoder with a matching codec ID.\n\n @param id AVCodecID of the requested encoder\n @return An encoder if one was found, NULL otherwise."]
6920 pub fn avcodec_find_encoder(id: AVCodecID) -> *const AVCodec;
6921}
6922extern "C" {
6923 #[doc = " Find a registered encoder with the specified name.\n\n @param name name of the requested encoder\n @return An encoder if one was found, NULL otherwise."]
6924 pub fn avcodec_find_encoder_by_name(name: *const ::std::os::raw::c_char) -> *const AVCodec;
6925}
6926extern "C" {
6927 #[doc = " @return a non-zero number if codec is an encoder, zero otherwise"]
6928 pub fn av_codec_is_encoder(codec: *const AVCodec) -> ::std::os::raw::c_int;
6929}
6930extern "C" {
6931 #[doc = " @return a non-zero number if codec is a decoder, zero otherwise"]
6932 pub fn av_codec_is_decoder(codec: *const AVCodec) -> ::std::os::raw::c_int;
6933}
6934extern "C" {
6935 #[doc = " Return a name for the specified profile, if available.\n\n @param codec the codec that is searched for the given profile\n @param profile the profile value for which a name is requested\n @return A name for the profile if found, NULL otherwise."]
6936 pub fn av_get_profile_name(
6937 codec: *const AVCodec,
6938 profile: ::std::os::raw::c_int,
6939 ) -> *const ::std::os::raw::c_char;
6940}
6941#[doc = " The codec supports this format via the hw_device_ctx interface.\n\n When selecting this format, AVCodecContext.hw_device_ctx should\n have been set to a device of the specified type before calling\n avcodec_open2()."]
6942pub const AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX: _bindgen_ty_3 = 1;
6943#[doc = " The codec supports this format via the hw_frames_ctx interface.\n\n When selecting this format for a decoder,\n AVCodecContext.hw_frames_ctx should be set to a suitable frames\n context inside the get_format() callback. The frames context\n must have been created on a device of the specified type.\n\n When selecting this format for an encoder,\n AVCodecContext.hw_frames_ctx should be set to the context which\n will be used for the input frames before calling avcodec_open2()."]
6944pub const AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX: _bindgen_ty_3 = 2;
6945#[doc = " The codec supports this format by some internal method.\n\n This format can be selected without any additional configuration -\n no device or frames context is required."]
6946pub const AV_CODEC_HW_CONFIG_METHOD_INTERNAL: _bindgen_ty_3 = 4;
6947#[doc = " The codec supports this format by some ad-hoc method.\n\n Additional settings and/or function calls are required. See the\n codec-specific documentation for details. (Methods requiring\n this sort of configuration are deprecated and others should be\n used in preference.)"]
6948pub const AV_CODEC_HW_CONFIG_METHOD_AD_HOC: _bindgen_ty_3 = 8;
6949pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
6950#[repr(C)]
6951#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6952pub struct AVCodecHWConfig {
6953 #[doc = " For decoders, a hardware pixel format which that decoder may be\n able to decode to if suitable hardware is available.\n\n For encoders, a pixel format which the encoder may be able to\n accept. If set to AV_PIX_FMT_NONE, this applies to all pixel\n formats supported by the codec."]
6954 pub pix_fmt: AVPixelFormat,
6955 #[doc = " Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible\n setup methods which can be used with this configuration."]
6956 pub methods: ::std::os::raw::c_int,
6957 #[doc = " The device type associated with the configuration.\n\n Must be set for AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX and\n AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, otherwise unused."]
6958 pub device_type: AVHWDeviceType,
6959}
6960impl Default for AVCodecHWConfig {
6961 fn default() -> Self {
6962 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6963 unsafe {
6964 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6965 s.assume_init()
6966 }
6967 }
6968}
6969extern "C" {
6970 #[doc = " Retrieve supported hardware configurations for a codec.\n\n Values of index from zero to some maximum return the indexed configuration\n descriptor; all other values return NULL. If the codec does not support\n any hardware configurations then it will always return NULL."]
6971 pub fn avcodec_get_hw_config(
6972 codec: *const AVCodec,
6973 index: ::std::os::raw::c_int,
6974 ) -> *const AVCodecHWConfig;
6975}
6976extern "C" {
6977 #[doc = " Allocate and read the payload of a packet and initialize its\n fields with default values.\n\n @param s associated IO context\n @param pkt packet\n @param size desired payload size\n @return >0 (read size) if OK, AVERROR_xxx otherwise"]
6978 pub fn av_get_packet(
6979 s: *mut AVIOContext,
6980 pkt: *mut AVPacket,
6981 size: ::std::os::raw::c_int,
6982 ) -> ::std::os::raw::c_int;
6983}
6984extern "C" {
6985 #[doc = " Read data and append it to the current content of the AVPacket.\n If pkt->size is 0 this is identical to av_get_packet.\n Note that this uses av_grow_packet and thus involves a realloc\n which is inefficient. Thus this function should only be used\n when there is no reasonable way to know (an upper bound of)\n the final size.\n\n @param s associated IO context\n @param pkt packet\n @param size amount of data to read\n @return >0 (read size) if OK, AVERROR_xxx otherwise, previous data\n will not be lost even if an error occurs."]
6986 pub fn av_append_packet(
6987 s: *mut AVIOContext,
6988 pkt: *mut AVPacket,
6989 size: ::std::os::raw::c_int,
6990 ) -> ::std::os::raw::c_int;
6991}
6992#[repr(C)]
6993#[derive(Debug, Copy, Clone)]
6994pub struct AVCodecTag {
6995 _unused: [u8; 0],
6996}
6997#[doc = " This structure contains the data a format has to probe a file."]
6998#[repr(C)]
6999#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
7000pub struct AVProbeData {
7001 pub filename: *const ::std::os::raw::c_char,
7002 #[doc = "< Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero."]
7003 pub buf: *mut ::std::os::raw::c_uchar,
7004 #[doc = "< Size of buf except extra allocated bytes"]
7005 pub buf_size: ::std::os::raw::c_int,
7006 #[doc = "< mime_type, when known."]
7007 pub mime_type: *const ::std::os::raw::c_char,
7008}
7009impl Default for AVProbeData {
7010 fn default() -> Self {
7011 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7012 unsafe {
7013 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7014 s.assume_init()
7015 }
7016 }
7017}
7018#[doc = " @addtogroup lavf_encoding\n @{"]
7019#[repr(C)]
7020#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
7021pub struct AVOutputFormat {
7022 pub name: *const ::std::os::raw::c_char,
7023 #[doc = " Descriptive name for the format, meant to be more human-readable\n than name. You should use the NULL_IF_CONFIG_SMALL() macro\n to define it."]
7024 pub long_name: *const ::std::os::raw::c_char,
7025 pub mime_type: *const ::std::os::raw::c_char,
7026 #[doc = "< comma-separated filename extensions"]
7027 pub extensions: *const ::std::os::raw::c_char,
7028 #[doc = "< default audio codec"]
7029 pub audio_codec: AVCodecID,
7030 #[doc = "< default video codec"]
7031 pub video_codec: AVCodecID,
7032 #[doc = "< default subtitle codec"]
7033 pub subtitle_codec: AVCodecID,
7034 #[doc = " can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER,\n AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS,\n AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS,\n AVFMT_TS_NONSTRICT, AVFMT_TS_NEGATIVE"]
7035 pub flags: ::std::os::raw::c_int,
7036 #[doc = " List of supported codec_id-codec_tag pairs, ordered by \"better\n choice first\". The arrays are all terminated by AV_CODEC_ID_NONE."]
7037 pub codec_tag: *const *const AVCodecTag,
7038 #[doc = "< AVClass for the private context"]
7039 pub priv_class: *const AVClass,
7040}
7041impl Default for AVOutputFormat {
7042 fn default() -> Self {
7043 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7044 unsafe {
7045 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7046 s.assume_init()
7047 }
7048 }
7049}
7050#[doc = " @addtogroup lavf_decoding\n @{"]
7051#[repr(C)]
7052#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
7053pub struct AVInputFormat {
7054 #[doc = " A comma separated list of short names for the format. New names\n may be appended with a minor bump."]
7055 pub name: *const ::std::os::raw::c_char,
7056 #[doc = " Descriptive name for the format, meant to be more human-readable\n than name. You should use the NULL_IF_CONFIG_SMALL() macro\n to define it."]
7057 pub long_name: *const ::std::os::raw::c_char,
7058 #[doc = " Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS,\n AVFMT_NOTIMESTAMPS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH,\n AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS."]
7059 pub flags: ::std::os::raw::c_int,
7060 #[doc = " If extensions are defined, then no probe is done. You should\n usually not use extension format guessing because it is not\n reliable enough"]
7061 pub extensions: *const ::std::os::raw::c_char,
7062 pub codec_tag: *const *const AVCodecTag,
7063 #[doc = "< AVClass for the private context"]
7064 pub priv_class: *const AVClass,
7065 #[doc = " Comma-separated list of mime types.\n It is used check for matching mime types while probing.\n @see av_probe_input_format2"]
7066 pub mime_type: *const ::std::os::raw::c_char,
7067}
7068impl Default for AVInputFormat {
7069 fn default() -> Self {
7070 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7071 unsafe {
7072 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7073 s.assume_init()
7074 }
7075 }
7076}
7077pub const AVStreamParseType_AVSTREAM_PARSE_NONE: AVStreamParseType = 0;
7078#[doc = "< full parsing and repack"]
7079pub const AVStreamParseType_AVSTREAM_PARSE_FULL: AVStreamParseType = 1;
7080#[doc = "< Only parse headers, do not repack."]
7081pub const AVStreamParseType_AVSTREAM_PARSE_HEADERS: AVStreamParseType = 2;
7082#[doc = "< full parsing and interpolation of timestamps for frames not starting on a packet boundary"]
7083pub const AVStreamParseType_AVSTREAM_PARSE_TIMESTAMPS: AVStreamParseType = 3;
7084#[doc = "< full parsing and repack of the first frame only, only implemented for H.264 currently"]
7085pub const AVStreamParseType_AVSTREAM_PARSE_FULL_ONCE: AVStreamParseType = 4;
7086#[doc = "< full parsing and repack with timestamp and position generation by parser for raw\nthis assumes that each packet in the file contains no demuxer level headers and\njust codec level data, otherwise position generation would fail"]
7087pub const AVStreamParseType_AVSTREAM_PARSE_FULL_RAW: AVStreamParseType = 5;
7088#[doc = " @}"]
7089pub type AVStreamParseType = ::std::os::raw::c_uint;
7090#[repr(C)]
7091#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
7092pub struct AVIndexEntry {
7093 pub pos: i64,
7094 #[doc = "<\n Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are available\n when seeking to this entry. That means preferable PTS on keyframe based formats.\n But demuxers can choose to store a different timestamp, if it is more convenient for the implementation or nothing better\n is known"]
7095 pub timestamp: i64,
7096 pub _bitfield_align_1: [u32; 0],
7097 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
7098 #[doc = "< Minimum distance between this and the previous keyframe, used to avoid unneeded searching."]
7099 pub min_distance: ::std::os::raw::c_int,
7100}
7101impl AVIndexEntry {
7102 #[inline]
7103 pub fn flags(&self) -> ::std::os::raw::c_int {
7104 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
7105 }
7106 #[inline]
7107 pub fn set_flags(&mut self, val: ::std::os::raw::c_int) {
7108 unsafe {
7109 let val: u32 = ::std::mem::transmute(val);
7110 self._bitfield_1.set(0usize, 2u8, val as u64)
7111 }
7112 }
7113 #[inline]
7114 pub fn size(&self) -> ::std::os::raw::c_int {
7115 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
7116 }
7117 #[inline]
7118 pub fn set_size(&mut self, val: ::std::os::raw::c_int) {
7119 unsafe {
7120 let val: u32 = ::std::mem::transmute(val);
7121 self._bitfield_1.set(2usize, 30u8, val as u64)
7122 }
7123 }
7124 #[inline]
7125 pub fn new_bitfield_1(
7126 flags: ::std::os::raw::c_int,
7127 size: ::std::os::raw::c_int,
7128 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
7129 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
7130 __bindgen_bitfield_unit.set(0usize, 2u8, {
7131 let flags: u32 = unsafe { ::std::mem::transmute(flags) };
7132 flags as u64
7133 });
7134 __bindgen_bitfield_unit.set(2usize, 30u8, {
7135 let size: u32 = unsafe { ::std::mem::transmute(size) };
7136 size as u64
7137 });
7138 __bindgen_bitfield_unit
7139 }
7140}
7141extern "C" {
7142 #[doc = " @return The AV_DISPOSITION_* flag corresponding to disp or a negative error\n code if disp does not correspond to a known stream disposition."]
7143 pub fn av_disposition_from_string(disp: *const ::std::os::raw::c_char)
7144 -> ::std::os::raw::c_int;
7145}
7146extern "C" {
7147 #[doc = " @param disposition a combination of AV_DISPOSITION_* values\n @return The string description corresponding to the lowest set bit in\n disposition. NULL when the lowest set bit does not correspond\n to a known disposition or when disposition is 0."]
7148 pub fn av_disposition_to_string(
7149 disposition: ::std::os::raw::c_int,
7150 ) -> *const ::std::os::raw::c_char;
7151}
7152#[doc = " Stream structure.\n New fields can be added to the end with minor version bumps.\n Removal, reordering and changes to existing fields require a major\n version bump.\n sizeof(AVStream) must not be used outside libav*."]
7153#[repr(C)]
7154#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
7155pub struct AVStream {
7156 #[doc = " A class for @ref avoptions. Set on stream creation."]
7157 pub av_class: *const AVClass,
7158 #[doc = "< stream index in AVFormatContext"]
7159 pub index: ::std::os::raw::c_int,
7160 #[doc = " Format-specific stream ID.\n decoding: set by libavformat\n encoding: set by the user, replaced by libavformat if left unset"]
7161 pub id: ::std::os::raw::c_int,
7162 #[doc = " Codec parameters associated with this stream. Allocated and freed by\n libavformat in avformat_new_stream() and avformat_free_context()\n respectively.\n\n - demuxing: filled by libavformat on stream creation or in\n avformat_find_stream_info()\n - muxing: filled by the caller before avformat_write_header()"]
7163 pub codecpar: *mut AVCodecParameters,
7164 pub priv_data: *mut ::std::os::raw::c_void,
7165 #[doc = " This is the fundamental unit of time (in seconds) in terms\n of which frame timestamps are represented.\n\n decoding: set by libavformat\n encoding: May be set by the caller before avformat_write_header() to\n provide a hint to the muxer about the desired timebase. In\n avformat_write_header(), the muxer will overwrite this field\n with the timebase that will actually be used for the timestamps\n written into the file (which may or may not be related to the\n user-provided one, depending on the format)."]
7166 pub time_base: AVRational,
7167 #[doc = " Decoding: pts of the first frame of the stream in presentation order, in stream time base.\n Only set this if you are absolutely 100% sure that the value you set\n it to really is the pts of the first frame.\n This may be undefined (AV_NOPTS_VALUE).\n @note The ASF header does NOT contain a correct start_time the ASF\n demuxer must NOT set this."]
7168 pub start_time: i64,
7169 #[doc = " Decoding: duration of the stream, in stream time base.\n If a source file does not specify a duration, but does specify\n a bitrate, this value will be estimated from bitrate and file size.\n\n Encoding: May be set by the caller before avformat_write_header() to\n provide a hint to the muxer about the estimated duration."]
7170 pub duration: i64,
7171 #[doc = "< number of frames in this stream if known or 0"]
7172 pub nb_frames: i64,
7173 #[doc = " Stream disposition - a combination of AV_DISPOSITION_* flags.\n - demuxing: set by libavformat when creating the stream or in\n avformat_find_stream_info().\n - muxing: may be set by the caller before avformat_write_header()."]
7174 pub disposition: ::std::os::raw::c_int,
7175 #[doc = "< Selects which packets can be discarded at will and do not need to be demuxed."]
7176 pub discard: AVDiscard,
7177 #[doc = " sample aspect ratio (0 if unknown)\n - encoding: Set by user.\n - decoding: Set by libavformat."]
7178 pub sample_aspect_ratio: AVRational,
7179 pub metadata: *mut AVDictionary,
7180 #[doc = " Average framerate\n\n - demuxing: May be set by libavformat when creating the stream or in\n avformat_find_stream_info().\n - muxing: May be set by the caller before avformat_write_header()."]
7181 pub avg_frame_rate: AVRational,
7182 #[doc = " For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet\n will contain the attached picture.\n\n decoding: set by libavformat, must not be modified by the caller.\n encoding: unused"]
7183 pub attached_pic: AVPacket,
7184 #[doc = " An array of side data that applies to the whole stream (i.e. the\n container does not allow it to change between packets).\n\n There may be no overlap between the side data in this array and side data\n in the packets. I.e. a given side data is either exported by the muxer\n (demuxing) / set by the caller (muxing) in this array, then it never\n appears in the packets, or the side data is exported / sent through\n the packets (always in the first packet where the value becomes known or\n changes), then it does not appear in this array.\n\n - demuxing: Set by libavformat when the stream is created.\n - muxing: May be set by the caller before avformat_write_header().\n\n Freed by libavformat in avformat_free_context().\n\n @deprecated use AVStream's @ref AVCodecParameters.coded_side_data\n \"codecpar side data\"."]
7185 pub side_data: *mut AVPacketSideData,
7186 #[doc = " The number of elements in the AVStream.side_data array.\n\n @deprecated use AVStream's @ref AVCodecParameters.nb_coded_side_data\n \"codecpar side data\"."]
7187 pub nb_side_data: ::std::os::raw::c_int,
7188 #[doc = " Flags indicating events happening on the stream, a combination of\n AVSTREAM_EVENT_FLAG_*.\n\n - demuxing: may be set by the demuxer in avformat_open_input(),\n avformat_find_stream_info() and av_read_frame(). Flags must be cleared\n by the user once the event has been handled.\n - muxing: may be set by the user after avformat_write_header(). to\n indicate a user-triggered event. The muxer will clear the flags for\n events it has handled in av_[interleaved]_write_frame()."]
7189 pub event_flags: ::std::os::raw::c_int,
7190 #[doc = " Real base framerate of the stream.\n This is the lowest framerate with which all timestamps can be\n represented accurately (it is the least common multiple of all\n framerates in the stream). Note, this value is just a guess!\n For example, if the time base is 1/90000 and all frames have either\n approximately 3600 or 1800 timer ticks, then r_frame_rate will be 50/1."]
7191 pub r_frame_rate: AVRational,
7192 #[doc = " Number of bits in timestamps. Used for wrapping control.\n\n - demuxing: set by libavformat\n - muxing: set by libavformat\n"]
7193 pub pts_wrap_bits: ::std::os::raw::c_int,
7194}
7195impl Default for AVStream {
7196 fn default() -> Self {
7197 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7198 unsafe {
7199 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7200 s.assume_init()
7201 }
7202 }
7203}
7204#[doc = " AVStreamGroupTileGrid holds information on how to combine several\n independent images on a single canvas for presentation.\n\n The output should be a @ref AVStreamGroupTileGrid.background \"background\"\n colored @ref AVStreamGroupTileGrid.coded_width \"coded_width\" x\n @ref AVStreamGroupTileGrid.coded_height \"coded_height\" canvas where a\n @ref AVStreamGroupTileGrid.nb_tiles \"nb_tiles\" amount of tiles are placed in\n the order they appear in the @ref AVStreamGroupTileGrid.offsets \"offsets\"\n array, at the exact offset described for them. In particular, if two or more\n tiles overlap, the image with higher index in the\n @ref AVStreamGroupTileGrid.offsets \"offsets\" array takes priority.\n Note that a single image may be used multiple times, i.e. multiple entries\n in @ref AVStreamGroupTileGrid.offsets \"offsets\" may have the same value of\n idx.\n\n The following is an example of a simple grid with 3 rows and 4 columns:\n\n +---+---+---+---+\n | 0 | 1 | 2 | 3 |\n +---+---+---+---+\n | 4 | 5 | 6 | 7 |\n +---+---+---+---+\n | 8 | 9 |10 |11 |\n +---+---+---+---+\n\n Assuming all tiles have a dimension of 512x512, the\n @ref AVStreamGroupTileGrid.offsets \"offset\" of the topleft pixel of\n the first @ref AVStreamGroup.streams \"stream\" in the group is \"0,0\", the\n @ref AVStreamGroupTileGrid.offsets \"offset\" of the topleft pixel of\n the second @ref AVStreamGroup.streams \"stream\" in the group is \"512,0\", the\n @ref AVStreamGroupTileGrid.offsets \"offset\" of the topleft pixel of\n the fifth @ref AVStreamGroup.streams \"stream\" in the group is \"0,512\", the\n @ref AVStreamGroupTileGrid.offsets \"offset\", of the topleft pixel of\n the sixth @ref AVStreamGroup.streams \"stream\" in the group is \"512,512\",\n etc.\n\n The following is an example of a canvas with overlaping tiles:\n\n +-----------+\n | %%%%% |\n |***%%3%%@@@|\n |**0%%%%%2@@|\n |***##1@@@@@|\n | ##### |\n +-----------+\n\n Assuming a canvas with size 1024x1024 and all tiles with a dimension of\n 512x512, a possible @ref AVStreamGroupTileGrid.offsets \"offset\" for the\n topleft pixel of the first @ref AVStreamGroup.streams \"stream\" in the group\n would be 0x256, the @ref AVStreamGroupTileGrid.offsets \"offset\" for the\n topleft pixel of the second @ref AVStreamGroup.streams \"stream\" in the group\n would be 256x512, the @ref AVStreamGroupTileGrid.offsets \"offset\" for the\n topleft pixel of the third @ref AVStreamGroup.streams \"stream\" in the group\n would be 512x256, and the @ref AVStreamGroupTileGrid.offsets \"offset\" for\n the topleft pixel of the fourth @ref AVStreamGroup.streams \"stream\" in the\n group would be 256x0.\n\n sizeof(AVStreamGroupTileGrid) is not a part of the ABI and may only be\n allocated by avformat_stream_group_create()."]
7205#[repr(C)]
7206#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
7207pub struct AVStreamGroupTileGrid {
7208 pub av_class: *const AVClass,
7209 #[doc = " Amount of tiles in the grid.\n\n Must be > 0."]
7210 pub nb_tiles: ::std::os::raw::c_uint,
7211 #[doc = " Width of the canvas.\n\n Must be > 0."]
7212 pub coded_width: ::std::os::raw::c_int,
7213 #[doc = " Width of the canvas.\n\n Must be > 0."]
7214 pub coded_height: ::std::os::raw::c_int,
7215 pub offsets: *mut AVStreamGroupTileGrid__bindgen_ty_1,
7216 #[doc = " The pixel value per channel in RGBA format used if no pixel of any tile\n is located at a particular pixel location.\n\n @see av_image_fill_color().\n @see av_parse_color()."]
7217 pub background: [u8; 4usize],
7218 #[doc = " Offset in pixels from the left edge of the canvas where the actual image\n meant for presentation starts.\n\n This field must be >= 0 and < @ref coded_width."]
7219 pub horizontal_offset: ::std::os::raw::c_int,
7220 #[doc = " Offset in pixels from the top edge of the canvas where the actual image\n meant for presentation starts.\n\n This field must be >= 0 and < @ref coded_height."]
7221 pub vertical_offset: ::std::os::raw::c_int,
7222 #[doc = " Width of the final image for presentation.\n\n Must be > 0 and <= (@ref coded_width - @ref horizontal_offset).\n When it's not equal to (@ref coded_width - @ref horizontal_offset), the\n result of (@ref coded_width - width - @ref horizontal_offset) is the\n amount amount of pixels to be cropped from the right edge of the\n final image before presentation."]
7223 pub width: ::std::os::raw::c_int,
7224 #[doc = " Height of the final image for presentation.\n\n Must be > 0 and <= (@ref coded_height - @ref vertical_offset).\n When it's not equal to (@ref coded_height - @ref vertical_offset), the\n result of (@ref coded_height - height - @ref vertical_offset) is the\n amount amount of pixels to be cropped from the bottom edge of the\n final image before presentation."]
7225 pub height: ::std::os::raw::c_int,
7226}
7227#[doc = " An @ref nb_tiles sized array of offsets in pixels from the topleft edge\n of the canvas, indicating where each stream should be placed.\n It must be allocated with the av_malloc() family of functions.\n\n - demuxing: set by libavformat, must not be modified by the caller.\n - muxing: set by the caller before avformat_write_header().\n\n Freed by libavformat in avformat_free_context()."]
7228#[repr(C)]
7229#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
7230pub struct AVStreamGroupTileGrid__bindgen_ty_1 {
7231 #[doc = " Index of the stream in the group this tile references.\n\n Must be < @ref AVStreamGroup.nb_streams \"nb_streams\"."]
7232 pub idx: ::std::os::raw::c_uint,
7233 #[doc = " Offset in pixels from the left edge of the canvas where the tile\n should be placed."]
7234 pub horizontal: ::std::os::raw::c_int,
7235 #[doc = " Offset in pixels from the top edge of the canvas where the tile\n should be placed."]
7236 pub vertical: ::std::os::raw::c_int,
7237}
7238impl Default for AVStreamGroupTileGrid {
7239 fn default() -> Self {
7240 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7241 unsafe {
7242 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7243 s.assume_init()
7244 }
7245 }
7246}
7247pub const AVStreamGroupParamsType_AV_STREAM_GROUP_PARAMS_NONE: AVStreamGroupParamsType = 0;
7248pub const AVStreamGroupParamsType_AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT:
7249 AVStreamGroupParamsType = 1;
7250pub const AVStreamGroupParamsType_AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION:
7251 AVStreamGroupParamsType = 2;
7252pub const AVStreamGroupParamsType_AV_STREAM_GROUP_PARAMS_TILE_GRID: AVStreamGroupParamsType = 3;
7253pub type AVStreamGroupParamsType = ::std::os::raw::c_uint;
7254#[repr(C)]
7255#[derive(Debug, Copy, Clone)]
7256pub struct AVIAMFAudioElement {
7257 _unused: [u8; 0],
7258}
7259#[repr(C)]
7260#[derive(Debug, Copy, Clone)]
7261pub struct AVIAMFMixPresentation {
7262 _unused: [u8; 0],
7263}
7264#[repr(C)]
7265#[derive(Copy, Clone)]
7266pub struct AVStreamGroup {
7267 #[doc = " A class for @ref avoptions. Set by avformat_stream_group_create()."]
7268 pub av_class: *const AVClass,
7269 pub priv_data: *mut ::std::os::raw::c_void,
7270 #[doc = " Group index in AVFormatContext."]
7271 pub index: ::std::os::raw::c_uint,
7272 #[doc = " Group type-specific group ID.\n\n decoding: set by libavformat\n encoding: may set by the user"]
7273 pub id: i64,
7274 #[doc = " Group type\n\n decoding: set by libavformat on group creation\n encoding: set by avformat_stream_group_create()"]
7275 pub type_: AVStreamGroupParamsType,
7276 pub params: AVStreamGroup__bindgen_ty_1,
7277 #[doc = " Metadata that applies to the whole group.\n\n - demuxing: set by libavformat on group creation\n - muxing: may be set by the caller before avformat_write_header()\n\n Freed by libavformat in avformat_free_context()."]
7278 pub metadata: *mut AVDictionary,
7279 #[doc = " Number of elements in AVStreamGroup.streams.\n\n Set by avformat_stream_group_add_stream() must not be modified by any other code."]
7280 pub nb_streams: ::std::os::raw::c_uint,
7281 #[doc = " A list of streams in the group. New entries are created with\n avformat_stream_group_add_stream().\n\n - demuxing: entries are created by libavformat on group creation.\n If AVFMTCTX_NOHEADER is set in ctx_flags, then new entries may also\n appear in av_read_frame().\n - muxing: entries are created by the user before avformat_write_header().\n\n Freed by libavformat in avformat_free_context()."]
7282 pub streams: *mut *mut AVStream,
7283 #[doc = " Stream group disposition - a combination of AV_DISPOSITION_* flags.\n This field currently applies to all defined AVStreamGroupParamsType.\n\n - demuxing: set by libavformat when creating the group or in\n avformat_find_stream_info().\n - muxing: may be set by the caller before avformat_write_header()."]
7284 pub disposition: ::std::os::raw::c_int,
7285}
7286#[doc = " Group type-specific parameters"]
7287#[repr(C)]
7288#[derive(Copy, Clone)]
7289pub union AVStreamGroup__bindgen_ty_1 {
7290 pub iamf_audio_element: *mut AVIAMFAudioElement,
7291 pub iamf_mix_presentation: *mut AVIAMFMixPresentation,
7292 pub tile_grid: *mut AVStreamGroupTileGrid,
7293}
7294impl Default for AVStreamGroup__bindgen_ty_1 {
7295 fn default() -> Self {
7296 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7297 unsafe {
7298 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7299 s.assume_init()
7300 }
7301 }
7302}
7303impl Default for AVStreamGroup {
7304 fn default() -> Self {
7305 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7306 unsafe {
7307 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7308 s.assume_init()
7309 }
7310 }
7311}
7312#[repr(C)]
7313#[derive(Debug, Copy, Clone)]
7314pub struct AVCodecParserContext {
7315 _unused: [u8; 0],
7316}
7317extern "C" {
7318 pub fn av_stream_get_parser(s: *const AVStream) -> *mut AVCodecParserContext;
7319}
7320#[doc = " New fields can be added to the end with minor version bumps.\n Removal, reordering and changes to existing fields require a major\n version bump.\n sizeof(AVProgram) must not be used outside libav*."]
7321#[repr(C)]
7322#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
7323pub struct AVProgram {
7324 pub id: ::std::os::raw::c_int,
7325 pub flags: ::std::os::raw::c_int,
7326 #[doc = "< selects which program to discard and which to feed to the caller"]
7327 pub discard: AVDiscard,
7328 pub stream_index: *mut ::std::os::raw::c_uint,
7329 pub nb_stream_indexes: ::std::os::raw::c_uint,
7330 pub metadata: *mut AVDictionary,
7331 pub program_num: ::std::os::raw::c_int,
7332 pub pmt_pid: ::std::os::raw::c_int,
7333 pub pcr_pid: ::std::os::raw::c_int,
7334 pub pmt_version: ::std::os::raw::c_int,
7335 #[doc = " All fields below this line are not part of the public API. They\n may not be used outside of libavformat and can be changed and\n removed at will.\n New public fields should be added right above.\n"]
7336 pub start_time: i64,
7337 pub end_time: i64,
7338 #[doc = "< reference dts for wrap detection"]
7339 pub pts_wrap_reference: i64,
7340 #[doc = "< behavior on wrap detection"]
7341 pub pts_wrap_behavior: ::std::os::raw::c_int,
7342}
7343impl Default for AVProgram {
7344 fn default() -> Self {
7345 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7346 unsafe {
7347 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7348 s.assume_init()
7349 }
7350 }
7351}
7352#[repr(C)]
7353#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
7354pub struct AVChapter {
7355 #[doc = "< unique ID to identify the chapter"]
7356 pub id: i64,
7357 #[doc = "< time base in which the start/end timestamps are specified"]
7358 pub time_base: AVRational,
7359 #[doc = "< chapter start/end time in time_base units"]
7360 pub start: i64,
7361 #[doc = "< chapter start/end time in time_base units"]
7362 pub end: i64,
7363 pub metadata: *mut AVDictionary,
7364}
7365impl Default for AVChapter {
7366 fn default() -> Self {
7367 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7368 unsafe {
7369 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7370 s.assume_init()
7371 }
7372 }
7373}
7374#[doc = " Callback used by devices to communicate with application."]
7375pub type av_format_control_message = ::std::option::Option<
7376 unsafe extern "C" fn(
7377 s: *mut AVFormatContext,
7378 type_: ::std::os::raw::c_int,
7379 data: *mut ::std::os::raw::c_void,
7380 data_size: usize,
7381 ) -> ::std::os::raw::c_int,
7382>;
7383pub type AVOpenCallback = ::std::option::Option<
7384 unsafe extern "C" fn(
7385 s: *mut AVFormatContext,
7386 pb: *mut *mut AVIOContext,
7387 url: *const ::std::os::raw::c_char,
7388 flags: ::std::os::raw::c_int,
7389 int_cb: *const AVIOInterruptCB,
7390 options: *mut *mut AVDictionary,
7391 ) -> ::std::os::raw::c_int,
7392>;
7393#[doc = "< Duration accurately estimated from PTSes"]
7394pub const AVDurationEstimationMethod_AVFMT_DURATION_FROM_PTS: AVDurationEstimationMethod = 0;
7395#[doc = "< Duration estimated from a stream with a known duration"]
7396pub const AVDurationEstimationMethod_AVFMT_DURATION_FROM_STREAM: AVDurationEstimationMethod = 1;
7397#[doc = "< Duration estimated from bitrate (less accurate)"]
7398pub const AVDurationEstimationMethod_AVFMT_DURATION_FROM_BITRATE: AVDurationEstimationMethod = 2;
7399#[doc = " The duration of a video can be estimated through various ways, and this enum can be used\n to know how the duration was estimated."]
7400pub type AVDurationEstimationMethod = ::std::os::raw::c_uint;
7401#[doc = " Format I/O context.\n New fields can be added to the end with minor version bumps.\n Removal, reordering and changes to existing fields require a major\n version bump.\n sizeof(AVFormatContext) must not be used outside libav*, use\n avformat_alloc_context() to create an AVFormatContext.\n\n Fields can be accessed through AVOptions (av_opt*),\n the name string used matches the associated command line parameter name and\n can be found in libavformat/options_table.h.\n The AVOption/command line parameter names differ in some cases from the C\n structure field names for historic reasons or brevity."]
7402#[repr(C)]
7403#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
7404pub struct AVFormatContext {
7405 #[doc = " A class for logging and @ref avoptions. Set by avformat_alloc_context().\n Exports (de)muxer private options if they exist."]
7406 pub av_class: *const AVClass,
7407 #[doc = " The input container format.\n\n Demuxing only, set by avformat_open_input()."]
7408 pub iformat: *const AVInputFormat,
7409 #[doc = " The output container format.\n\n Muxing only, must be set by the caller before avformat_write_header()."]
7410 pub oformat: *const AVOutputFormat,
7411 #[doc = " Format private data. This is an AVOptions-enabled struct\n if and only if iformat/oformat.priv_class is not NULL.\n\n - muxing: set by avformat_write_header()\n - demuxing: set by avformat_open_input()"]
7412 pub priv_data: *mut ::std::os::raw::c_void,
7413 #[doc = " I/O context.\n\n - demuxing: either set by the user before avformat_open_input() (then\n the user must close it manually) or set by avformat_open_input().\n - muxing: set by the user before avformat_write_header(). The caller must\n take care of closing / freeing the IO context.\n\n Do NOT set this field if AVFMT_NOFILE flag is set in\n iformat/oformat.flags. In such a case, the (de)muxer will handle\n I/O in some other way and this field will be NULL."]
7414 pub pb: *mut AVIOContext,
7415 #[doc = " Flags signalling stream properties. A combination of AVFMTCTX_*.\n Set by libavformat."]
7416 pub ctx_flags: ::std::os::raw::c_int,
7417 #[doc = " Number of elements in AVFormatContext.streams.\n\n Set by avformat_new_stream(), must not be modified by any other code."]
7418 pub nb_streams: ::std::os::raw::c_uint,
7419 #[doc = " A list of all streams in the file. New streams are created with\n avformat_new_stream().\n\n - demuxing: streams are created by libavformat in avformat_open_input().\n If AVFMTCTX_NOHEADER is set in ctx_flags, then new streams may also\n appear in av_read_frame().\n - muxing: streams are created by the user before avformat_write_header().\n\n Freed by libavformat in avformat_free_context()."]
7420 pub streams: *mut *mut AVStream,
7421 #[doc = " Number of elements in AVFormatContext.stream_groups.\n\n Set by avformat_stream_group_create(), must not be modified by any other code."]
7422 pub nb_stream_groups: ::std::os::raw::c_uint,
7423 #[doc = " A list of all stream groups in the file. New groups are created with\n avformat_stream_group_create(), and filled with avformat_stream_group_add_stream().\n\n - demuxing: groups may be created by libavformat in avformat_open_input().\n If AVFMTCTX_NOHEADER is set in ctx_flags, then new groups may also\n appear in av_read_frame().\n - muxing: groups may be created by the user before avformat_write_header().\n\n Freed by libavformat in avformat_free_context()."]
7424 pub stream_groups: *mut *mut AVStreamGroup,
7425 #[doc = " Number of chapters in AVChapter array.\n When muxing, chapters are normally written in the file header,\n so nb_chapters should normally be initialized before write_header\n is called. Some muxers (e.g. mov and mkv) can also write chapters\n in the trailer. To write chapters in the trailer, nb_chapters\n must be zero when write_header is called and non-zero when\n write_trailer is called.\n - muxing: set by user\n - demuxing: set by libavformat"]
7426 pub nb_chapters: ::std::os::raw::c_uint,
7427 pub chapters: *mut *mut AVChapter,
7428 #[doc = " input or output URL. Unlike the old filename field, this field has no\n length restriction.\n\n - demuxing: set by avformat_open_input(), initialized to an empty\n string if url parameter was NULL in avformat_open_input().\n - muxing: may be set by the caller before calling avformat_write_header()\n (or avformat_init_output() if that is called first) to a string\n which is freeable by av_free(). Set to an empty string if it\n was NULL in avformat_init_output().\n\n Freed by libavformat in avformat_free_context()."]
7429 pub url: *mut ::std::os::raw::c_char,
7430 #[doc = " Position of the first frame of the component, in\n AV_TIME_BASE fractional seconds. NEVER set this value directly:\n It is deduced from the AVStream values.\n\n Demuxing only, set by libavformat."]
7431 pub start_time: i64,
7432 #[doc = " Duration of the stream, in AV_TIME_BASE fractional\n seconds. Only set this value if you know none of the individual stream\n durations and also do not set any of them. This is deduced from the\n AVStream values if not set.\n\n Demuxing only, set by libavformat."]
7433 pub duration: i64,
7434 #[doc = " Total stream bitrate in bit/s, 0 if not\n available. Never set it directly if the file_size and the\n duration are known as FFmpeg can compute it automatically."]
7435 pub bit_rate: i64,
7436 pub packet_size: ::std::os::raw::c_uint,
7437 pub max_delay: ::std::os::raw::c_int,
7438 #[doc = " Flags modifying the (de)muxer behaviour. A combination of AVFMT_FLAG_*.\n Set by the user before avformat_open_input() / avformat_write_header()."]
7439 pub flags: ::std::os::raw::c_int,
7440 #[doc = " Maximum number of bytes read from input in order to determine stream\n properties. Used when reading the global header and in\n avformat_find_stream_info().\n\n Demuxing only, set by the caller before avformat_open_input().\n\n @note this is \\e not used for determining the \\ref AVInputFormat\n \"input format\"\n @see format_probesize"]
7441 pub probesize: i64,
7442 #[doc = " Maximum duration (in AV_TIME_BASE units) of the data read\n from input in avformat_find_stream_info().\n Demuxing only, set by the caller before avformat_find_stream_info().\n Can be set to 0 to let avformat choose using a heuristic."]
7443 pub max_analyze_duration: i64,
7444 pub key: *const u8,
7445 pub keylen: ::std::os::raw::c_int,
7446 pub nb_programs: ::std::os::raw::c_uint,
7447 pub programs: *mut *mut AVProgram,
7448 #[doc = " Forced video codec_id.\n Demuxing: Set by user."]
7449 pub video_codec_id: AVCodecID,
7450 #[doc = " Forced audio codec_id.\n Demuxing: Set by user."]
7451 pub audio_codec_id: AVCodecID,
7452 #[doc = " Forced subtitle codec_id.\n Demuxing: Set by user."]
7453 pub subtitle_codec_id: AVCodecID,
7454 #[doc = " Forced Data codec_id.\n Demuxing: Set by user."]
7455 pub data_codec_id: AVCodecID,
7456 #[doc = " Metadata that applies to the whole file.\n\n - demuxing: set by libavformat in avformat_open_input()\n - muxing: may be set by the caller before avformat_write_header()\n\n Freed by libavformat in avformat_free_context()."]
7457 pub metadata: *mut AVDictionary,
7458 #[doc = " Start time of the stream in real world time, in microseconds\n since the Unix epoch (00:00 1st January 1970). That is, pts=0 in the\n stream was captured at this real world time.\n - muxing: Set by the caller before avformat_write_header(). If set to\n either 0 or AV_NOPTS_VALUE, then the current wall-time will\n be used.\n - demuxing: Set by libavformat. AV_NOPTS_VALUE if unknown. Note that\n the value may become known after some number of frames\n have been received."]
7459 pub start_time_realtime: i64,
7460 #[doc = " The number of frames used for determining the framerate in\n avformat_find_stream_info().\n Demuxing only, set by the caller before avformat_find_stream_info()."]
7461 pub fps_probe_size: ::std::os::raw::c_int,
7462 #[doc = " Error recognition; higher values will detect more errors but may\n misdetect some more or less valid parts as errors.\n Demuxing only, set by the caller before avformat_open_input()."]
7463 pub error_recognition: ::std::os::raw::c_int,
7464 #[doc = " Custom interrupt callbacks for the I/O layer.\n\n demuxing: set by the user before avformat_open_input().\n muxing: set by the user before avformat_write_header()\n (mainly useful for AVFMT_NOFILE formats). The callback\n should also be passed to avio_open2() if it's used to\n open the file."]
7465 pub interrupt_callback: AVIOInterruptCB,
7466 #[doc = " Flags to enable debugging."]
7467 pub debug: ::std::os::raw::c_int,
7468 #[doc = " The maximum number of streams.\n - encoding: unused\n - decoding: set by user"]
7469 pub max_streams: ::std::os::raw::c_int,
7470 #[doc = " Maximum amount of memory in bytes to use for the index of each stream.\n If the index exceeds this size, entries will be discarded as\n needed to maintain a smaller size. This can lead to slower or less\n accurate seeking (depends on demuxer).\n Demuxers for which a full in-memory index is mandatory will ignore\n this.\n - muxing: unused\n - demuxing: set by user"]
7471 pub max_index_size: ::std::os::raw::c_uint,
7472 #[doc = " Maximum amount of memory in bytes to use for buffering frames\n obtained from realtime capture devices."]
7473 pub max_picture_buffer: ::std::os::raw::c_uint,
7474 #[doc = " Maximum buffering duration for interleaving.\n\n To ensure all the streams are interleaved correctly,\n av_interleaved_write_frame() will wait until it has at least one packet\n for each stream before actually writing any packets to the output file.\n When some streams are \"sparse\" (i.e. there are large gaps between\n successive packets), this can result in excessive buffering.\n\n This field specifies the maximum difference between the timestamps of the\n first and the last packet in the muxing queue, above which libavformat\n will output a packet regardless of whether it has queued a packet for all\n the streams.\n\n Muxing only, set by the caller before avformat_write_header()."]
7475 pub max_interleave_delta: i64,
7476 #[doc = " Maximum number of packets to read while waiting for the first timestamp.\n Decoding only."]
7477 pub max_ts_probe: ::std::os::raw::c_int,
7478 #[doc = " Max chunk time in microseconds.\n Note, not all formats support this and unpredictable things may happen if it is used when not supported.\n - encoding: Set by user\n - decoding: unused"]
7479 pub max_chunk_duration: ::std::os::raw::c_int,
7480 #[doc = " Max chunk size in bytes\n Note, not all formats support this and unpredictable things may happen if it is used when not supported.\n - encoding: Set by user\n - decoding: unused"]
7481 pub max_chunk_size: ::std::os::raw::c_int,
7482 #[doc = " Maximum number of packets that can be probed\n - encoding: unused\n - decoding: set by user"]
7483 pub max_probe_packets: ::std::os::raw::c_int,
7484 #[doc = " Allow non-standard and experimental extension\n @see AVCodecContext.strict_std_compliance"]
7485 pub strict_std_compliance: ::std::os::raw::c_int,
7486 #[doc = " Flags indicating events happening on the file, a combination of\n AVFMT_EVENT_FLAG_*.\n\n - demuxing: may be set by the demuxer in avformat_open_input(),\n avformat_find_stream_info() and av_read_frame(). Flags must be cleared\n by the user once the event has been handled.\n - muxing: may be set by the user after avformat_write_header() to\n indicate a user-triggered event. The muxer will clear the flags for\n events it has handled in av_[interleaved]_write_frame()."]
7487 pub event_flags: ::std::os::raw::c_int,
7488 #[doc = " Avoid negative timestamps during muxing.\n Any value of the AVFMT_AVOID_NEG_TS_* constants.\n Note, this works better when using av_interleaved_write_frame().\n - muxing: Set by user\n - demuxing: unused"]
7489 pub avoid_negative_ts: ::std::os::raw::c_int,
7490 #[doc = " Audio preload in microseconds.\n Note, not all formats support this and unpredictable things may happen if it is used when not supported.\n - encoding: Set by user\n - decoding: unused"]
7491 pub audio_preload: ::std::os::raw::c_int,
7492 #[doc = " forces the use of wallclock timestamps as pts/dts of packets\n This has undefined results in the presence of B frames.\n - encoding: unused\n - decoding: Set by user"]
7493 pub use_wallclock_as_timestamps: ::std::os::raw::c_int,
7494 #[doc = " Skip duration calcuation in estimate_timings_from_pts.\n - encoding: unused\n - decoding: set by user\n\n @see duration_probesize"]
7495 pub skip_estimate_duration_from_pts: ::std::os::raw::c_int,
7496 #[doc = " avio flags, used to force AVIO_FLAG_DIRECT.\n - encoding: unused\n - decoding: Set by user"]
7497 pub avio_flags: ::std::os::raw::c_int,
7498 #[doc = " The duration field can be estimated through various ways, and this field can be used\n to know how the duration was estimated.\n - encoding: unused\n - decoding: Read by user"]
7499 pub duration_estimation_method: AVDurationEstimationMethod,
7500 #[doc = " Skip initial bytes when opening stream\n - encoding: unused\n - decoding: Set by user"]
7501 pub skip_initial_bytes: i64,
7502 #[doc = " Correct single timestamp overflows\n - encoding: unused\n - decoding: Set by user"]
7503 pub correct_ts_overflow: ::std::os::raw::c_uint,
7504 #[doc = " Force seeking to any (also non key) frames.\n - encoding: unused\n - decoding: Set by user"]
7505 pub seek2any: ::std::os::raw::c_int,
7506 #[doc = " Flush the I/O context after each packet.\n - encoding: Set by user\n - decoding: unused"]
7507 pub flush_packets: ::std::os::raw::c_int,
7508 #[doc = " format probing score.\n The maximal score is AVPROBE_SCORE_MAX, its set when the demuxer probes\n the format.\n - encoding: unused\n - decoding: set by avformat, read by user"]
7509 pub probe_score: ::std::os::raw::c_int,
7510 #[doc = " Maximum number of bytes read from input in order to identify the\n \\ref AVInputFormat \"input format\". Only used when the format is not set\n explicitly by the caller.\n\n Demuxing only, set by the caller before avformat_open_input().\n\n @see probesize"]
7511 pub format_probesize: ::std::os::raw::c_int,
7512 #[doc = " ',' separated list of allowed decoders.\n If NULL then all are allowed\n - encoding: unused\n - decoding: set by user"]
7513 pub codec_whitelist: *mut ::std::os::raw::c_char,
7514 #[doc = " ',' separated list of allowed demuxers.\n If NULL then all are allowed\n - encoding: unused\n - decoding: set by user"]
7515 pub format_whitelist: *mut ::std::os::raw::c_char,
7516 #[doc = " ',' separated list of allowed protocols.\n - encoding: unused\n - decoding: set by user"]
7517 pub protocol_whitelist: *mut ::std::os::raw::c_char,
7518 #[doc = " ',' separated list of disallowed protocols.\n - encoding: unused\n - decoding: set by user"]
7519 pub protocol_blacklist: *mut ::std::os::raw::c_char,
7520 #[doc = " IO repositioned flag.\n This is set by avformat when the underlaying IO context read pointer\n is repositioned, for example when doing byte based seeking.\n Demuxers can use the flag to detect such changes."]
7521 pub io_repositioned: ::std::os::raw::c_int,
7522 #[doc = " Forced video codec.\n This allows forcing a specific decoder, even when there are multiple with\n the same codec_id.\n Demuxing: Set by user"]
7523 pub video_codec: *const AVCodec,
7524 #[doc = " Forced audio codec.\n This allows forcing a specific decoder, even when there are multiple with\n the same codec_id.\n Demuxing: Set by user"]
7525 pub audio_codec: *const AVCodec,
7526 #[doc = " Forced subtitle codec.\n This allows forcing a specific decoder, even when there are multiple with\n the same codec_id.\n Demuxing: Set by user"]
7527 pub subtitle_codec: *const AVCodec,
7528 #[doc = " Forced data codec.\n This allows forcing a specific decoder, even when there are multiple with\n the same codec_id.\n Demuxing: Set by user"]
7529 pub data_codec: *const AVCodec,
7530 #[doc = " Number of bytes to be written as padding in a metadata header.\n Demuxing: Unused.\n Muxing: Set by user."]
7531 pub metadata_header_padding: ::std::os::raw::c_int,
7532 #[doc = " User data.\n This is a place for some private data of the user."]
7533 pub opaque: *mut ::std::os::raw::c_void,
7534 #[doc = " Callback used by devices to communicate with application."]
7535 pub control_message_cb: av_format_control_message,
7536 #[doc = " Output timestamp offset, in microseconds.\n Muxing: set by user"]
7537 pub output_ts_offset: i64,
7538 #[doc = " dump format separator.\n can be \", \" or \"\\n \" or anything else\n - muxing: Set by user.\n - demuxing: Set by user."]
7539 pub dump_separator: *mut u8,
7540 #[doc = " A callback for opening new IO streams.\n\n Whenever a muxer or a demuxer needs to open an IO stream (typically from\n avformat_open_input() for demuxers, but for certain formats can happen at\n other times as well), it will call this callback to obtain an IO context.\n\n @param s the format context\n @param pb on success, the newly opened IO context should be returned here\n @param url the url to open\n @param flags a combination of AVIO_FLAG_*\n @param options a dictionary of additional options, with the same\n semantics as in avio_open2()\n @return 0 on success, a negative AVERROR code on failure\n\n @note Certain muxers and demuxers do nesting, i.e. they open one or more\n additional internal format contexts. Thus the AVFormatContext pointer\n passed to this callback may be different from the one facing the caller.\n It will, however, have the same 'opaque' field."]
7541 pub io_open: ::std::option::Option<
7542 unsafe extern "C" fn(
7543 s: *mut AVFormatContext,
7544 pb: *mut *mut AVIOContext,
7545 url: *const ::std::os::raw::c_char,
7546 flags: ::std::os::raw::c_int,
7547 options: *mut *mut AVDictionary,
7548 ) -> ::std::os::raw::c_int,
7549 >,
7550 #[doc = " A callback for closing the streams opened with AVFormatContext.io_open().\n\n Using this is preferred over io_close, because this can return an error.\n Therefore this callback is used instead of io_close by the generic\n libavformat code if io_close is NULL or the default.\n\n @param s the format context\n @param pb IO context to be closed and freed\n @return 0 on success, a negative AVERROR code on failure"]
7551 pub io_close2: ::std::option::Option<
7552 unsafe extern "C" fn(
7553 s: *mut AVFormatContext,
7554 pb: *mut AVIOContext,
7555 ) -> ::std::os::raw::c_int,
7556 >,
7557 #[doc = " Maximum number of bytes read from input in order to determine stream durations\n when using estimate_timings_from_pts in avformat_find_stream_info().\n Demuxing only, set by the caller before avformat_find_stream_info().\n Can be set to 0 to let avformat choose using a heuristic.\n\n @see skip_estimate_duration_from_pts"]
7558 pub duration_probesize: i64,
7559}
7560impl Default for AVFormatContext {
7561 fn default() -> Self {
7562 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7563 unsafe {
7564 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7565 s.assume_init()
7566 }
7567 }
7568}
7569extern "C" {
7570 #[doc = " This function will cause global side data to be injected in the next packet\n of each stream as well as after any subsequent seek.\n\n @note global side data is always available in every AVStream's\n @ref AVCodecParameters.coded_side_data \"codecpar side data\" array, and\n in a @ref AVCodecContext.coded_side_data \"decoder's side data\" array if\n initialized with said stream's codecpar.\n @see av_packet_side_data_get()"]
7571 pub fn av_format_inject_global_side_data(s: *mut AVFormatContext);
7572}
7573extern "C" {
7574 #[doc = " Returns the method used to set ctx->duration.\n\n @return AVFMT_DURATION_FROM_PTS, AVFMT_DURATION_FROM_STREAM, or AVFMT_DURATION_FROM_BITRATE.\n @deprecated duration_estimation_method is public and can be read directly."]
7575 pub fn av_fmt_ctx_get_duration_estimation_method(
7576 ctx: *const AVFormatContext,
7577 ) -> AVDurationEstimationMethod;
7578}
7579extern "C" {
7580 #[doc = " Return the LIBAVFORMAT_VERSION_INT constant."]
7581 pub fn avformat_version() -> ::std::os::raw::c_uint;
7582}
7583extern "C" {
7584 #[doc = " Return the libavformat build-time configuration."]
7585 pub fn avformat_configuration() -> *const ::std::os::raw::c_char;
7586}
7587extern "C" {
7588 #[doc = " Return the libavformat license."]
7589 pub fn avformat_license() -> *const ::std::os::raw::c_char;
7590}
7591extern "C" {
7592 #[doc = " Do global initialization of network libraries. This is optional,\n and not recommended anymore.\n\n This functions only exists to work around thread-safety issues\n with older GnuTLS or OpenSSL libraries. If libavformat is linked\n to newer versions of those libraries, or if you do not use them,\n calling this function is unnecessary. Otherwise, you need to call\n this function before any other threads using them are started.\n\n This function will be deprecated once support for older GnuTLS and\n OpenSSL libraries is removed, and this function has no purpose\n anymore."]
7593 pub fn avformat_network_init() -> ::std::os::raw::c_int;
7594}
7595extern "C" {
7596 #[doc = " Undo the initialization done by avformat_network_init. Call it only\n once for each time you called avformat_network_init."]
7597 pub fn avformat_network_deinit() -> ::std::os::raw::c_int;
7598}
7599extern "C" {
7600 #[doc = " Iterate over all registered muxers.\n\n @param opaque a pointer where libavformat will store the iteration state. Must\n point to NULL to start the iteration.\n\n @return the next registered muxer or NULL when the iteration is\n finished"]
7601 pub fn av_muxer_iterate(opaque: *mut *mut ::std::os::raw::c_void) -> *const AVOutputFormat;
7602}
7603extern "C" {
7604 #[doc = " Iterate over all registered demuxers.\n\n @param opaque a pointer where libavformat will store the iteration state.\n Must point to NULL to start the iteration.\n\n @return the next registered demuxer or NULL when the iteration is\n finished"]
7605 pub fn av_demuxer_iterate(opaque: *mut *mut ::std::os::raw::c_void) -> *const AVInputFormat;
7606}
7607extern "C" {
7608 #[doc = " Allocate an AVFormatContext.\n avformat_free_context() can be used to free the context and everything\n allocated by the framework within it."]
7609 pub fn avformat_alloc_context() -> *mut AVFormatContext;
7610}
7611extern "C" {
7612 #[doc = " Free an AVFormatContext and all its streams.\n @param s context to free"]
7613 pub fn avformat_free_context(s: *mut AVFormatContext);
7614}
7615extern "C" {
7616 #[doc = " Get the AVClass for AVFormatContext. It can be used in combination with\n AV_OPT_SEARCH_FAKE_OBJ for examining options.\n\n @see av_opt_find()."]
7617 pub fn avformat_get_class() -> *const AVClass;
7618}
7619extern "C" {
7620 #[doc = " Get the AVClass for AVStream. It can be used in combination with\n AV_OPT_SEARCH_FAKE_OBJ for examining options.\n\n @see av_opt_find()."]
7621 pub fn av_stream_get_class() -> *const AVClass;
7622}
7623extern "C" {
7624 #[doc = " Get the AVClass for AVStreamGroup. It can be used in combination with\n AV_OPT_SEARCH_FAKE_OBJ for examining options.\n\n @see av_opt_find()."]
7625 pub fn av_stream_group_get_class() -> *const AVClass;
7626}
7627extern "C" {
7628 #[doc = " @return a string identifying the stream group type, or NULL if unknown"]
7629 pub fn avformat_stream_group_name(
7630 type_: AVStreamGroupParamsType,
7631 ) -> *const ::std::os::raw::c_char;
7632}
7633extern "C" {
7634 #[doc = " Add a new empty stream group to a media file.\n\n When demuxing, it may be called by the demuxer in read_header(). If the\n flag AVFMTCTX_NOHEADER is set in s.ctx_flags, then it may also\n be called in read_packet().\n\n When muxing, may be called by the user before avformat_write_header().\n\n User is required to call avformat_free_context() to clean up the allocation\n by avformat_stream_group_create().\n\n New streams can be added to the group with avformat_stream_group_add_stream().\n\n @param s media file handle\n\n @return newly created group or NULL on error.\n @see avformat_new_stream, avformat_stream_group_add_stream."]
7635 pub fn avformat_stream_group_create(
7636 s: *mut AVFormatContext,
7637 type_: AVStreamGroupParamsType,
7638 options: *mut *mut AVDictionary,
7639 ) -> *mut AVStreamGroup;
7640}
7641extern "C" {
7642 #[doc = " Add a new stream to a media file.\n\n When demuxing, it is called by the demuxer in read_header(). If the\n flag AVFMTCTX_NOHEADER is set in s.ctx_flags, then it may also\n be called in read_packet().\n\n When muxing, should be called by the user before avformat_write_header().\n\n User is required to call avformat_free_context() to clean up the allocation\n by avformat_new_stream().\n\n @param s media file handle\n @param c unused, does nothing\n\n @return newly created stream or NULL on error."]
7643 pub fn avformat_new_stream(s: *mut AVFormatContext, c: *const AVCodec) -> *mut AVStream;
7644}
7645extern "C" {
7646 #[doc = " Add an already allocated stream to a stream group.\n\n When demuxing, it may be called by the demuxer in read_header(). If the\n flag AVFMTCTX_NOHEADER is set in s.ctx_flags, then it may also\n be called in read_packet().\n\n When muxing, may be called by the user before avformat_write_header() after\n having allocated a new group with avformat_stream_group_create() and stream with\n avformat_new_stream().\n\n User is required to call avformat_free_context() to clean up the allocation\n by avformat_stream_group_add_stream().\n\n @param stg stream group belonging to a media file.\n @param st stream in the media file to add to the group.\n\n @retval 0 success\n @retval AVERROR(EEXIST) the stream was already in the group\n @retval \"another negative error code\" legitimate errors\n\n @see avformat_new_stream, avformat_stream_group_create."]
7647 pub fn avformat_stream_group_add_stream(
7648 stg: *mut AVStreamGroup,
7649 st: *mut AVStream,
7650 ) -> ::std::os::raw::c_int;
7651}
7652extern "C" {
7653 #[doc = " Wrap an existing array as stream side data.\n\n @param st stream\n @param type side information type\n @param data the side data array. It must be allocated with the av_malloc()\n family of functions. The ownership of the data is transferred to\n st.\n @param size side information size\n\n @return zero on success, a negative AVERROR code on failure. On failure,\n the stream is unchanged and the data remains owned by the caller.\n @deprecated use av_packet_side_data_add() with the stream's\n @ref AVCodecParameters.coded_side_data \"codecpar side data\""]
7654 pub fn av_stream_add_side_data(
7655 st: *mut AVStream,
7656 type_: AVPacketSideDataType,
7657 data: *mut u8,
7658 size: usize,
7659 ) -> ::std::os::raw::c_int;
7660}
7661extern "C" {
7662 #[doc = " Allocate new information from stream.\n\n @param stream stream\n @param type desired side information type\n @param size side information size\n\n @return pointer to fresh allocated data or NULL otherwise\n @deprecated use av_packet_side_data_new() with the stream's\n @ref AVCodecParameters.coded_side_data \"codecpar side data\""]
7663 pub fn av_stream_new_side_data(
7664 stream: *mut AVStream,
7665 type_: AVPacketSideDataType,
7666 size: usize,
7667 ) -> *mut u8;
7668}
7669extern "C" {
7670 #[doc = " Get side information from stream.\n\n @param stream stream\n @param type desired side information type\n @param size If supplied, *size will be set to the size of the side data\n or to zero if the desired side data is not present.\n\n @return pointer to data if present or NULL otherwise\n @deprecated use av_packet_side_data_get() with the stream's\n @ref AVCodecParameters.coded_side_data \"codecpar side data\""]
7671 pub fn av_stream_get_side_data(
7672 stream: *const AVStream,
7673 type_: AVPacketSideDataType,
7674 size: *mut usize,
7675 ) -> *mut u8;
7676}
7677extern "C" {
7678 pub fn av_new_program(s: *mut AVFormatContext, id: ::std::os::raw::c_int) -> *mut AVProgram;
7679}
7680extern "C" {
7681 #[doc = " Allocate an AVFormatContext for an output format.\n avformat_free_context() can be used to free the context and\n everything allocated by the framework within it.\n\n @param ctx pointee is set to the created format context,\n or to NULL in case of failure\n @param oformat format to use for allocating the context, if NULL\n format_name and filename are used instead\n @param format_name the name of output format to use for allocating the\n context, if NULL filename is used instead\n @param filename the name of the filename to use for allocating the\n context, may be NULL\n\n @return >= 0 in case of success, a negative AVERROR code in case of\n failure"]
7682 pub fn avformat_alloc_output_context2(
7683 ctx: *mut *mut AVFormatContext,
7684 oformat: *const AVOutputFormat,
7685 format_name: *const ::std::os::raw::c_char,
7686 filename: *const ::std::os::raw::c_char,
7687 ) -> ::std::os::raw::c_int;
7688}
7689extern "C" {
7690 #[doc = " Find AVInputFormat based on the short name of the input format."]
7691 pub fn av_find_input_format(short_name: *const ::std::os::raw::c_char) -> *const AVInputFormat;
7692}
7693extern "C" {
7694 #[doc = " Guess the file format.\n\n @param pd data to be probed\n @param is_opened Whether the file is already opened; determines whether\n demuxers with or without AVFMT_NOFILE are probed."]
7695 pub fn av_probe_input_format(
7696 pd: *const AVProbeData,
7697 is_opened: ::std::os::raw::c_int,
7698 ) -> *const AVInputFormat;
7699}
7700extern "C" {
7701 #[doc = " Guess the file format.\n\n @param pd data to be probed\n @param is_opened Whether the file is already opened; determines whether\n demuxers with or without AVFMT_NOFILE are probed.\n @param score_max A probe score larger that this is required to accept a\n detection, the variable is set to the actual detection\n score afterwards.\n If the score is <= AVPROBE_SCORE_MAX / 4 it is recommended\n to retry with a larger probe buffer."]
7702 pub fn av_probe_input_format2(
7703 pd: *const AVProbeData,
7704 is_opened: ::std::os::raw::c_int,
7705 score_max: *mut ::std::os::raw::c_int,
7706 ) -> *const AVInputFormat;
7707}
7708extern "C" {
7709 #[doc = " Guess the file format.\n\n @param is_opened Whether the file is already opened; determines whether\n demuxers with or without AVFMT_NOFILE are probed.\n @param score_ret The score of the best detection."]
7710 pub fn av_probe_input_format3(
7711 pd: *const AVProbeData,
7712 is_opened: ::std::os::raw::c_int,
7713 score_ret: *mut ::std::os::raw::c_int,
7714 ) -> *const AVInputFormat;
7715}
7716extern "C" {
7717 #[doc = " Probe a bytestream to determine the input format. Each time a probe returns\n with a score that is too low, the probe buffer size is increased and another\n attempt is made. When the maximum probe size is reached, the input format\n with the highest score is returned.\n\n @param pb the bytestream to probe\n @param fmt the input format is put here\n @param url the url of the stream\n @param logctx the log context\n @param offset the offset within the bytestream to probe from\n @param max_probe_size the maximum probe buffer size (zero for default)\n\n @return the score in case of success, a negative value corresponding to an\n the maximal score is AVPROBE_SCORE_MAX\n AVERROR code otherwise"]
7718 pub fn av_probe_input_buffer2(
7719 pb: *mut AVIOContext,
7720 fmt: *mut *const AVInputFormat,
7721 url: *const ::std::os::raw::c_char,
7722 logctx: *mut ::std::os::raw::c_void,
7723 offset: ::std::os::raw::c_uint,
7724 max_probe_size: ::std::os::raw::c_uint,
7725 ) -> ::std::os::raw::c_int;
7726}
7727extern "C" {
7728 #[doc = " Like av_probe_input_buffer2() but returns 0 on success"]
7729 pub fn av_probe_input_buffer(
7730 pb: *mut AVIOContext,
7731 fmt: *mut *const AVInputFormat,
7732 url: *const ::std::os::raw::c_char,
7733 logctx: *mut ::std::os::raw::c_void,
7734 offset: ::std::os::raw::c_uint,
7735 max_probe_size: ::std::os::raw::c_uint,
7736 ) -> ::std::os::raw::c_int;
7737}
7738extern "C" {
7739 #[doc = " Open an input stream and read the header. The codecs are not opened.\n The stream must be closed with avformat_close_input().\n\n @param ps Pointer to user-supplied AVFormatContext (allocated by\n avformat_alloc_context). May be a pointer to NULL, in\n which case an AVFormatContext is allocated by this\n function and written into ps.\n Note that a user-supplied AVFormatContext will be freed\n on failure.\n @param url URL of the stream to open.\n @param fmt If non-NULL, this parameter forces a specific input format.\n Otherwise the format is autodetected.\n @param options A dictionary filled with AVFormatContext and demuxer-private\n options.\n On return this parameter will be destroyed and replaced with\n a dict containing options that were not found. May be NULL.\n\n @return 0 on success, a negative AVERROR on failure.\n\n @note If you want to use custom IO, preallocate the format context and set its pb field."]
7740 pub fn avformat_open_input(
7741 ps: *mut *mut AVFormatContext,
7742 url: *const ::std::os::raw::c_char,
7743 fmt: *const AVInputFormat,
7744 options: *mut *mut AVDictionary,
7745 ) -> ::std::os::raw::c_int;
7746}
7747extern "C" {
7748 #[doc = " Read packets of a media file to get stream information. This\n is useful for file formats with no headers such as MPEG. This\n function also computes the real framerate in case of MPEG-2 repeat\n frame mode.\n The logical file position is not changed by this function;\n examined packets may be buffered for later processing.\n\n @param ic media file handle\n @param options If non-NULL, an ic.nb_streams long array of pointers to\n dictionaries, where i-th member contains options for\n codec corresponding to i-th stream.\n On return each dictionary will be filled with options that were not found.\n @return >=0 if OK, AVERROR_xxx on error\n\n @note this function isn't guaranteed to open all the codecs, so\n options being non-empty at return is a perfectly normal behavior.\n\n @todo Let the user decide somehow what information is needed so that\n we do not waste time getting stuff the user does not need."]
7749 pub fn avformat_find_stream_info(
7750 ic: *mut AVFormatContext,
7751 options: *mut *mut AVDictionary,
7752 ) -> ::std::os::raw::c_int;
7753}
7754extern "C" {
7755 #[doc = " Find the programs which belong to a given stream.\n\n @param ic media file handle\n @param last the last found program, the search will start after this\n program, or from the beginning if it is NULL\n @param s stream index\n\n @return the next program which belongs to s, NULL if no program is found or\n the last program is not among the programs of ic."]
7756 pub fn av_find_program_from_stream(
7757 ic: *mut AVFormatContext,
7758 last: *mut AVProgram,
7759 s: ::std::os::raw::c_int,
7760 ) -> *mut AVProgram;
7761}
7762extern "C" {
7763 pub fn av_program_add_stream_index(
7764 ac: *mut AVFormatContext,
7765 progid: ::std::os::raw::c_int,
7766 idx: ::std::os::raw::c_uint,
7767 );
7768}
7769extern "C" {
7770 #[doc = " Find the \"best\" stream in the file.\n The best stream is determined according to various heuristics as the most\n likely to be what the user expects.\n If the decoder parameter is non-NULL, av_find_best_stream will find the\n default decoder for the stream's codec; streams for which no decoder can\n be found are ignored.\n\n @param ic media file handle\n @param type stream type: video, audio, subtitles, etc.\n @param wanted_stream_nb user-requested stream number,\n or -1 for automatic selection\n @param related_stream try to find a stream related (eg. in the same\n program) to this one, or -1 if none\n @param decoder_ret if non-NULL, returns the decoder for the\n selected stream\n @param flags flags; none are currently defined\n\n @return the non-negative stream number in case of success,\n AVERROR_STREAM_NOT_FOUND if no stream with the requested type\n could be found,\n AVERROR_DECODER_NOT_FOUND if streams were found but no decoder\n\n @note If av_find_best_stream returns successfully and decoder_ret is not\n NULL, then *decoder_ret is guaranteed to be set to a valid AVCodec."]
7771 pub fn av_find_best_stream(
7772 ic: *mut AVFormatContext,
7773 type_: AVMediaType,
7774 wanted_stream_nb: ::std::os::raw::c_int,
7775 related_stream: ::std::os::raw::c_int,
7776 decoder_ret: *mut *const AVCodec,
7777 flags: ::std::os::raw::c_int,
7778 ) -> ::std::os::raw::c_int;
7779}
7780extern "C" {
7781 #[doc = " Return the next frame of a stream.\n This function returns what is stored in the file, and does not validate\n that what is there are valid frames for the decoder. It will split what is\n stored in the file into frames and return one for each call. It will not\n omit invalid data between valid frames so as to give the decoder the maximum\n information possible for decoding.\n\n On success, the returned packet is reference-counted (pkt->buf is set) and\n valid indefinitely. The packet must be freed with av_packet_unref() when\n it is no longer needed. For video, the packet contains exactly one frame.\n For audio, it contains an integer number of frames if each frame has\n a known fixed size (e.g. PCM or ADPCM data). If the audio frames have\n a variable size (e.g. MPEG audio), then it contains one frame.\n\n pkt->pts, pkt->dts and pkt->duration are always set to correct\n values in AVStream.time_base units (and guessed if the format cannot\n provide them). pkt->pts can be AV_NOPTS_VALUE if the video format\n has B-frames, so it is better to rely on pkt->dts if you do not\n decompress the payload.\n\n @return 0 if OK, < 0 on error or end of file. On error, pkt will be blank\n (as if it came from av_packet_alloc()).\n\n @note pkt will be initialized, so it may be uninitialized, but it must not\n contain data that needs to be freed."]
7782 pub fn av_read_frame(s: *mut AVFormatContext, pkt: *mut AVPacket) -> ::std::os::raw::c_int;
7783}
7784extern "C" {
7785 #[doc = " Seek to the keyframe at timestamp.\n 'timestamp' in 'stream_index'.\n\n @param s media file handle\n @param stream_index If stream_index is (-1), a default stream is selected,\n and timestamp is automatically converted from\n AV_TIME_BASE units to the stream specific time_base.\n @param timestamp Timestamp in AVStream.time_base units or, if no stream\n is specified, in AV_TIME_BASE units.\n @param flags flags which select direction and seeking mode\n\n @return >= 0 on success"]
7786 pub fn av_seek_frame(
7787 s: *mut AVFormatContext,
7788 stream_index: ::std::os::raw::c_int,
7789 timestamp: i64,
7790 flags: ::std::os::raw::c_int,
7791 ) -> ::std::os::raw::c_int;
7792}
7793extern "C" {
7794 #[doc = " Seek to timestamp ts.\n Seeking will be done so that the point from which all active streams\n can be presented successfully will be closest to ts and within min/max_ts.\n Active streams are all streams that have AVStream.discard < AVDISCARD_ALL.\n\n If flags contain AVSEEK_FLAG_BYTE, then all timestamps are in bytes and\n are the file position (this may not be supported by all demuxers).\n If flags contain AVSEEK_FLAG_FRAME, then all timestamps are in frames\n in the stream with stream_index (this may not be supported by all demuxers).\n Otherwise all timestamps are in units of the stream selected by stream_index\n or if stream_index is -1, in AV_TIME_BASE units.\n If flags contain AVSEEK_FLAG_ANY, then non-keyframes are treated as\n keyframes (this may not be supported by all demuxers).\n If flags contain AVSEEK_FLAG_BACKWARD, it is ignored.\n\n @param s media file handle\n @param stream_index index of the stream which is used as time base reference\n @param min_ts smallest acceptable timestamp\n @param ts target timestamp\n @param max_ts largest acceptable timestamp\n @param flags flags\n @return >=0 on success, error code otherwise\n\n @note This is part of the new seek API which is still under construction."]
7795 pub fn avformat_seek_file(
7796 s: *mut AVFormatContext,
7797 stream_index: ::std::os::raw::c_int,
7798 min_ts: i64,
7799 ts: i64,
7800 max_ts: i64,
7801 flags: ::std::os::raw::c_int,
7802 ) -> ::std::os::raw::c_int;
7803}
7804extern "C" {
7805 #[doc = " Discard all internally buffered data. This can be useful when dealing with\n discontinuities in the byte stream. Generally works only with formats that\n can resync. This includes headerless formats like MPEG-TS/TS but should also\n work with NUT, Ogg and in a limited way AVI for example.\n\n The set of streams, the detected duration, stream parameters and codecs do\n not change when calling this function. If you want a complete reset, it's\n better to open a new AVFormatContext.\n\n This does not flush the AVIOContext (s->pb). If necessary, call\n avio_flush(s->pb) before calling this function.\n\n @param s media file handle\n @return >=0 on success, error code otherwise"]
7806 pub fn avformat_flush(s: *mut AVFormatContext) -> ::std::os::raw::c_int;
7807}
7808extern "C" {
7809 #[doc = " Start playing a network-based stream (e.g. RTSP stream) at the\n current position."]
7810 pub fn av_read_play(s: *mut AVFormatContext) -> ::std::os::raw::c_int;
7811}
7812extern "C" {
7813 #[doc = " Pause a network-based stream (e.g. RTSP stream).\n\n Use av_read_play() to resume it."]
7814 pub fn av_read_pause(s: *mut AVFormatContext) -> ::std::os::raw::c_int;
7815}
7816extern "C" {
7817 #[doc = " Close an opened input AVFormatContext. Free it and all its contents\n and set *s to NULL."]
7818 pub fn avformat_close_input(s: *mut *mut AVFormatContext);
7819}
7820extern "C" {
7821 #[must_use]
7822 #[doc = " Allocate the stream private data and write the stream header to\n an output media file.\n\n @param s Media file handle, must be allocated with\n avformat_alloc_context().\n Its \\ref AVFormatContext.oformat \"oformat\" field must be set\n to the desired output format;\n Its \\ref AVFormatContext.pb \"pb\" field must be set to an\n already opened ::AVIOContext.\n @param options An ::AVDictionary filled with AVFormatContext and\n muxer-private options.\n On return this parameter will be destroyed and replaced with\n a dict containing options that were not found. May be NULL.\n\n @retval AVSTREAM_INIT_IN_WRITE_HEADER On success, if the codec had not already been\n fully initialized in avformat_init_output().\n @retval AVSTREAM_INIT_IN_INIT_OUTPUT On success, if the codec had already been fully\n initialized in avformat_init_output().\n @retval AVERROR A negative AVERROR on failure.\n\n @see av_opt_find, av_dict_set, avio_open, av_oformat_next, avformat_init_output."]
7823 pub fn avformat_write_header(
7824 s: *mut AVFormatContext,
7825 options: *mut *mut AVDictionary,
7826 ) -> ::std::os::raw::c_int;
7827}
7828extern "C" {
7829 #[must_use]
7830 #[doc = " Allocate the stream private data and initialize the codec, but do not write the header.\n May optionally be used before avformat_write_header() to initialize stream parameters\n before actually writing the header.\n If using this function, do not pass the same options to avformat_write_header().\n\n @param s Media file handle, must be allocated with\n avformat_alloc_context().\n Its \\ref AVFormatContext.oformat \"oformat\" field must be set\n to the desired output format;\n Its \\ref AVFormatContext.pb \"pb\" field must be set to an\n already opened ::AVIOContext.\n @param options An ::AVDictionary filled with AVFormatContext and\n muxer-private options.\n On return this parameter will be destroyed and replaced with\n a dict containing options that were not found. May be NULL.\n\n @retval AVSTREAM_INIT_IN_WRITE_HEADER On success, if the codec requires\n avformat_write_header to fully initialize.\n @retval AVSTREAM_INIT_IN_INIT_OUTPUT On success, if the codec has been fully\n initialized.\n @retval AVERROR Anegative AVERROR on failure.\n\n @see av_opt_find, av_dict_set, avio_open, av_oformat_next, avformat_write_header."]
7831 pub fn avformat_init_output(
7832 s: *mut AVFormatContext,
7833 options: *mut *mut AVDictionary,
7834 ) -> ::std::os::raw::c_int;
7835}
7836extern "C" {
7837 #[doc = " Write a packet to an output media file.\n\n This function passes the packet directly to the muxer, without any buffering\n or reordering. The caller is responsible for correctly interleaving the\n packets if the format requires it. Callers that want libavformat to handle\n the interleaving should call av_interleaved_write_frame() instead of this\n function.\n\n @param s media file handle\n @param pkt The packet containing the data to be written. Note that unlike\n av_interleaved_write_frame(), this function does not take\n ownership of the packet passed to it (though some muxers may make\n an internal reference to the input packet).\n <br>\n This parameter can be NULL (at any time, not just at the end), in\n order to immediately flush data buffered within the muxer, for\n muxers that buffer up data internally before writing it to the\n output.\n <br>\n Packet's @ref AVPacket.stream_index \"stream_index\" field must be\n set to the index of the corresponding stream in @ref\n AVFormatContext.streams \"s->streams\".\n <br>\n The timestamps (@ref AVPacket.pts \"pts\", @ref AVPacket.dts \"dts\")\n must be set to correct values in the stream's timebase (unless the\n output format is flagged with the AVFMT_NOTIMESTAMPS flag, then\n they can be set to AV_NOPTS_VALUE).\n The dts for subsequent packets passed to this function must be strictly\n increasing when compared in their respective timebases (unless the\n output format is flagged with the AVFMT_TS_NONSTRICT, then they\n merely have to be nondecreasing). @ref AVPacket.duration\n \"duration\") should also be set if known.\n @return < 0 on error, = 0 if OK, 1 if flushed and there is no more data to flush\n\n @see av_interleaved_write_frame()"]
7838 pub fn av_write_frame(s: *mut AVFormatContext, pkt: *mut AVPacket) -> ::std::os::raw::c_int;
7839}
7840extern "C" {
7841 #[doc = " Write a packet to an output media file ensuring correct interleaving.\n\n This function will buffer the packets internally as needed to make sure the\n packets in the output file are properly interleaved, usually ordered by\n increasing dts. Callers doing their own interleaving should call\n av_write_frame() instead of this function.\n\n Using this function instead of av_write_frame() can give muxers advance\n knowledge of future packets, improving e.g. the behaviour of the mp4\n muxer for VFR content in fragmenting mode.\n\n @param s media file handle\n @param pkt The packet containing the data to be written.\n <br>\n If the packet is reference-counted, this function will take\n ownership of this reference and unreference it later when it sees\n fit. If the packet is not reference-counted, libavformat will\n make a copy.\n The returned packet will be blank (as if returned from\n av_packet_alloc()), even on error.\n <br>\n This parameter can be NULL (at any time, not just at the end), to\n flush the interleaving queues.\n <br>\n Packet's @ref AVPacket.stream_index \"stream_index\" field must be\n set to the index of the corresponding stream in @ref\n AVFormatContext.streams \"s->streams\".\n <br>\n The timestamps (@ref AVPacket.pts \"pts\", @ref AVPacket.dts \"dts\")\n must be set to correct values in the stream's timebase (unless the\n output format is flagged with the AVFMT_NOTIMESTAMPS flag, then\n they can be set to AV_NOPTS_VALUE).\n The dts for subsequent packets in one stream must be strictly\n increasing (unless the output format is flagged with the\n AVFMT_TS_NONSTRICT, then they merely have to be nondecreasing).\n @ref AVPacket.duration \"duration\" should also be set if known.\n\n @return 0 on success, a negative AVERROR on error.\n\n @see av_write_frame(), AVFormatContext.max_interleave_delta"]
7842 pub fn av_interleaved_write_frame(
7843 s: *mut AVFormatContext,
7844 pkt: *mut AVPacket,
7845 ) -> ::std::os::raw::c_int;
7846}
7847extern "C" {
7848 #[doc = " Write an uncoded frame to an output media file.\n\n The frame must be correctly interleaved according to the container\n specification; if not, av_interleaved_write_uncoded_frame() must be used.\n\n See av_interleaved_write_uncoded_frame() for details."]
7849 pub fn av_write_uncoded_frame(
7850 s: *mut AVFormatContext,
7851 stream_index: ::std::os::raw::c_int,
7852 frame: *mut AVFrame,
7853 ) -> ::std::os::raw::c_int;
7854}
7855extern "C" {
7856 #[doc = " Write an uncoded frame to an output media file.\n\n If the muxer supports it, this function makes it possible to write an AVFrame\n structure directly, without encoding it into a packet.\n It is mostly useful for devices and similar special muxers that use raw\n video or PCM data and will not serialize it into a byte stream.\n\n To test whether it is possible to use it with a given muxer and stream,\n use av_write_uncoded_frame_query().\n\n The caller gives up ownership of the frame and must not access it\n afterwards.\n\n @return >=0 for success, a negative code on error"]
7857 pub fn av_interleaved_write_uncoded_frame(
7858 s: *mut AVFormatContext,
7859 stream_index: ::std::os::raw::c_int,
7860 frame: *mut AVFrame,
7861 ) -> ::std::os::raw::c_int;
7862}
7863extern "C" {
7864 #[doc = " Test whether a muxer supports uncoded frame.\n\n @return >=0 if an uncoded frame can be written to that muxer and stream,\n <0 if not"]
7865 pub fn av_write_uncoded_frame_query(
7866 s: *mut AVFormatContext,
7867 stream_index: ::std::os::raw::c_int,
7868 ) -> ::std::os::raw::c_int;
7869}
7870extern "C" {
7871 #[doc = " Write the stream trailer to an output media file and free the\n file private data.\n\n May only be called after a successful call to avformat_write_header.\n\n @param s media file handle\n @return 0 if OK, AVERROR_xxx on error"]
7872 pub fn av_write_trailer(s: *mut AVFormatContext) -> ::std::os::raw::c_int;
7873}
7874extern "C" {
7875 #[doc = " Return the output format in the list of registered output formats\n which best matches the provided parameters, or return NULL if\n there is no match.\n\n @param short_name if non-NULL checks if short_name matches with the\n names of the registered formats\n @param filename if non-NULL checks if filename terminates with the\n extensions of the registered formats\n @param mime_type if non-NULL checks if mime_type matches with the\n MIME type of the registered formats"]
7876 pub fn av_guess_format(
7877 short_name: *const ::std::os::raw::c_char,
7878 filename: *const ::std::os::raw::c_char,
7879 mime_type: *const ::std::os::raw::c_char,
7880 ) -> *const AVOutputFormat;
7881}
7882extern "C" {
7883 #[doc = " Guess the codec ID based upon muxer and filename."]
7884 pub fn av_guess_codec(
7885 fmt: *const AVOutputFormat,
7886 short_name: *const ::std::os::raw::c_char,
7887 filename: *const ::std::os::raw::c_char,
7888 mime_type: *const ::std::os::raw::c_char,
7889 type_: AVMediaType,
7890 ) -> AVCodecID;
7891}
7892extern "C" {
7893 #[doc = " Get timing information for the data currently output.\n The exact meaning of \"currently output\" depends on the format.\n It is mostly relevant for devices that have an internal buffer and/or\n work in real time.\n @param s media file handle\n @param stream stream in the media file\n @param[out] dts DTS of the last packet output for the stream, in stream\n time_base units\n @param[out] wall absolute time when that packet whas output,\n in microsecond\n @retval 0 Success\n @retval AVERROR(ENOSYS) The format does not support it\n\n @note Some formats or devices may not allow to measure dts and wall\n atomically."]
7894 pub fn av_get_output_timestamp(
7895 s: *mut AVFormatContext,
7896 stream: ::std::os::raw::c_int,
7897 dts: *mut i64,
7898 wall: *mut i64,
7899 ) -> ::std::os::raw::c_int;
7900}
7901extern "C" {
7902 #[doc = " Send a nice hexadecimal dump of a buffer to the specified file stream.\n\n @param f The file stream pointer where the dump should be sent to.\n @param buf buffer\n @param size buffer size\n\n @see av_hex_dump_log, av_pkt_dump2, av_pkt_dump_log2"]
7903 pub fn av_hex_dump(f: *mut FILE, buf: *const u8, size: ::std::os::raw::c_int);
7904}
7905extern "C" {
7906 #[doc = " Send a nice hexadecimal dump of a buffer to the log.\n\n @param avcl A pointer to an arbitrary struct of which the first field is a\n pointer to an AVClass struct.\n @param level The importance level of the message, lower values signifying\n higher importance.\n @param buf buffer\n @param size buffer size\n\n @see av_hex_dump, av_pkt_dump2, av_pkt_dump_log2"]
7907 pub fn av_hex_dump_log(
7908 avcl: *mut ::std::os::raw::c_void,
7909 level: ::std::os::raw::c_int,
7910 buf: *const u8,
7911 size: ::std::os::raw::c_int,
7912 );
7913}
7914extern "C" {
7915 #[doc = " Send a nice dump of a packet to the specified file stream.\n\n @param f The file stream pointer where the dump should be sent to.\n @param pkt packet to dump\n @param dump_payload True if the payload must be displayed, too.\n @param st AVStream that the packet belongs to"]
7916 pub fn av_pkt_dump2(
7917 f: *mut FILE,
7918 pkt: *const AVPacket,
7919 dump_payload: ::std::os::raw::c_int,
7920 st: *const AVStream,
7921 );
7922}
7923extern "C" {
7924 #[doc = " Send a nice dump of a packet to the log.\n\n @param avcl A pointer to an arbitrary struct of which the first field is a\n pointer to an AVClass struct.\n @param level The importance level of the message, lower values signifying\n higher importance.\n @param pkt packet to dump\n @param dump_payload True if the payload must be displayed, too.\n @param st AVStream that the packet belongs to"]
7925 pub fn av_pkt_dump_log2(
7926 avcl: *mut ::std::os::raw::c_void,
7927 level: ::std::os::raw::c_int,
7928 pkt: *const AVPacket,
7929 dump_payload: ::std::os::raw::c_int,
7930 st: *const AVStream,
7931 );
7932}
7933extern "C" {
7934 #[doc = " Get the AVCodecID for the given codec tag tag.\n If no codec id is found returns AV_CODEC_ID_NONE.\n\n @param tags list of supported codec_id-codec_tag pairs, as stored\n in AVInputFormat.codec_tag and AVOutputFormat.codec_tag\n @param tag codec tag to match to a codec ID"]
7935 pub fn av_codec_get_id(
7936 tags: *const *const AVCodecTag,
7937 tag: ::std::os::raw::c_uint,
7938 ) -> AVCodecID;
7939}
7940extern "C" {
7941 #[doc = " Get the codec tag for the given codec id id.\n If no codec tag is found returns 0.\n\n @param tags list of supported codec_id-codec_tag pairs, as stored\n in AVInputFormat.codec_tag and AVOutputFormat.codec_tag\n @param id codec ID to match to a codec tag"]
7942 pub fn av_codec_get_tag(
7943 tags: *const *const AVCodecTag,
7944 id: AVCodecID,
7945 ) -> ::std::os::raw::c_uint;
7946}
7947extern "C" {
7948 #[doc = " Get the codec tag for the given codec id.\n\n @param tags list of supported codec_id - codec_tag pairs, as stored\n in AVInputFormat.codec_tag and AVOutputFormat.codec_tag\n @param id codec id that should be searched for in the list\n @param tag A pointer to the found tag\n @return 0 if id was not found in tags, > 0 if it was found"]
7949 pub fn av_codec_get_tag2(
7950 tags: *const *const AVCodecTag,
7951 id: AVCodecID,
7952 tag: *mut ::std::os::raw::c_uint,
7953 ) -> ::std::os::raw::c_int;
7954}
7955extern "C" {
7956 pub fn av_find_default_stream_index(s: *mut AVFormatContext) -> ::std::os::raw::c_int;
7957}
7958extern "C" {
7959 #[doc = " Get the index for a specific timestamp.\n\n @param st stream that the timestamp belongs to\n @param timestamp timestamp to retrieve the index for\n @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond\n to the timestamp which is <= the requested one, if backward\n is 0, then it will be >=\n if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise\n @return < 0 if no such timestamp could be found"]
7960 pub fn av_index_search_timestamp(
7961 st: *mut AVStream,
7962 timestamp: i64,
7963 flags: ::std::os::raw::c_int,
7964 ) -> ::std::os::raw::c_int;
7965}
7966extern "C" {
7967 #[doc = " Get the index entry count for the given AVStream.\n\n @param st stream\n @return the number of index entries in the stream"]
7968 pub fn avformat_index_get_entries_count(st: *const AVStream) -> ::std::os::raw::c_int;
7969}
7970extern "C" {
7971 #[doc = " Get the AVIndexEntry corresponding to the given index.\n\n @param st Stream containing the requested AVIndexEntry.\n @param idx The desired index.\n @return A pointer to the requested AVIndexEntry if it exists, NULL otherwise.\n\n @note The pointer returned by this function is only guaranteed to be valid\n until any function that takes the stream or the parent AVFormatContext\n as input argument is called."]
7972 pub fn avformat_index_get_entry(
7973 st: *mut AVStream,
7974 idx: ::std::os::raw::c_int,
7975 ) -> *const AVIndexEntry;
7976}
7977extern "C" {
7978 #[doc = " Get the AVIndexEntry corresponding to the given timestamp.\n\n @param st Stream containing the requested AVIndexEntry.\n @param wanted_timestamp Timestamp to retrieve the index entry for.\n @param flags If AVSEEK_FLAG_BACKWARD then the returned entry will correspond\n to the timestamp which is <= the requested one, if backward\n is 0, then it will be >=\n if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise.\n @return A pointer to the requested AVIndexEntry if it exists, NULL otherwise.\n\n @note The pointer returned by this function is only guaranteed to be valid\n until any function that takes the stream or the parent AVFormatContext\n as input argument is called."]
7979 pub fn avformat_index_get_entry_from_timestamp(
7980 st: *mut AVStream,
7981 wanted_timestamp: i64,
7982 flags: ::std::os::raw::c_int,
7983 ) -> *const AVIndexEntry;
7984}
7985extern "C" {
7986 #[doc = " Add an index entry into a sorted list. Update the entry if the list\n already contains it.\n\n @param timestamp timestamp in the time base of the given stream"]
7987 pub fn av_add_index_entry(
7988 st: *mut AVStream,
7989 pos: i64,
7990 timestamp: i64,
7991 size: ::std::os::raw::c_int,
7992 distance: ::std::os::raw::c_int,
7993 flags: ::std::os::raw::c_int,
7994 ) -> ::std::os::raw::c_int;
7995}
7996extern "C" {
7997 #[doc = " Split a URL string into components.\n\n The pointers to buffers for storing individual components may be null,\n in order to ignore that component. Buffers for components not found are\n set to empty strings. If the port is not found, it is set to a negative\n value.\n\n @param proto the buffer for the protocol\n @param proto_size the size of the proto buffer\n @param authorization the buffer for the authorization\n @param authorization_size the size of the authorization buffer\n @param hostname the buffer for the host name\n @param hostname_size the size of the hostname buffer\n @param port_ptr a pointer to store the port number in\n @param path the buffer for the path\n @param path_size the size of the path buffer\n @param url the URL to split"]
7998 pub fn av_url_split(
7999 proto: *mut ::std::os::raw::c_char,
8000 proto_size: ::std::os::raw::c_int,
8001 authorization: *mut ::std::os::raw::c_char,
8002 authorization_size: ::std::os::raw::c_int,
8003 hostname: *mut ::std::os::raw::c_char,
8004 hostname_size: ::std::os::raw::c_int,
8005 port_ptr: *mut ::std::os::raw::c_int,
8006 path: *mut ::std::os::raw::c_char,
8007 path_size: ::std::os::raw::c_int,
8008 url: *const ::std::os::raw::c_char,
8009 );
8010}
8011extern "C" {
8012 #[doc = " Print detailed information about the input or output format, such as\n duration, bitrate, streams, container, programs, metadata, side data,\n codec and time base.\n\n @param ic the context to analyze\n @param index index of the stream to dump information about\n @param url the URL to print, such as source or destination file\n @param is_output Select whether the specified context is an input(0) or output(1)"]
8013 pub fn av_dump_format(
8014 ic: *mut AVFormatContext,
8015 index: ::std::os::raw::c_int,
8016 url: *const ::std::os::raw::c_char,
8017 is_output: ::std::os::raw::c_int,
8018 );
8019}
8020extern "C" {
8021 #[doc = " Return in 'buf' the path with '%d' replaced by a number.\n\n Also handles the '%0nd' format where 'n' is the total number\n of digits and '%%'.\n\n @param buf destination buffer\n @param buf_size destination buffer size\n @param path numbered sequence string\n @param number frame number\n @param flags AV_FRAME_FILENAME_FLAGS_*\n @return 0 if OK, -1 on format error"]
8022 pub fn av_get_frame_filename2(
8023 buf: *mut ::std::os::raw::c_char,
8024 buf_size: ::std::os::raw::c_int,
8025 path: *const ::std::os::raw::c_char,
8026 number: ::std::os::raw::c_int,
8027 flags: ::std::os::raw::c_int,
8028 ) -> ::std::os::raw::c_int;
8029}
8030extern "C" {
8031 pub fn av_get_frame_filename(
8032 buf: *mut ::std::os::raw::c_char,
8033 buf_size: ::std::os::raw::c_int,
8034 path: *const ::std::os::raw::c_char,
8035 number: ::std::os::raw::c_int,
8036 ) -> ::std::os::raw::c_int;
8037}
8038extern "C" {
8039 #[doc = " Check whether filename actually is a numbered sequence generator.\n\n @param filename possible numbered sequence string\n @return 1 if a valid numbered sequence string, 0 otherwise"]
8040 pub fn av_filename_number_test(
8041 filename: *const ::std::os::raw::c_char,
8042 ) -> ::std::os::raw::c_int;
8043}
8044extern "C" {
8045 #[doc = " Generate an SDP for an RTP session.\n\n Note, this overwrites the id values of AVStreams in the muxer contexts\n for getting unique dynamic payload types.\n\n @param ac array of AVFormatContexts describing the RTP streams. If the\n array is composed by only one context, such context can contain\n multiple AVStreams (one AVStream per RTP stream). Otherwise,\n all the contexts in the array (an AVCodecContext per RTP stream)\n must contain only one AVStream.\n @param n_files number of AVCodecContexts contained in ac\n @param buf buffer where the SDP will be stored (must be allocated by\n the caller)\n @param size the size of the buffer\n @return 0 if OK, AVERROR_xxx on error"]
8046 pub fn av_sdp_create(
8047 ac: *mut *mut AVFormatContext,
8048 n_files: ::std::os::raw::c_int,
8049 buf: *mut ::std::os::raw::c_char,
8050 size: ::std::os::raw::c_int,
8051 ) -> ::std::os::raw::c_int;
8052}
8053extern "C" {
8054 #[doc = " Return a positive value if the given filename has one of the given\n extensions, 0 otherwise.\n\n @param filename file name to check against the given extensions\n @param extensions a comma-separated list of filename extensions"]
8055 pub fn av_match_ext(
8056 filename: *const ::std::os::raw::c_char,
8057 extensions: *const ::std::os::raw::c_char,
8058 ) -> ::std::os::raw::c_int;
8059}
8060extern "C" {
8061 #[doc = " Test if the given container can store a codec.\n\n @param ofmt container to check for compatibility\n @param codec_id codec to potentially store in container\n @param std_compliance standards compliance level, one of FF_COMPLIANCE_*\n\n @return 1 if codec with ID codec_id can be stored in ofmt, 0 if it cannot.\n A negative number if this information is not available."]
8062 pub fn avformat_query_codec(
8063 ofmt: *const AVOutputFormat,
8064 codec_id: AVCodecID,
8065 std_compliance: ::std::os::raw::c_int,
8066 ) -> ::std::os::raw::c_int;
8067}
8068extern "C" {
8069 #[doc = " @defgroup riff_fourcc RIFF FourCCs\n @{\n Get the tables mapping RIFF FourCCs to libavcodec AVCodecIDs. The tables are\n meant to be passed to av_codec_get_id()/av_codec_get_tag() as in the\n following code:\n @code\n uint32_t tag = MKTAG('H', '2', '6', '4');\n const struct AVCodecTag *table[] = { avformat_get_riff_video_tags(), 0 };\n enum AVCodecID id = av_codec_get_id(table, tag);\n @endcode\n/\n/**\n @return the table mapping RIFF FourCCs for video to libavcodec AVCodecID."]
8070 pub fn avformat_get_riff_video_tags() -> *const AVCodecTag;
8071}
8072extern "C" {
8073 #[doc = " @return the table mapping RIFF FourCCs for audio to AVCodecID."]
8074 pub fn avformat_get_riff_audio_tags() -> *const AVCodecTag;
8075}
8076extern "C" {
8077 #[doc = " @return the table mapping MOV FourCCs for video to libavcodec AVCodecID."]
8078 pub fn avformat_get_mov_video_tags() -> *const AVCodecTag;
8079}
8080extern "C" {
8081 #[doc = " @return the table mapping MOV FourCCs for audio to AVCodecID."]
8082 pub fn avformat_get_mov_audio_tags() -> *const AVCodecTag;
8083}
8084extern "C" {
8085 #[doc = " Guess the sample aspect ratio of a frame, based on both the stream and the\n frame aspect ratio.\n\n Since the frame aspect ratio is set by the codec but the stream aspect ratio\n is set by the demuxer, these two may not be equal. This function tries to\n return the value that you should use if you would like to display the frame.\n\n Basic logic is to use the stream aspect ratio if it is set to something sane\n otherwise use the frame aspect ratio. This way a container setting, which is\n usually easy to modify can override the coded value in the frames.\n\n @param format the format context which the stream is part of\n @param stream the stream which the frame is part of\n @param frame the frame with the aspect ratio to be determined\n @return the guessed (valid) sample_aspect_ratio, 0/1 if no idea"]
8086 pub fn av_guess_sample_aspect_ratio(
8087 format: *mut AVFormatContext,
8088 stream: *mut AVStream,
8089 frame: *mut AVFrame,
8090 ) -> AVRational;
8091}
8092extern "C" {
8093 #[doc = " Guess the frame rate, based on both the container and codec information.\n\n @param ctx the format context which the stream is part of\n @param stream the stream which the frame is part of\n @param frame the frame for which the frame rate should be determined, may be NULL\n @return the guessed (valid) frame rate, 0/1 if no idea"]
8094 pub fn av_guess_frame_rate(
8095 ctx: *mut AVFormatContext,
8096 stream: *mut AVStream,
8097 frame: *mut AVFrame,
8098 ) -> AVRational;
8099}
8100extern "C" {
8101 #[doc = " Check if the stream st contained in s is matched by the stream specifier\n spec.\n\n See the \"stream specifiers\" chapter in the documentation for the syntax\n of spec.\n\n @return >0 if st is matched by spec;\n 0 if st is not matched by spec;\n AVERROR code if spec is invalid\n\n @note A stream specifier can match several streams in the format."]
8102 pub fn avformat_match_stream_specifier(
8103 s: *mut AVFormatContext,
8104 st: *mut AVStream,
8105 spec: *const ::std::os::raw::c_char,
8106 ) -> ::std::os::raw::c_int;
8107}
8108extern "C" {
8109 pub fn avformat_queue_attached_pictures(s: *mut AVFormatContext) -> ::std::os::raw::c_int;
8110}
8111pub const AVTimebaseSource_AVFMT_TBCF_AUTO: AVTimebaseSource = -1;
8112pub const AVTimebaseSource_AVFMT_TBCF_DECODER: AVTimebaseSource = 0;
8113pub const AVTimebaseSource_AVFMT_TBCF_DEMUXER: AVTimebaseSource = 1;
8114pub const AVTimebaseSource_AVFMT_TBCF_R_FRAMERATE: AVTimebaseSource = 2;
8115pub type AVTimebaseSource = ::std::os::raw::c_int;
8116extern "C" {
8117 #[doc = " Transfer internal timing information from one stream to another.\n\n This function is useful when doing stream copy.\n\n @param ofmt target output format for ost\n @param ost output stream which needs timings copy and adjustments\n @param ist reference input stream to copy timings from\n @param copy_tb define from where the stream codec timebase needs to be imported"]
8118 pub fn avformat_transfer_internal_stream_timing_info(
8119 ofmt: *const AVOutputFormat,
8120 ost: *mut AVStream,
8121 ist: *const AVStream,
8122 copy_tb: AVTimebaseSource,
8123 ) -> ::std::os::raw::c_int;
8124}
8125extern "C" {
8126 #[doc = " Get the internal codec timebase from a stream.\n\n @param st input stream to extract the timebase from"]
8127 pub fn av_stream_get_codec_timebase(st: *const AVStream) -> AVRational;
8128}
8129pub type __builtin_va_list = *mut ::std::os::raw::c_void;
8130#[doc = " a pointer to the first option specified in the class if any or NULL\n\n @see av_set_default_options()"]
8131#[repr(C)]
8132#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
8133pub struct AVOption {
8134 pub _address: u8,
8135}