1pub const FF_LAMBDA_SHIFT: u32 = 7;
4pub const FF_LAMBDA_SCALE: u32 = 128;
5pub const FF_QP2LAMBDA: u32 = 118;
6pub const FF_LAMBDA_MAX: u32 = 32767;
7pub const FF_QUALITY_SCALE: u32 = 128;
8pub const AV_TIME_BASE: u32 = 1000000;
9pub const _BSD_SOURCE: u32 = 1;
10pub const _XOPEN_SOURCE: u32 = 700;
11pub const __LITTLE_ENDIAN: u32 = 1234;
12pub const __BIG_ENDIAN: u32 = 4321;
13pub const __USE_TIME_BITS64: u32 = 1;
14pub const INT8_MIN: i32 = -128;
15pub const INT16_MIN: i32 = -32768;
16pub const INT32_MIN: i32 = -2147483648;
17pub const INT64_MIN: i64 = -9223372036854775808;
18pub const INT8_MAX: u32 = 127;
19pub const INT16_MAX: u32 = 32767;
20pub const INT32_MAX: u32 = 2147483647;
21pub const INT64_MAX: u64 = 9223372036854775807;
22pub const UINT8_MAX: u32 = 255;
23pub const UINT16_MAX: u32 = 65535;
24pub const UINT32_MAX: u32 = 4294967295;
25pub const UINT64_MAX: i32 = -1;
26pub const INT_FAST8_MIN: i32 = -128;
27pub const INT_FAST64_MIN: i64 = -9223372036854775808;
28pub const INT_LEAST8_MIN: i32 = -128;
29pub const INT_LEAST16_MIN: i32 = -32768;
30pub const INT_LEAST32_MIN: i32 = -2147483648;
31pub const INT_LEAST64_MIN: i64 = -9223372036854775808;
32pub const INT_FAST8_MAX: u32 = 127;
33pub const INT_FAST64_MAX: u64 = 9223372036854775807;
34pub const INT_LEAST8_MAX: u32 = 127;
35pub const INT_LEAST16_MAX: u32 = 32767;
36pub const INT_LEAST32_MAX: u32 = 2147483647;
37pub const INT_LEAST64_MAX: u64 = 9223372036854775807;
38pub const UINT_FAST8_MAX: u32 = 255;
39pub const UINT_FAST64_MAX: i32 = -1;
40pub const UINT_LEAST8_MAX: u32 = 255;
41pub const UINT_LEAST16_MAX: u32 = 65535;
42pub const UINT_LEAST32_MAX: u32 = 4294967295;
43pub const UINT_LEAST64_MAX: i32 = -1;
44pub const INTMAX_MIN: i64 = -9223372036854775808;
45pub const INTMAX_MAX: u64 = 9223372036854775807;
46pub const UINTMAX_MAX: i32 = -1;
47pub const WINT_MIN: u32 = 0;
48pub const WINT_MAX: u32 = 4294967295;
49pub const SIG_ATOMIC_MIN: i32 = -2147483648;
50pub const SIG_ATOMIC_MAX: u32 = 2147483647;
51pub const INT_FAST16_MIN: i32 = -32768;
52pub const INT_FAST32_MIN: i32 = -2147483648;
53pub const INT_FAST16_MAX: u32 = 32767;
54pub const INT_FAST32_MAX: u32 = 2147483647;
55pub const UINT_FAST16_MAX: u32 = 65535;
56pub const UINT_FAST32_MAX: u32 = 4294967295;
57pub const INTPTR_MIN: i32 = -2147483648;
58pub const INTPTR_MAX: u32 = 2147483647;
59pub const UINTPTR_MAX: u32 = 4294967295;
60pub const PTRDIFF_MIN: i32 = -2147483648;
61pub const PTRDIFF_MAX: u32 = 2147483647;
62pub const SIZE_MAX: u32 = 4294967295;
63pub const CHAR_MIN: i32 = -128;
64pub const CHAR_MAX: u32 = 127;
65pub const CHAR_BIT: u32 = 8;
66pub const SCHAR_MIN: i32 = -128;
67pub const SCHAR_MAX: u32 = 127;
68pub const UCHAR_MAX: u32 = 255;
69pub const SHRT_MIN: i32 = -32768;
70pub const SHRT_MAX: u32 = 32767;
71pub const USHRT_MAX: u32 = 65535;
72pub const INT_MIN: i32 = -2147483648;
73pub const INT_MAX: u32 = 2147483647;
74pub const UINT_MAX: u32 = 4294967295;
75pub const LLONG_MAX: u64 = 9223372036854775807;
76pub const ULLONG_MAX: i32 = -1;
77pub const MB_LEN_MAX: u32 = 4;
78pub const PAGESIZE: u32 = 65536;
79pub const FILESIZEBITS: u32 = 64;
80pub const NAME_MAX: u32 = 255;
81pub const PATH_MAX: u32 = 4096;
82pub const NGROUPS_MAX: u32 = 32;
83pub const ARG_MAX: u32 = 131072;
84pub const IOV_MAX: u32 = 1024;
85pub const SYMLOOP_MAX: u32 = 40;
86pub const WORD_BIT: u32 = 32;
87pub const TZNAME_MAX: u32 = 6;
88pub const TTY_NAME_MAX: u32 = 32;
89pub const HOST_NAME_MAX: u32 = 255;
90pub const LONG_BIT: u32 = 32;
91pub const DELAYTIMER_MAX: u32 = 2147483647;
92pub const CHARCLASS_NAME_MAX: u32 = 14;
93pub const COLL_WEIGHTS_MAX: u32 = 2;
94pub const RE_DUP_MAX: u32 = 255;
95pub const NL_ARGMAX: u32 = 9;
96pub const NL_MSGMAX: u32 = 32767;
97pub const NL_SETMAX: u32 = 255;
98pub const NL_TEXTMAX: u32 = 2048;
99pub const PAGE_SIZE: u32 = 65536;
100pub const NZERO: u32 = 20;
101pub const NL_LANGMAX: u32 = 32;
102pub const NL_NMAX: u32 = 16;
103pub const _POSIX_AIO_LISTIO_MAX: u32 = 2;
104pub const _POSIX_AIO_MAX: u32 = 1;
105pub const _POSIX_ARG_MAX: u32 = 4096;
106pub const _POSIX_CHILD_MAX: u32 = 25;
107pub const _POSIX_CLOCKRES_MIN: u32 = 20000000;
108pub const _POSIX_DELAYTIMER_MAX: u32 = 32;
109pub const _POSIX_HOST_NAME_MAX: u32 = 255;
110pub const _POSIX_LINK_MAX: u32 = 8;
111pub const _POSIX_LOGIN_NAME_MAX: u32 = 9;
112pub const _POSIX_MAX_CANON: u32 = 255;
113pub const _POSIX_MAX_INPUT: u32 = 255;
114pub const _POSIX_MQ_OPEN_MAX: u32 = 8;
115pub const _POSIX_MQ_PRIO_MAX: u32 = 32;
116pub const _POSIX_NAME_MAX: u32 = 14;
117pub const _POSIX_NGROUPS_MAX: u32 = 8;
118pub const _POSIX_OPEN_MAX: u32 = 20;
119pub const _POSIX_PATH_MAX: u32 = 256;
120pub const _POSIX_PIPE_BUF: u32 = 512;
121pub const _POSIX_RE_DUP_MAX: u32 = 255;
122pub const _POSIX_RTSIG_MAX: u32 = 8;
123pub const _POSIX_SEM_NSEMS_MAX: u32 = 256;
124pub const _POSIX_SEM_VALUE_MAX: u32 = 32767;
125pub const _POSIX_SIGQUEUE_MAX: u32 = 32;
126pub const _POSIX_SSIZE_MAX: u32 = 32767;
127pub const _POSIX_STREAM_MAX: u32 = 8;
128pub const _POSIX_SS_REPL_MAX: u32 = 4;
129pub const _POSIX_SYMLINK_MAX: u32 = 255;
130pub const _POSIX_SYMLOOP_MAX: u32 = 8;
131pub const _POSIX_THREAD_DESTRUCTOR_ITERATIONS: u32 = 4;
132pub const _POSIX_THREAD_KEYS_MAX: u32 = 128;
133pub const _POSIX_THREAD_THREADS_MAX: u32 = 64;
134pub const _POSIX_TIMER_MAX: u32 = 32;
135pub const _POSIX_TRACE_EVENT_NAME_MAX: u32 = 30;
136pub const _POSIX_TRACE_NAME_MAX: u32 = 8;
137pub const _POSIX_TRACE_SYS_MAX: u32 = 8;
138pub const _POSIX_TRACE_USER_EVENT_MAX: u32 = 32;
139pub const _POSIX_TTY_NAME_MAX: u32 = 9;
140pub const _POSIX_TZNAME_MAX: u32 = 6;
141pub const _POSIX2_BC_BASE_MAX: u32 = 99;
142pub const _POSIX2_BC_DIM_MAX: u32 = 2048;
143pub const _POSIX2_BC_SCALE_MAX: u32 = 99;
144pub const _POSIX2_BC_STRING_MAX: u32 = 1000;
145pub const _POSIX2_CHARCLASS_NAME_MAX: u32 = 14;
146pub const _POSIX2_COLL_WEIGHTS_MAX: u32 = 2;
147pub const _POSIX2_EXPR_NEST_MAX: u32 = 32;
148pub const _POSIX2_LINE_MAX: u32 = 2048;
149pub const _POSIX2_RE_DUP_MAX: u32 = 255;
150pub const _XOPEN_IOV_MAX: u32 = 16;
151pub const _XOPEN_NAME_MAX: u32 = 255;
152pub const _XOPEN_PATH_MAX: u32 = 1024;
153pub const MATH_ERRNO: u32 = 1;
154pub const MATH_ERREXCEPT: u32 = 2;
155pub const math_errhandling: u32 = 2;
156pub const FP_ILOGBNAN: i32 = -2147483648;
157pub const FP_ILOGB0: i32 = -2147483648;
158pub const FP_NAN: u32 = 0;
159pub const FP_INFINITE: u32 = 1;
160pub const FP_ZERO: u32 = 2;
161pub const FP_SUBNORMAL: u32 = 3;
162pub const FP_NORMAL: u32 = 4;
163pub const M_E: f64 = 2.718281828459045;
164pub const M_LOG2E: f64 = 1.4426950408889634;
165pub const M_LOG10E: f64 = 0.4342944819032518;
166pub const M_LN2: f64 = 0.6931471805599453;
167pub const M_LN10: f64 = 2.302585092994046;
168pub const M_PI: f64 = 3.141592653589793;
169pub const M_PI_2: f64 = 1.5707963267948966;
170pub const M_PI_4: f64 = 0.7853981633974483;
171pub const M_1_PI: f64 = 0.3183098861837907;
172pub const M_2_PI: f64 = 0.6366197723675814;
173pub const M_2_SQRTPI: f64 = 1.1283791670955126;
174pub const M_SQRT2: f64 = 1.4142135623730951;
175pub const M_SQRT1_2: f64 = 0.7071067811865476;
176pub const EOF: i32 = -1;
177pub const _IOFBF: u32 = 0;
178pub const _IOLBF: u32 = 1;
179pub const _IONBF: u32 = 2;
180pub const BUFSIZ: u32 = 1024;
181pub const FILENAME_MAX: u32 = 4096;
182pub const FOPEN_MAX: u32 = 1000;
183pub const L_ctermid: u32 = 20;
184pub const L_cuserid: u32 = 20;
185pub const EXIT_FAILURE: u32 = 1;
186pub const EXIT_SUCCESS: u32 = 0;
187pub const RAND_MAX: u32 = 2147483647;
188pub const AV_HAVE_BIGENDIAN: u32 = 0;
189pub const AV_HAVE_FAST_UNALIGNED: u32 = 0;
190pub const AVERROR_EXPERIMENTAL: i32 = -733130664;
191pub const AVERROR_INPUT_CHANGED: i32 = -1668179713;
192pub const AVERROR_OUTPUT_CHANGED: i32 = -1668179714;
193pub const AV_ERROR_MAX_STRING_SIZE: u32 = 64;
194pub const LIBAVUTIL_VERSION_MAJOR: u32 = 59;
195pub const LIBAVUTIL_VERSION_MINOR: u32 = 16;
196pub const LIBAVUTIL_VERSION_MICRO: u32 = 101;
197pub const M_Ef: f64 = 2.718281828459045;
198pub const M_LN2f: f64 = 0.6931471805599453;
199pub const M_LN10f: f64 = 2.302585092994046;
200pub const M_LOG2_10: f64 = 3.321928094887362;
201pub const M_LOG2_10f: f64 = 3.321928094887362;
202pub const M_PHI: f64 = 1.618033988749895;
203pub const M_PHIf: f64 = 1.618033988749895;
204pub const M_PIf: f64 = 3.141592653589793;
205pub const M_PI_2f: f64 = 1.5707963267948966;
206pub const M_PI_4f: f64 = 0.7853981633974483;
207pub const M_1_PIf: f64 = 0.3183098861837907;
208pub const M_2_PIf: f64 = 0.6366197723675814;
209pub const M_2_SQRTPIf: f64 = 1.1283791670955126;
210pub const M_SQRT1_2f: f64 = 0.7071067811865476;
211pub const M_SQRT2f: f64 = 1.4142135623730951;
212pub const __GNUC_VA_LIST: u32 = 1;
213pub const AV_LOG_QUIET: i32 = -8;
214pub const AV_LOG_PANIC: u32 = 0;
215pub const AV_LOG_FATAL: u32 = 8;
216pub const AV_LOG_ERROR: u32 = 16;
217pub const AV_LOG_WARNING: u32 = 24;
218pub const AV_LOG_INFO: u32 = 32;
219pub const AV_LOG_VERBOSE: u32 = 40;
220pub const AV_LOG_DEBUG: u32 = 48;
221pub const AV_LOG_TRACE: u32 = 56;
222pub const AV_LOG_MAX_OFFSET: u32 = 64;
223pub const AV_LOG_SKIP_REPEATED: u32 = 1;
224pub const AV_LOG_PRINT_LEVEL: u32 = 2;
225pub const AVPALETTE_SIZE: u32 = 1024;
226pub const AVPALETTE_COUNT: u32 = 256;
227pub const AV_VIDEO_MAX_PLANES: u32 = 4;
228pub const AV_FOURCC_MAX_STRING_SIZE: u32 = 32;
229extern "C" {
230 #[doc = " Return the LIBAVUTIL_VERSION_INT constant."]
231 pub fn avutil_version() -> ::std::os::raw::c_uint;
232}
233extern "C" {
234 #[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."]
235 pub fn av_version_info() -> *const ::std::os::raw::c_char;
236}
237extern "C" {
238 #[doc = " Return the libavutil build-time configuration."]
239 pub fn avutil_configuration() -> *const ::std::os::raw::c_char;
240}
241extern "C" {
242 #[doc = " Return the libavutil license."]
243 pub fn avutil_license() -> *const ::std::os::raw::c_char;
244}
245#[doc = "< Usually treated as AVMEDIA_TYPE_DATA"]
246pub const AVMediaType_AVMEDIA_TYPE_UNKNOWN: AVMediaType = -1;
247pub const AVMediaType_AVMEDIA_TYPE_VIDEO: AVMediaType = 0;
248pub const AVMediaType_AVMEDIA_TYPE_AUDIO: AVMediaType = 1;
249#[doc = "< Opaque data information usually continuous"]
250pub const AVMediaType_AVMEDIA_TYPE_DATA: AVMediaType = 2;
251pub const AVMediaType_AVMEDIA_TYPE_SUBTITLE: AVMediaType = 3;
252#[doc = "< Opaque data information usually sparse"]
253pub const AVMediaType_AVMEDIA_TYPE_ATTACHMENT: AVMediaType = 4;
254pub const AVMediaType_AVMEDIA_TYPE_NB: AVMediaType = 5;
255#[doc = " @addtogroup lavu_media Media Type\n @brief Media Type"]
256pub type AVMediaType = ::std::os::raw::c_int;
257extern "C" {
258 #[doc = " Return a string describing the media_type enum, NULL if media_type\n is unknown."]
259 pub fn av_get_media_type_string(media_type: AVMediaType) -> *const ::std::os::raw::c_char;
260}
261#[doc = "< Undefined"]
262pub const AVPictureType_AV_PICTURE_TYPE_NONE: AVPictureType = 0;
263#[doc = "< Intra"]
264pub const AVPictureType_AV_PICTURE_TYPE_I: AVPictureType = 1;
265#[doc = "< Predicted"]
266pub const AVPictureType_AV_PICTURE_TYPE_P: AVPictureType = 2;
267#[doc = "< Bi-dir predicted"]
268pub const AVPictureType_AV_PICTURE_TYPE_B: AVPictureType = 3;
269#[doc = "< S(GMC)-VOP MPEG-4"]
270pub const AVPictureType_AV_PICTURE_TYPE_S: AVPictureType = 4;
271#[doc = "< Switching Intra"]
272pub const AVPictureType_AV_PICTURE_TYPE_SI: AVPictureType = 5;
273#[doc = "< Switching Predicted"]
274pub const AVPictureType_AV_PICTURE_TYPE_SP: AVPictureType = 6;
275#[doc = "< BI type"]
276pub const AVPictureType_AV_PICTURE_TYPE_BI: AVPictureType = 7;
277#[doc = " @}\n @}\n @defgroup lavu_picture Image related\n\n AVPicture types, pixel formats and basic image planes manipulation.\n\n @{"]
278pub type AVPictureType = ::std::os::raw::c_uint;
279extern "C" {
280 #[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"]
281 pub fn av_get_picture_type_char(pict_type: AVPictureType) -> ::std::os::raw::c_char;
282}
283extern "C" {
284 pub static mut errno: ::std::os::raw::c_int;
285}
286pub type wchar_t = ::std::os::raw::c_int;
287#[repr(C)]
288#[repr(align(16))]
289#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)]
290pub struct max_align_t {
291 pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
292 pub __bindgen_padding_0: u64,
293 pub __clang_max_align_nonce2: u128,
294}
295pub type intmax_t = ::std::os::raw::c_longlong;
296pub type uintmax_t = ::std::os::raw::c_ulonglong;
297pub type time_t = ::std::os::raw::c_longlong;
298pub type suseconds_t = ::std::os::raw::c_longlong;
299#[repr(C)]
300#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
301pub struct timeval {
302 pub tv_sec: time_t,
303 pub tv_usec: suseconds_t,
304}
305#[repr(C)]
306#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
307pub struct timespec {
308 pub tv_sec: time_t,
309 pub tv_nsec: ::std::os::raw::c_long,
310}
311#[repr(C)]
312#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
313pub struct iovec {
314 pub iov_base: *mut ::std::os::raw::c_void,
315 pub iov_len: usize,
316}
317impl Default for iovec {
318 fn default() -> Self {
319 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
320 unsafe {
321 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
322 s.assume_init()
323 }
324 }
325}
326pub type int_fast8_t = i8;
327pub type int_fast64_t = i64;
328pub type int_least8_t = i8;
329pub type int_least16_t = i16;
330pub type int_least32_t = i32;
331pub type int_least64_t = i64;
332pub type uint_fast8_t = u8;
333pub type uint_fast64_t = u64;
334pub type uint_least8_t = u8;
335pub type uint_least16_t = u16;
336pub type uint_least32_t = u32;
337pub type uint_least64_t = u64;
338pub type int_fast16_t = i16;
339pub type int_fast32_t = i32;
340pub type uint_fast16_t = u16;
341pub type uint_fast32_t = u32;
342pub type __wasi_size_t = ::std::os::raw::c_ulong;
343#[doc = " Non-negative file size or length of a region within a file."]
344pub type __wasi_filesize_t = u64;
345#[doc = " Timestamp in nanoseconds."]
346pub type __wasi_timestamp_t = u64;
347#[doc = " Identifiers for clocks."]
348pub type __wasi_clockid_t = u32;
349#[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."]
350pub type __wasi_errno_t = u16;
351#[doc = " File descriptor rights, determining which actions may be performed."]
352pub type __wasi_rights_t = u64;
353#[doc = " A file descriptor handle."]
354pub type __wasi_fd_t = ::std::os::raw::c_int;
355#[doc = " A region of memory for scatter/gather reads."]
356#[repr(C)]
357#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
358pub struct __wasi_iovec_t {
359 #[doc = " The address of the buffer to be filled."]
360 pub buf: *mut u8,
361 #[doc = " The length of the buffer to be filled."]
362 pub buf_len: __wasi_size_t,
363}
364impl Default for __wasi_iovec_t {
365 fn default() -> Self {
366 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
367 unsafe {
368 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
369 s.assume_init()
370 }
371 }
372}
373#[doc = " A region of memory for scatter/gather writes."]
374#[repr(C)]
375#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
376pub struct __wasi_ciovec_t {
377 #[doc = " The address of the buffer to be written."]
378 pub buf: *const u8,
379 #[doc = " The length of the buffer to be written."]
380 pub buf_len: __wasi_size_t,
381}
382impl Default for __wasi_ciovec_t {
383 fn default() -> Self {
384 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
385 unsafe {
386 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
387 s.assume_init()
388 }
389 }
390}
391#[doc = " Relative offset within a file."]
392pub type __wasi_filedelta_t = i64;
393#[doc = " The position relative to which to set the offset of the file descriptor."]
394pub type __wasi_whence_t = u8;
395#[doc = " A reference to the offset of a directory entry.\n\n The value 0 signifies the start of the directory."]
396pub type __wasi_dircookie_t = u64;
397#[doc = " The type for the `dirent::d_namlen` field of `dirent` struct."]
398pub type __wasi_dirnamlen_t = u32;
399#[doc = " File serial number that is unique within its file system."]
400pub type __wasi_inode_t = u64;
401#[doc = " The type of a file descriptor or file."]
402pub type __wasi_filetype_t = u8;
403#[doc = " A directory entry."]
404#[repr(C)]
405#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
406pub struct __wasi_dirent_t {
407 #[doc = " The offset of the next directory entry stored in this directory."]
408 pub d_next: __wasi_dircookie_t,
409 #[doc = " The serial number of the file referred to by this directory entry."]
410 pub d_ino: __wasi_inode_t,
411 #[doc = " The length of the name of the directory entry."]
412 pub d_namlen: __wasi_dirnamlen_t,
413 #[doc = " The type of the file referred to by this directory entry."]
414 pub d_type: __wasi_filetype_t,
415}
416#[doc = " File or memory access pattern advisory information."]
417pub type __wasi_advice_t = u8;
418#[doc = " File descriptor flags."]
419pub type __wasi_fdflags_t = u16;
420#[doc = " File descriptor attributes."]
421#[repr(C)]
422#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
423pub struct __wasi_fdstat_t {
424 #[doc = " File type."]
425 pub fs_filetype: __wasi_filetype_t,
426 #[doc = " File descriptor flags."]
427 pub fs_flags: __wasi_fdflags_t,
428 #[doc = " Rights that apply to this file descriptor."]
429 pub fs_rights_base: __wasi_rights_t,
430 #[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`."]
431 pub fs_rights_inheriting: __wasi_rights_t,
432}
433#[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."]
434pub type __wasi_device_t = u64;
435#[doc = " Which file time attributes to adjust."]
436pub type __wasi_fstflags_t = u16;
437#[doc = " Flags determining the method of how paths are resolved."]
438pub type __wasi_lookupflags_t = u32;
439#[doc = " Open flags used by `path_open`."]
440pub type __wasi_oflags_t = u16;
441#[doc = " Number of hard links to an inode."]
442pub type __wasi_linkcount_t = u64;
443#[doc = " File attributes."]
444#[repr(C)]
445#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
446pub struct __wasi_filestat_t {
447 #[doc = " Device ID of device containing the file."]
448 pub dev: __wasi_device_t,
449 #[doc = " File serial number."]
450 pub ino: __wasi_inode_t,
451 #[doc = " File type."]
452 pub filetype: __wasi_filetype_t,
453 #[doc = " Number of hard links to the file."]
454 pub nlink: __wasi_linkcount_t,
455 #[doc = " For regular files, the file size in bytes. For symbolic links, the length in bytes of the pathname contained in the symbolic link."]
456 pub size: __wasi_filesize_t,
457 #[doc = " Last data access timestamp."]
458 pub atim: __wasi_timestamp_t,
459 #[doc = " Last data modification timestamp."]
460 pub mtim: __wasi_timestamp_t,
461 #[doc = " Last file status change timestamp."]
462 pub ctim: __wasi_timestamp_t,
463}
464#[doc = " User-provided value that may be attached to objects that is retained when\n extracted from the implementation."]
465pub type __wasi_userdata_t = u64;
466#[doc = " Type of a subscription to an event or its occurrence."]
467pub type __wasi_eventtype_t = u8;
468#[doc = " The state of the file descriptor subscribed to with\n `eventtype::fd_read` or `eventtype::fd_write`."]
469pub type __wasi_eventrwflags_t = u16;
470#[doc = " The contents of an `event` when type is `eventtype::fd_read` or\n `eventtype::fd_write`."]
471#[repr(C)]
472#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
473pub struct __wasi_event_fd_readwrite_t {
474 #[doc = " The number of bytes available for reading or writing."]
475 pub nbytes: __wasi_filesize_t,
476 #[doc = " The state of the file descriptor."]
477 pub flags: __wasi_eventrwflags_t,
478}
479#[doc = " An event that occurred."]
480#[repr(C)]
481#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
482pub struct __wasi_event_t {
483 #[doc = " User-provided value that got attached to `subscription::userdata`."]
484 pub userdata: __wasi_userdata_t,
485 #[doc = " If non-zero, an error that occurred while processing the subscription request."]
486 pub error: __wasi_errno_t,
487 #[doc = " The type of event that occured"]
488 pub type_: __wasi_eventtype_t,
489 #[doc = " The contents of the event, if it is an `eventtype::fd_read` or\n `eventtype::fd_write`. `eventtype::clock` events ignore this field."]
490 pub fd_readwrite: __wasi_event_fd_readwrite_t,
491}
492#[doc = " Flags determining how to interpret the timestamp provided in\n `subscription_clock::timeout`."]
493pub type __wasi_subclockflags_t = u16;
494#[doc = " The contents of a `subscription` when type is `eventtype::clock`."]
495#[repr(C)]
496#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
497pub struct __wasi_subscription_clock_t {
498 #[doc = " The clock against which to compare the timestamp."]
499 pub id: __wasi_clockid_t,
500 #[doc = " The absolute or relative timestamp."]
501 pub timeout: __wasi_timestamp_t,
502 #[doc = " The amount of time that the implementation may wait additionally\n to coalesce with other events."]
503 pub precision: __wasi_timestamp_t,
504 #[doc = " Flags specifying whether the timeout is absolute or relative"]
505 pub flags: __wasi_subclockflags_t,
506}
507#[doc = " The contents of a `subscription` when type is type is\n `eventtype::fd_read` or `eventtype::fd_write`."]
508#[repr(C)]
509#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
510pub struct __wasi_subscription_fd_readwrite_t {
511 #[doc = " The file descriptor on which to wait for it to become ready for reading or writing."]
512 pub file_descriptor: __wasi_fd_t,
513}
514#[doc = " The contents of a `subscription`."]
515#[repr(C)]
516#[derive(Copy, Clone)]
517pub union __wasi_subscription_u_u_t {
518 pub clock: __wasi_subscription_clock_t,
519 pub fd_read: __wasi_subscription_fd_readwrite_t,
520 pub fd_write: __wasi_subscription_fd_readwrite_t,
521}
522impl Default for __wasi_subscription_u_u_t {
523 fn default() -> Self {
524 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
525 unsafe {
526 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
527 s.assume_init()
528 }
529 }
530}
531#[repr(C)]
532#[derive(Copy, Clone)]
533pub struct __wasi_subscription_u_t {
534 pub tag: u8,
535 pub u: __wasi_subscription_u_u_t,
536}
537impl Default for __wasi_subscription_u_t {
538 fn default() -> Self {
539 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
540 unsafe {
541 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
542 s.assume_init()
543 }
544 }
545}
546#[doc = " Subscription to an event."]
547#[repr(C)]
548#[derive(Copy, Clone)]
549pub struct __wasi_subscription_t {
550 #[doc = " User-provided value that is attached to the subscription in the\n implementation and returned through `event::userdata`."]
551 pub userdata: __wasi_userdata_t,
552 #[doc = " The type of the event to which to subscribe, and its contents"]
553 pub u: __wasi_subscription_u_t,
554}
555impl Default for __wasi_subscription_t {
556 fn default() -> Self {
557 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
558 unsafe {
559 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
560 s.assume_init()
561 }
562 }
563}
564#[doc = " Exit code generated by a process when exiting."]
565pub type __wasi_exitcode_t = u32;
566#[doc = " Flags provided to `sock_recv`."]
567pub type __wasi_riflags_t = u16;
568#[doc = " Flags returned by `sock_recv`."]
569pub type __wasi_roflags_t = u16;
570#[doc = " Flags provided to `sock_send`. As there are currently no flags\n defined, it must be set to zero."]
571pub type __wasi_siflags_t = u16;
572#[doc = " Which channels on a socket to shut down."]
573pub type __wasi_sdflags_t = u8;
574#[doc = " Identifiers for preopened capabilities."]
575pub type __wasi_preopentype_t = u8;
576#[doc = " The contents of a $prestat when type is `preopentype::dir`."]
577#[repr(C)]
578#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
579pub struct __wasi_prestat_dir_t {
580 #[doc = " The length of the directory name for use with `fd_prestat_dir_name`."]
581 pub pr_name_len: __wasi_size_t,
582}
583#[doc = " Information about a pre-opened capability."]
584#[repr(C)]
585#[derive(Copy, Clone)]
586pub union __wasi_prestat_u_t {
587 pub dir: __wasi_prestat_dir_t,
588}
589impl Default for __wasi_prestat_u_t {
590 fn default() -> Self {
591 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
592 unsafe {
593 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
594 s.assume_init()
595 }
596 }
597}
598#[repr(C)]
599#[derive(Copy, Clone)]
600pub struct __wasi_prestat_t {
601 pub tag: u8,
602 pub u: __wasi_prestat_u_t,
603}
604impl Default for __wasi_prestat_t {
605 fn default() -> Self {
606 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
607 unsafe {
608 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
609 s.assume_init()
610 }
611 }
612}
613extern "C" {
614 #[must_use]
615 #[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."]
616 pub fn __wasi_args_get(argv: *mut *mut u8, argv_buf: *mut u8) -> __wasi_errno_t;
617}
618extern "C" {
619 #[must_use]
620 #[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."]
621 pub fn __wasi_args_sizes_get(
622 retptr0: *mut __wasi_size_t,
623 retptr1: *mut __wasi_size_t,
624 ) -> __wasi_errno_t;
625}
626extern "C" {
627 #[must_use]
628 #[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."]
629 pub fn __wasi_environ_get(environ: *mut *mut u8, environ_buf: *mut u8) -> __wasi_errno_t;
630}
631extern "C" {
632 #[must_use]
633 #[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."]
634 pub fn __wasi_environ_sizes_get(
635 retptr0: *mut __wasi_size_t,
636 retptr1: *mut __wasi_size_t,
637 ) -> __wasi_errno_t;
638}
639extern "C" {
640 #[must_use]
641 #[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."]
642 pub fn __wasi_clock_res_get(
643 id: __wasi_clockid_t,
644 retptr0: *mut __wasi_timestamp_t,
645 ) -> __wasi_errno_t;
646}
647extern "C" {
648 #[must_use]
649 #[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."]
650 pub fn __wasi_clock_time_get(
651 id: __wasi_clockid_t,
652 precision: __wasi_timestamp_t,
653 retptr0: *mut __wasi_timestamp_t,
654 ) -> __wasi_errno_t;
655}
656extern "C" {
657 #[must_use]
658 #[doc = " Provide file advisory information on a file descriptor.\n Note: This is similar to `posix_fadvise` in POSIX."]
659 pub fn __wasi_fd_advise(
660 fd: __wasi_fd_t,
661 offset: __wasi_filesize_t,
662 len: __wasi_filesize_t,
663 advice: __wasi_advice_t,
664 ) -> __wasi_errno_t;
665}
666extern "C" {
667 #[must_use]
668 #[doc = " Force the allocation of space in a file.\n Note: This is similar to `posix_fallocate` in POSIX."]
669 pub fn __wasi_fd_allocate(
670 fd: __wasi_fd_t,
671 offset: __wasi_filesize_t,
672 len: __wasi_filesize_t,
673 ) -> __wasi_errno_t;
674}
675extern "C" {
676 #[must_use]
677 #[doc = " Close a file descriptor.\n Note: This is similar to `close` in POSIX."]
678 pub fn __wasi_fd_close(fd: __wasi_fd_t) -> __wasi_errno_t;
679}
680extern "C" {
681 #[must_use]
682 #[doc = " Synchronize the data of a file to disk.\n Note: This is similar to `fdatasync` in POSIX."]
683 pub fn __wasi_fd_datasync(fd: __wasi_fd_t) -> __wasi_errno_t;
684}
685extern "C" {
686 #[must_use]
687 #[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."]
688 pub fn __wasi_fd_fdstat_get(fd: __wasi_fd_t, retptr0: *mut __wasi_fdstat_t) -> __wasi_errno_t;
689}
690extern "C" {
691 #[must_use]
692 #[doc = " Adjust the flags associated with a file descriptor.\n Note: This is similar to `fcntl(fd, F_SETFL, flags)` in POSIX."]
693 pub fn __wasi_fd_fdstat_set_flags(fd: __wasi_fd_t, flags: __wasi_fdflags_t) -> __wasi_errno_t;
694}
695extern "C" {
696 #[must_use]
697 #[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"]
698 pub fn __wasi_fd_fdstat_set_rights(
699 fd: __wasi_fd_t,
700 fs_rights_base: __wasi_rights_t,
701 fs_rights_inheriting: __wasi_rights_t,
702 ) -> __wasi_errno_t;
703}
704extern "C" {
705 #[must_use]
706 #[doc = " Return the attributes of an open file.\n @return\n The buffer where the file's attributes are stored."]
707 pub fn __wasi_fd_filestat_get(
708 fd: __wasi_fd_t,
709 retptr0: *mut __wasi_filestat_t,
710 ) -> __wasi_errno_t;
711}
712extern "C" {
713 #[must_use]
714 #[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."]
715 pub fn __wasi_fd_filestat_set_size(fd: __wasi_fd_t, size: __wasi_filesize_t) -> __wasi_errno_t;
716}
717extern "C" {
718 #[must_use]
719 #[doc = " Adjust the timestamps of an open file or directory.\n Note: This is similar to `futimens` in POSIX."]
720 pub fn __wasi_fd_filestat_set_times(
721 fd: __wasi_fd_t,
722 atim: __wasi_timestamp_t,
723 mtim: __wasi_timestamp_t,
724 fst_flags: __wasi_fstflags_t,
725 ) -> __wasi_errno_t;
726}
727extern "C" {
728 #[must_use]
729 #[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."]
730 pub fn __wasi_fd_pread(
731 fd: __wasi_fd_t,
732 iovs: *const __wasi_iovec_t,
733 iovs_len: usize,
734 offset: __wasi_filesize_t,
735 retptr0: *mut __wasi_size_t,
736 ) -> __wasi_errno_t;
737}
738extern "C" {
739 #[must_use]
740 #[doc = " Return a description of the given preopened file descriptor.\n @return\n The buffer where the description is stored."]
741 pub fn __wasi_fd_prestat_get(fd: __wasi_fd_t, retptr0: *mut __wasi_prestat_t)
742 -> __wasi_errno_t;
743}
744extern "C" {
745 #[must_use]
746 #[doc = " Return a description of the given preopened file descriptor."]
747 pub fn __wasi_fd_prestat_dir_name(
748 fd: __wasi_fd_t,
749 path: *mut u8,
750 path_len: __wasi_size_t,
751 ) -> __wasi_errno_t;
752}
753extern "C" {
754 #[must_use]
755 #[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."]
756 pub fn __wasi_fd_pwrite(
757 fd: __wasi_fd_t,
758 iovs: *const __wasi_ciovec_t,
759 iovs_len: usize,
760 offset: __wasi_filesize_t,
761 retptr0: *mut __wasi_size_t,
762 ) -> __wasi_errno_t;
763}
764extern "C" {
765 #[must_use]
766 #[doc = " Read from a file descriptor.\n Note: This is similar to `readv` in POSIX.\n @return\n The number of bytes read."]
767 pub fn __wasi_fd_read(
768 fd: __wasi_fd_t,
769 iovs: *const __wasi_iovec_t,
770 iovs_len: usize,
771 retptr0: *mut __wasi_size_t,
772 ) -> __wasi_errno_t;
773}
774extern "C" {
775 #[must_use]
776 #[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."]
777 pub fn __wasi_fd_readdir(
778 fd: __wasi_fd_t,
779 buf: *mut u8,
780 buf_len: __wasi_size_t,
781 cookie: __wasi_dircookie_t,
782 retptr0: *mut __wasi_size_t,
783 ) -> __wasi_errno_t;
784}
785extern "C" {
786 #[must_use]
787 #[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."]
788 pub fn __wasi_fd_renumber(fd: __wasi_fd_t, to: __wasi_fd_t) -> __wasi_errno_t;
789}
790extern "C" {
791 #[must_use]
792 #[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."]
793 pub fn __wasi_fd_seek(
794 fd: __wasi_fd_t,
795 offset: __wasi_filedelta_t,
796 whence: __wasi_whence_t,
797 retptr0: *mut __wasi_filesize_t,
798 ) -> __wasi_errno_t;
799}
800extern "C" {
801 #[must_use]
802 #[doc = " Synchronize the data and metadata of a file to disk.\n Note: This is similar to `fsync` in POSIX."]
803 pub fn __wasi_fd_sync(fd: __wasi_fd_t) -> __wasi_errno_t;
804}
805extern "C" {
806 #[must_use]
807 #[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."]
808 pub fn __wasi_fd_tell(fd: __wasi_fd_t, retptr0: *mut __wasi_filesize_t) -> __wasi_errno_t;
809}
810extern "C" {
811 #[must_use]
812 #[doc = " Write to a file descriptor.\n Note: This is similar to `writev` in POSIX."]
813 pub fn __wasi_fd_write(
814 fd: __wasi_fd_t,
815 iovs: *const __wasi_ciovec_t,
816 iovs_len: usize,
817 retptr0: *mut __wasi_size_t,
818 ) -> __wasi_errno_t;
819}
820extern "C" {
821 #[must_use]
822 #[doc = " Create a directory.\n Note: This is similar to `mkdirat` in POSIX."]
823 pub fn __wasi_path_create_directory(
824 fd: __wasi_fd_t,
825 path: *const ::std::os::raw::c_char,
826 ) -> __wasi_errno_t;
827}
828extern "C" {
829 #[must_use]
830 #[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."]
831 pub fn __wasi_path_filestat_get(
832 fd: __wasi_fd_t,
833 flags: __wasi_lookupflags_t,
834 path: *const ::std::os::raw::c_char,
835 retptr0: *mut __wasi_filestat_t,
836 ) -> __wasi_errno_t;
837}
838extern "C" {
839 #[must_use]
840 #[doc = " Adjust the timestamps of a file or directory.\n Note: This is similar to `utimensat` in POSIX."]
841 pub fn __wasi_path_filestat_set_times(
842 fd: __wasi_fd_t,
843 flags: __wasi_lookupflags_t,
844 path: *const ::std::os::raw::c_char,
845 atim: __wasi_timestamp_t,
846 mtim: __wasi_timestamp_t,
847 fst_flags: __wasi_fstflags_t,
848 ) -> __wasi_errno_t;
849}
850extern "C" {
851 #[must_use]
852 #[doc = " Create a hard link.\n Note: This is similar to `linkat` in POSIX."]
853 pub fn __wasi_path_link(
854 old_fd: __wasi_fd_t,
855 old_flags: __wasi_lookupflags_t,
856 old_path: *const ::std::os::raw::c_char,
857 new_fd: __wasi_fd_t,
858 new_path: *const ::std::os::raw::c_char,
859 ) -> __wasi_errno_t;
860}
861extern "C" {
862 #[must_use]
863 #[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."]
864 pub fn __wasi_path_open(
865 fd: __wasi_fd_t,
866 dirflags: __wasi_lookupflags_t,
867 path: *const ::std::os::raw::c_char,
868 oflags: __wasi_oflags_t,
869 fs_rights_base: __wasi_rights_t,
870 fs_rights_inheriting: __wasi_rights_t,
871 fdflags: __wasi_fdflags_t,
872 retptr0: *mut __wasi_fd_t,
873 ) -> __wasi_errno_t;
874}
875extern "C" {
876 #[must_use]
877 #[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."]
878 pub fn __wasi_path_readlink(
879 fd: __wasi_fd_t,
880 path: *const ::std::os::raw::c_char,
881 buf: *mut u8,
882 buf_len: __wasi_size_t,
883 retptr0: *mut __wasi_size_t,
884 ) -> __wasi_errno_t;
885}
886extern "C" {
887 #[must_use]
888 #[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."]
889 pub fn __wasi_path_remove_directory(
890 fd: __wasi_fd_t,
891 path: *const ::std::os::raw::c_char,
892 ) -> __wasi_errno_t;
893}
894extern "C" {
895 #[must_use]
896 #[doc = " Rename a file or directory.\n Note: This is similar to `renameat` in POSIX."]
897 pub fn __wasi_path_rename(
898 fd: __wasi_fd_t,
899 old_path: *const ::std::os::raw::c_char,
900 new_fd: __wasi_fd_t,
901 new_path: *const ::std::os::raw::c_char,
902 ) -> __wasi_errno_t;
903}
904extern "C" {
905 #[must_use]
906 #[doc = " Create a symbolic link.\n Note: This is similar to `symlinkat` in POSIX."]
907 pub fn __wasi_path_symlink(
908 old_path: *const ::std::os::raw::c_char,
909 fd: __wasi_fd_t,
910 new_path: *const ::std::os::raw::c_char,
911 ) -> __wasi_errno_t;
912}
913extern "C" {
914 #[must_use]
915 #[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."]
916 pub fn __wasi_path_unlink_file(
917 fd: __wasi_fd_t,
918 path: *const ::std::os::raw::c_char,
919 ) -> __wasi_errno_t;
920}
921extern "C" {
922 #[must_use]
923 #[doc = " Concurrently poll for the occurrence of a set of events.\n @return\n The number of events stored."]
924 pub fn __wasi_poll_oneoff(
925 in_: *const __wasi_subscription_t,
926 out: *mut __wasi_event_t,
927 nsubscriptions: __wasi_size_t,
928 retptr0: *mut __wasi_size_t,
929 ) -> __wasi_errno_t;
930}
931extern "C" {
932 #[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."]
933 pub fn __wasi_proc_exit(rval: __wasi_exitcode_t) -> !;
934}
935extern "C" {
936 #[must_use]
937 #[doc = " Temporarily yield execution of the calling thread.\n Note: This is similar to `sched_yield` in POSIX."]
938 pub fn __wasi_sched_yield() -> __wasi_errno_t;
939}
940extern "C" {
941 #[must_use]
942 #[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."]
943 pub fn __wasi_random_get(buf: *mut u8, buf_len: __wasi_size_t) -> __wasi_errno_t;
944}
945extern "C" {
946 #[must_use]
947 #[doc = " Accept a new incoming connection.\n Note: This is similar to `accept` in POSIX.\n @return\n New socket connection"]
948 pub fn __wasi_sock_accept(
949 fd: __wasi_fd_t,
950 flags: __wasi_fdflags_t,
951 retptr0: *mut __wasi_fd_t,
952 ) -> __wasi_errno_t;
953}
954extern "C" {
955 #[must_use]
956 #[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."]
957 pub fn __wasi_sock_recv(
958 fd: __wasi_fd_t,
959 ri_data: *const __wasi_iovec_t,
960 ri_data_len: usize,
961 ri_flags: __wasi_riflags_t,
962 retptr0: *mut __wasi_size_t,
963 retptr1: *mut __wasi_roflags_t,
964 ) -> __wasi_errno_t;
965}
966extern "C" {
967 #[must_use]
968 #[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."]
969 pub fn __wasi_sock_send(
970 fd: __wasi_fd_t,
971 si_data: *const __wasi_ciovec_t,
972 si_data_len: usize,
973 si_flags: __wasi_siflags_t,
974 retptr0: *mut __wasi_size_t,
975 ) -> __wasi_errno_t;
976}
977extern "C" {
978 #[must_use]
979 #[doc = " Shut down socket send and receive channels.\n Note: This is similar to `shutdown` in POSIX."]
980 pub fn __wasi_sock_shutdown(fd: __wasi_fd_t, how: __wasi_sdflags_t) -> __wasi_errno_t;
981}
982#[repr(C)]
983#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
984pub struct imaxdiv_t {
985 pub quot: intmax_t,
986 pub rem: intmax_t,
987}
988extern "C" {
989 pub fn imaxabs(arg1: intmax_t) -> intmax_t;
990}
991extern "C" {
992 pub fn imaxdiv(arg1: intmax_t, arg2: intmax_t) -> imaxdiv_t;
993}
994extern "C" {
995 pub fn strtoimax(
996 arg1: *const ::std::os::raw::c_char,
997 arg2: *mut *mut ::std::os::raw::c_char,
998 arg3: ::std::os::raw::c_int,
999 ) -> intmax_t;
1000}
1001extern "C" {
1002 pub fn strtoumax(
1003 arg1: *const ::std::os::raw::c_char,
1004 arg2: *mut *mut ::std::os::raw::c_char,
1005 arg3: ::std::os::raw::c_int,
1006 ) -> uintmax_t;
1007}
1008extern "C" {
1009 pub fn wcstoimax(
1010 arg1: *const wchar_t,
1011 arg2: *mut *mut wchar_t,
1012 arg3: ::std::os::raw::c_int,
1013 ) -> intmax_t;
1014}
1015extern "C" {
1016 pub fn wcstoumax(
1017 arg1: *const wchar_t,
1018 arg2: *mut *mut wchar_t,
1019 arg3: ::std::os::raw::c_int,
1020 ) -> uintmax_t;
1021}
1022pub type float_t = f32;
1023pub type double_t = f64;
1024extern "C" {
1025 pub fn acos(arg1: f64) -> f64;
1026}
1027extern "C" {
1028 pub fn acosf(arg1: f32) -> f32;
1029}
1030extern "C" {
1031 pub fn acosl(arg1: u128) -> u128;
1032}
1033extern "C" {
1034 pub fn acosh(arg1: f64) -> f64;
1035}
1036extern "C" {
1037 pub fn acoshf(arg1: f32) -> f32;
1038}
1039extern "C" {
1040 pub fn acoshl(arg1: u128) -> u128;
1041}
1042extern "C" {
1043 pub fn asin(arg1: f64) -> f64;
1044}
1045extern "C" {
1046 pub fn asinf(arg1: f32) -> f32;
1047}
1048extern "C" {
1049 pub fn asinl(arg1: u128) -> u128;
1050}
1051extern "C" {
1052 pub fn asinh(arg1: f64) -> f64;
1053}
1054extern "C" {
1055 pub fn asinhf(arg1: f32) -> f32;
1056}
1057extern "C" {
1058 pub fn asinhl(arg1: u128) -> u128;
1059}
1060extern "C" {
1061 pub fn atan(arg1: f64) -> f64;
1062}
1063extern "C" {
1064 pub fn atanf(arg1: f32) -> f32;
1065}
1066extern "C" {
1067 pub fn atanl(arg1: u128) -> u128;
1068}
1069extern "C" {
1070 pub fn atan2(arg1: f64, arg2: f64) -> f64;
1071}
1072extern "C" {
1073 pub fn atan2f(arg1: f32, arg2: f32) -> f32;
1074}
1075extern "C" {
1076 pub fn atan2l(arg1: u128, arg2: u128) -> u128;
1077}
1078extern "C" {
1079 pub fn atanh(arg1: f64) -> f64;
1080}
1081extern "C" {
1082 pub fn atanhf(arg1: f32) -> f32;
1083}
1084extern "C" {
1085 pub fn atanhl(arg1: u128) -> u128;
1086}
1087extern "C" {
1088 pub fn cbrt(arg1: f64) -> f64;
1089}
1090extern "C" {
1091 pub fn cbrtf(arg1: f32) -> f32;
1092}
1093extern "C" {
1094 pub fn cbrtl(arg1: u128) -> u128;
1095}
1096extern "C" {
1097 pub fn ceil(arg1: f64) -> f64;
1098}
1099extern "C" {
1100 pub fn ceilf(arg1: f32) -> f32;
1101}
1102extern "C" {
1103 pub fn ceill(arg1: u128) -> u128;
1104}
1105extern "C" {
1106 pub fn copysign(arg1: f64, arg2: f64) -> f64;
1107}
1108extern "C" {
1109 pub fn copysignf(arg1: f32, arg2: f32) -> f32;
1110}
1111extern "C" {
1112 pub fn copysignl(arg1: u128, arg2: u128) -> u128;
1113}
1114extern "C" {
1115 pub fn cos(arg1: f64) -> f64;
1116}
1117extern "C" {
1118 pub fn cosf(arg1: f32) -> f32;
1119}
1120extern "C" {
1121 pub fn cosl(arg1: u128) -> u128;
1122}
1123extern "C" {
1124 pub fn cosh(arg1: f64) -> f64;
1125}
1126extern "C" {
1127 pub fn coshf(arg1: f32) -> f32;
1128}
1129extern "C" {
1130 pub fn coshl(arg1: u128) -> u128;
1131}
1132extern "C" {
1133 pub fn erf(arg1: f64) -> f64;
1134}
1135extern "C" {
1136 pub fn erff(arg1: f32) -> f32;
1137}
1138extern "C" {
1139 pub fn erfl(arg1: u128) -> u128;
1140}
1141extern "C" {
1142 pub fn erfc(arg1: f64) -> f64;
1143}
1144extern "C" {
1145 pub fn erfcf(arg1: f32) -> f32;
1146}
1147extern "C" {
1148 pub fn erfcl(arg1: u128) -> u128;
1149}
1150extern "C" {
1151 pub fn exp(arg1: f64) -> f64;
1152}
1153extern "C" {
1154 pub fn expf(arg1: f32) -> f32;
1155}
1156extern "C" {
1157 pub fn expl(arg1: u128) -> u128;
1158}
1159extern "C" {
1160 pub fn exp2(arg1: f64) -> f64;
1161}
1162extern "C" {
1163 pub fn exp2f(arg1: f32) -> f32;
1164}
1165extern "C" {
1166 pub fn exp2l(arg1: u128) -> u128;
1167}
1168extern "C" {
1169 pub fn expm1(arg1: f64) -> f64;
1170}
1171extern "C" {
1172 pub fn expm1f(arg1: f32) -> f32;
1173}
1174extern "C" {
1175 pub fn expm1l(arg1: u128) -> u128;
1176}
1177extern "C" {
1178 pub fn fabs(arg1: f64) -> f64;
1179}
1180extern "C" {
1181 pub fn fabsf(arg1: f32) -> f32;
1182}
1183extern "C" {
1184 pub fn fabsl(arg1: u128) -> u128;
1185}
1186extern "C" {
1187 pub fn fdim(arg1: f64, arg2: f64) -> f64;
1188}
1189extern "C" {
1190 pub fn fdimf(arg1: f32, arg2: f32) -> f32;
1191}
1192extern "C" {
1193 pub fn fdiml(arg1: u128, arg2: u128) -> u128;
1194}
1195extern "C" {
1196 pub fn floor(arg1: f64) -> f64;
1197}
1198extern "C" {
1199 pub fn floorf(arg1: f32) -> f32;
1200}
1201extern "C" {
1202 pub fn floorl(arg1: u128) -> u128;
1203}
1204extern "C" {
1205 pub fn fma(arg1: f64, arg2: f64, arg3: f64) -> f64;
1206}
1207extern "C" {
1208 pub fn fmaf(arg1: f32, arg2: f32, arg3: f32) -> f32;
1209}
1210extern "C" {
1211 pub fn fmal(arg1: u128, arg2: u128, arg3: u128) -> u128;
1212}
1213extern "C" {
1214 pub fn fmax(arg1: f64, arg2: f64) -> f64;
1215}
1216extern "C" {
1217 pub fn fmaxf(arg1: f32, arg2: f32) -> f32;
1218}
1219extern "C" {
1220 pub fn fmaxl(arg1: u128, arg2: u128) -> u128;
1221}
1222extern "C" {
1223 pub fn fmin(arg1: f64, arg2: f64) -> f64;
1224}
1225extern "C" {
1226 pub fn fminf(arg1: f32, arg2: f32) -> f32;
1227}
1228extern "C" {
1229 pub fn fminl(arg1: u128, arg2: u128) -> u128;
1230}
1231extern "C" {
1232 pub fn fmod(arg1: f64, arg2: f64) -> f64;
1233}
1234extern "C" {
1235 pub fn fmodf(arg1: f32, arg2: f32) -> f32;
1236}
1237extern "C" {
1238 pub fn fmodl(arg1: u128, arg2: u128) -> u128;
1239}
1240extern "C" {
1241 pub fn frexp(arg1: f64, arg2: *mut ::std::os::raw::c_int) -> f64;
1242}
1243extern "C" {
1244 pub fn frexpf(arg1: f32, arg2: *mut ::std::os::raw::c_int) -> f32;
1245}
1246extern "C" {
1247 pub fn frexpl(arg1: u128, arg2: *mut ::std::os::raw::c_int) -> u128;
1248}
1249extern "C" {
1250 pub fn hypot(arg1: f64, arg2: f64) -> f64;
1251}
1252extern "C" {
1253 pub fn hypotf(arg1: f32, arg2: f32) -> f32;
1254}
1255extern "C" {
1256 pub fn hypotl(arg1: u128, arg2: u128) -> u128;
1257}
1258extern "C" {
1259 pub fn ilogb(arg1: f64) -> ::std::os::raw::c_int;
1260}
1261extern "C" {
1262 pub fn ilogbf(arg1: f32) -> ::std::os::raw::c_int;
1263}
1264extern "C" {
1265 pub fn ilogbl(arg1: u128) -> ::std::os::raw::c_int;
1266}
1267extern "C" {
1268 pub fn ldexp(arg1: f64, arg2: ::std::os::raw::c_int) -> f64;
1269}
1270extern "C" {
1271 pub fn ldexpf(arg1: f32, arg2: ::std::os::raw::c_int) -> f32;
1272}
1273extern "C" {
1274 pub fn ldexpl(arg1: u128, arg2: ::std::os::raw::c_int) -> u128;
1275}
1276extern "C" {
1277 pub fn lgamma(arg1: f64) -> f64;
1278}
1279extern "C" {
1280 pub fn lgammaf(arg1: f32) -> f32;
1281}
1282extern "C" {
1283 pub fn lgammal(arg1: u128) -> u128;
1284}
1285extern "C" {
1286 pub fn llrint(arg1: f64) -> ::std::os::raw::c_longlong;
1287}
1288extern "C" {
1289 pub fn llrintf(arg1: f32) -> ::std::os::raw::c_longlong;
1290}
1291extern "C" {
1292 pub fn llrintl(arg1: u128) -> ::std::os::raw::c_longlong;
1293}
1294extern "C" {
1295 pub fn llround(arg1: f64) -> ::std::os::raw::c_longlong;
1296}
1297extern "C" {
1298 pub fn llroundf(arg1: f32) -> ::std::os::raw::c_longlong;
1299}
1300extern "C" {
1301 pub fn llroundl(arg1: u128) -> ::std::os::raw::c_longlong;
1302}
1303extern "C" {
1304 pub fn log(arg1: f64) -> f64;
1305}
1306extern "C" {
1307 pub fn logf(arg1: f32) -> f32;
1308}
1309extern "C" {
1310 pub fn logl(arg1: u128) -> u128;
1311}
1312extern "C" {
1313 pub fn log10(arg1: f64) -> f64;
1314}
1315extern "C" {
1316 pub fn log10f(arg1: f32) -> f32;
1317}
1318extern "C" {
1319 pub fn log10l(arg1: u128) -> u128;
1320}
1321extern "C" {
1322 pub fn log1p(arg1: f64) -> f64;
1323}
1324extern "C" {
1325 pub fn log1pf(arg1: f32) -> f32;
1326}
1327extern "C" {
1328 pub fn log1pl(arg1: u128) -> u128;
1329}
1330extern "C" {
1331 pub fn log2(arg1: f64) -> f64;
1332}
1333extern "C" {
1334 pub fn log2f(arg1: f32) -> f32;
1335}
1336extern "C" {
1337 pub fn log2l(arg1: u128) -> u128;
1338}
1339extern "C" {
1340 pub fn logb(arg1: f64) -> f64;
1341}
1342extern "C" {
1343 pub fn logbf(arg1: f32) -> f32;
1344}
1345extern "C" {
1346 pub fn logbl(arg1: u128) -> u128;
1347}
1348extern "C" {
1349 pub fn lrint(arg1: f64) -> ::std::os::raw::c_long;
1350}
1351extern "C" {
1352 pub fn lrintf(arg1: f32) -> ::std::os::raw::c_long;
1353}
1354extern "C" {
1355 pub fn lrintl(arg1: u128) -> ::std::os::raw::c_long;
1356}
1357extern "C" {
1358 pub fn lround(arg1: f64) -> ::std::os::raw::c_long;
1359}
1360extern "C" {
1361 pub fn lroundf(arg1: f32) -> ::std::os::raw::c_long;
1362}
1363extern "C" {
1364 pub fn lroundl(arg1: u128) -> ::std::os::raw::c_long;
1365}
1366extern "C" {
1367 pub fn modf(arg1: f64, arg2: *mut f64) -> f64;
1368}
1369extern "C" {
1370 pub fn modff(arg1: f32, arg2: *mut f32) -> f32;
1371}
1372extern "C" {
1373 pub fn modfl(arg1: u128, arg2: *mut u128) -> u128;
1374}
1375extern "C" {
1376 pub fn nan(arg1: *const ::std::os::raw::c_char) -> f64;
1377}
1378extern "C" {
1379 pub fn nanf(arg1: *const ::std::os::raw::c_char) -> f32;
1380}
1381extern "C" {
1382 pub fn nanl(arg1: *const ::std::os::raw::c_char) -> u128;
1383}
1384extern "C" {
1385 pub fn nearbyint(arg1: f64) -> f64;
1386}
1387extern "C" {
1388 pub fn nearbyintf(arg1: f32) -> f32;
1389}
1390extern "C" {
1391 pub fn nearbyintl(arg1: u128) -> u128;
1392}
1393extern "C" {
1394 pub fn nextafter(arg1: f64, arg2: f64) -> f64;
1395}
1396extern "C" {
1397 pub fn nextafterf(arg1: f32, arg2: f32) -> f32;
1398}
1399extern "C" {
1400 pub fn nextafterl(arg1: u128, arg2: u128) -> u128;
1401}
1402extern "C" {
1403 pub fn nexttoward(arg1: f64, arg2: u128) -> f64;
1404}
1405extern "C" {
1406 pub fn nexttowardf(arg1: f32, arg2: u128) -> f32;
1407}
1408extern "C" {
1409 pub fn nexttowardl(arg1: u128, arg2: u128) -> u128;
1410}
1411extern "C" {
1412 pub fn pow(arg1: f64, arg2: f64) -> f64;
1413}
1414extern "C" {
1415 pub fn powf(arg1: f32, arg2: f32) -> f32;
1416}
1417extern "C" {
1418 pub fn powl(arg1: u128, arg2: u128) -> u128;
1419}
1420extern "C" {
1421 pub fn remainder(arg1: f64, arg2: f64) -> f64;
1422}
1423extern "C" {
1424 pub fn remainderf(arg1: f32, arg2: f32) -> f32;
1425}
1426extern "C" {
1427 pub fn remainderl(arg1: u128, arg2: u128) -> u128;
1428}
1429extern "C" {
1430 pub fn remquo(arg1: f64, arg2: f64, arg3: *mut ::std::os::raw::c_int) -> f64;
1431}
1432extern "C" {
1433 pub fn remquof(arg1: f32, arg2: f32, arg3: *mut ::std::os::raw::c_int) -> f32;
1434}
1435extern "C" {
1436 pub fn remquol(arg1: u128, arg2: u128, arg3: *mut ::std::os::raw::c_int) -> u128;
1437}
1438extern "C" {
1439 pub fn rint(arg1: f64) -> f64;
1440}
1441extern "C" {
1442 pub fn rintf(arg1: f32) -> f32;
1443}
1444extern "C" {
1445 pub fn rintl(arg1: u128) -> u128;
1446}
1447extern "C" {
1448 pub fn round(arg1: f64) -> f64;
1449}
1450extern "C" {
1451 pub fn roundf(arg1: f32) -> f32;
1452}
1453extern "C" {
1454 pub fn roundl(arg1: u128) -> u128;
1455}
1456extern "C" {
1457 pub fn scalbln(arg1: f64, arg2: ::std::os::raw::c_long) -> f64;
1458}
1459extern "C" {
1460 pub fn scalblnf(arg1: f32, arg2: ::std::os::raw::c_long) -> f32;
1461}
1462extern "C" {
1463 pub fn scalblnl(arg1: u128, arg2: ::std::os::raw::c_long) -> u128;
1464}
1465extern "C" {
1466 pub fn scalbn(arg1: f64, arg2: ::std::os::raw::c_int) -> f64;
1467}
1468extern "C" {
1469 pub fn scalbnf(arg1: f32, arg2: ::std::os::raw::c_int) -> f32;
1470}
1471extern "C" {
1472 pub fn scalbnl(arg1: u128, arg2: ::std::os::raw::c_int) -> u128;
1473}
1474extern "C" {
1475 pub fn sin(arg1: f64) -> f64;
1476}
1477extern "C" {
1478 pub fn sinf(arg1: f32) -> f32;
1479}
1480extern "C" {
1481 pub fn sinl(arg1: u128) -> u128;
1482}
1483extern "C" {
1484 pub fn sinh(arg1: f64) -> f64;
1485}
1486extern "C" {
1487 pub fn sinhf(arg1: f32) -> f32;
1488}
1489extern "C" {
1490 pub fn sinhl(arg1: u128) -> u128;
1491}
1492extern "C" {
1493 pub fn sqrt(arg1: f64) -> f64;
1494}
1495extern "C" {
1496 pub fn sqrtf(arg1: f32) -> f32;
1497}
1498extern "C" {
1499 pub fn sqrtl(arg1: u128) -> u128;
1500}
1501extern "C" {
1502 pub fn tan(arg1: f64) -> f64;
1503}
1504extern "C" {
1505 pub fn tanf(arg1: f32) -> f32;
1506}
1507extern "C" {
1508 pub fn tanl(arg1: u128) -> u128;
1509}
1510extern "C" {
1511 pub fn tanh(arg1: f64) -> f64;
1512}
1513extern "C" {
1514 pub fn tanhf(arg1: f32) -> f32;
1515}
1516extern "C" {
1517 pub fn tanhl(arg1: u128) -> u128;
1518}
1519extern "C" {
1520 pub fn tgamma(arg1: f64) -> f64;
1521}
1522extern "C" {
1523 pub fn tgammaf(arg1: f32) -> f32;
1524}
1525extern "C" {
1526 pub fn tgammal(arg1: u128) -> u128;
1527}
1528extern "C" {
1529 pub fn trunc(arg1: f64) -> f64;
1530}
1531extern "C" {
1532 pub fn truncf(arg1: f32) -> f32;
1533}
1534extern "C" {
1535 pub fn truncl(arg1: u128) -> u128;
1536}
1537extern "C" {
1538 pub static mut signgam: ::std::os::raw::c_int;
1539}
1540extern "C" {
1541 pub fn j0(arg1: f64) -> f64;
1542}
1543extern "C" {
1544 pub fn j1(arg1: f64) -> f64;
1545}
1546extern "C" {
1547 pub fn jn(arg1: ::std::os::raw::c_int, arg2: f64) -> f64;
1548}
1549extern "C" {
1550 pub fn y0(arg1: f64) -> f64;
1551}
1552extern "C" {
1553 pub fn y1(arg1: f64) -> f64;
1554}
1555extern "C" {
1556 pub fn yn(arg1: ::std::os::raw::c_int, arg2: f64) -> f64;
1557}
1558extern "C" {
1559 pub fn drem(arg1: f64, arg2: f64) -> f64;
1560}
1561extern "C" {
1562 pub fn dremf(arg1: f32, arg2: f32) -> f32;
1563}
1564extern "C" {
1565 pub fn finite(arg1: f64) -> ::std::os::raw::c_int;
1566}
1567extern "C" {
1568 pub fn finitef(arg1: f32) -> ::std::os::raw::c_int;
1569}
1570extern "C" {
1571 pub fn scalb(arg1: f64, arg2: f64) -> f64;
1572}
1573extern "C" {
1574 pub fn scalbf(arg1: f32, arg2: f32) -> f32;
1575}
1576extern "C" {
1577 pub fn significand(arg1: f64) -> f64;
1578}
1579extern "C" {
1580 pub fn significandf(arg1: f32) -> f32;
1581}
1582extern "C" {
1583 pub fn lgamma_r(arg1: f64, arg2: *mut ::std::os::raw::c_int) -> f64;
1584}
1585extern "C" {
1586 pub fn lgammaf_r(arg1: f32, arg2: *mut ::std::os::raw::c_int) -> f32;
1587}
1588extern "C" {
1589 pub fn j0f(arg1: f32) -> f32;
1590}
1591extern "C" {
1592 pub fn j1f(arg1: f32) -> f32;
1593}
1594extern "C" {
1595 pub fn jnf(arg1: ::std::os::raw::c_int, arg2: f32) -> f32;
1596}
1597extern "C" {
1598 pub fn y0f(arg1: f32) -> f32;
1599}
1600extern "C" {
1601 pub fn y1f(arg1: f32) -> f32;
1602}
1603extern "C" {
1604 pub fn ynf(arg1: ::std::os::raw::c_int, arg2: f32) -> f32;
1605}
1606pub type off_t = ::std::os::raw::c_longlong;
1607#[repr(C)]
1608#[derive(Debug, Copy, Clone)]
1609pub struct _IO_FILE {
1610 _unused: [u8; 0],
1611}
1612pub type FILE = _IO_FILE;
1613pub type va_list = __builtin_va_list;
1614pub type __isoc_va_list = __builtin_va_list;
1615#[repr(C)]
1616#[derive(Copy, Clone)]
1617pub union _G_fpos64_t {
1618 pub __opaque: [::std::os::raw::c_char; 16usize],
1619 pub __lldata: ::std::os::raw::c_longlong,
1620 pub __align: f64,
1621}
1622impl Default for _G_fpos64_t {
1623 fn default() -> Self {
1624 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1625 unsafe {
1626 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1627 s.assume_init()
1628 }
1629 }
1630}
1631pub type fpos_t = _G_fpos64_t;
1632extern "C" {
1633 pub static stdin: *mut FILE;
1634}
1635extern "C" {
1636 pub static stdout: *mut FILE;
1637}
1638extern "C" {
1639 pub static stderr: *mut FILE;
1640}
1641extern "C" {
1642 pub fn fopen(
1643 arg1: *const ::std::os::raw::c_char,
1644 arg2: *const ::std::os::raw::c_char,
1645 ) -> *mut FILE;
1646}
1647extern "C" {
1648 pub fn freopen(
1649 arg1: *const ::std::os::raw::c_char,
1650 arg2: *const ::std::os::raw::c_char,
1651 arg3: *mut FILE,
1652 ) -> *mut FILE;
1653}
1654extern "C" {
1655 pub fn fclose(arg1: *mut FILE) -> ::std::os::raw::c_int;
1656}
1657extern "C" {
1658 pub fn remove(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1659}
1660extern "C" {
1661 pub fn rename(
1662 arg1: *const ::std::os::raw::c_char,
1663 arg2: *const ::std::os::raw::c_char,
1664 ) -> ::std::os::raw::c_int;
1665}
1666extern "C" {
1667 pub fn feof(arg1: *mut FILE) -> ::std::os::raw::c_int;
1668}
1669extern "C" {
1670 pub fn ferror(arg1: *mut FILE) -> ::std::os::raw::c_int;
1671}
1672extern "C" {
1673 pub fn fflush(arg1: *mut FILE) -> ::std::os::raw::c_int;
1674}
1675extern "C" {
1676 pub fn clearerr(arg1: *mut FILE);
1677}
1678extern "C" {
1679 pub fn fseek(
1680 arg1: *mut FILE,
1681 arg2: ::std::os::raw::c_long,
1682 arg3: ::std::os::raw::c_int,
1683 ) -> ::std::os::raw::c_int;
1684}
1685extern "C" {
1686 pub fn ftell(arg1: *mut FILE) -> ::std::os::raw::c_long;
1687}
1688extern "C" {
1689 pub fn rewind(arg1: *mut FILE);
1690}
1691extern "C" {
1692 pub fn fgetpos(arg1: *mut FILE, arg2: *mut fpos_t) -> ::std::os::raw::c_int;
1693}
1694extern "C" {
1695 pub fn fsetpos(arg1: *mut FILE, arg2: *const fpos_t) -> ::std::os::raw::c_int;
1696}
1697extern "C" {
1698 pub fn fread(
1699 arg1: *mut ::std::os::raw::c_void,
1700 arg2: ::std::os::raw::c_ulong,
1701 arg3: ::std::os::raw::c_ulong,
1702 arg4: *mut FILE,
1703 ) -> ::std::os::raw::c_ulong;
1704}
1705extern "C" {
1706 pub fn fwrite(
1707 arg1: *const ::std::os::raw::c_void,
1708 arg2: ::std::os::raw::c_ulong,
1709 arg3: ::std::os::raw::c_ulong,
1710 arg4: *mut FILE,
1711 ) -> ::std::os::raw::c_ulong;
1712}
1713extern "C" {
1714 pub fn fgetc(arg1: *mut FILE) -> ::std::os::raw::c_int;
1715}
1716extern "C" {
1717 pub fn getc(arg1: *mut FILE) -> ::std::os::raw::c_int;
1718}
1719extern "C" {
1720 pub fn getchar() -> ::std::os::raw::c_int;
1721}
1722extern "C" {
1723 pub fn ungetc(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1724}
1725extern "C" {
1726 pub fn fputc(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1727}
1728extern "C" {
1729 pub fn putc(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1730}
1731extern "C" {
1732 pub fn putchar(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1733}
1734extern "C" {
1735 pub fn fgets(
1736 arg1: *mut ::std::os::raw::c_char,
1737 arg2: ::std::os::raw::c_int,
1738 arg3: *mut FILE,
1739 ) -> *mut ::std::os::raw::c_char;
1740}
1741extern "C" {
1742 pub fn fputs(arg1: *const ::std::os::raw::c_char, arg2: *mut FILE) -> ::std::os::raw::c_int;
1743}
1744extern "C" {
1745 pub fn puts(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1746}
1747extern "C" {
1748 pub fn printf(arg1: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
1749}
1750extern "C" {
1751 pub fn fprintf(
1752 arg1: *mut FILE,
1753 arg2: *const ::std::os::raw::c_char,
1754 ...
1755 ) -> ::std::os::raw::c_int;
1756}
1757extern "C" {
1758 pub fn sprintf(
1759 arg1: *mut ::std::os::raw::c_char,
1760 arg2: *const ::std::os::raw::c_char,
1761 ...
1762 ) -> ::std::os::raw::c_int;
1763}
1764extern "C" {
1765 pub fn snprintf(
1766 arg1: *mut ::std::os::raw::c_char,
1767 arg2: ::std::os::raw::c_ulong,
1768 arg3: *const ::std::os::raw::c_char,
1769 ...
1770 ) -> ::std::os::raw::c_int;
1771}
1772extern "C" {
1773 pub fn vprintf(
1774 arg1: *const ::std::os::raw::c_char,
1775 arg2: __builtin_va_list,
1776 ) -> ::std::os::raw::c_int;
1777}
1778extern "C" {
1779 pub fn vfprintf(
1780 arg1: *mut FILE,
1781 arg2: *const ::std::os::raw::c_char,
1782 arg3: __builtin_va_list,
1783 ) -> ::std::os::raw::c_int;
1784}
1785extern "C" {
1786 pub fn vsprintf(
1787 arg1: *mut ::std::os::raw::c_char,
1788 arg2: *const ::std::os::raw::c_char,
1789 arg3: __builtin_va_list,
1790 ) -> ::std::os::raw::c_int;
1791}
1792extern "C" {
1793 pub fn vsnprintf(
1794 arg1: *mut ::std::os::raw::c_char,
1795 arg2: ::std::os::raw::c_ulong,
1796 arg3: *const ::std::os::raw::c_char,
1797 arg4: __builtin_va_list,
1798 ) -> ::std::os::raw::c_int;
1799}
1800extern "C" {
1801 pub fn scanf(arg1: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
1802}
1803extern "C" {
1804 pub fn fscanf(
1805 arg1: *mut FILE,
1806 arg2: *const ::std::os::raw::c_char,
1807 ...
1808 ) -> ::std::os::raw::c_int;
1809}
1810extern "C" {
1811 pub fn sscanf(
1812 arg1: *const ::std::os::raw::c_char,
1813 arg2: *const ::std::os::raw::c_char,
1814 ...
1815 ) -> ::std::os::raw::c_int;
1816}
1817extern "C" {
1818 pub fn vscanf(
1819 arg1: *const ::std::os::raw::c_char,
1820 arg2: __builtin_va_list,
1821 ) -> ::std::os::raw::c_int;
1822}
1823extern "C" {
1824 pub fn vfscanf(
1825 arg1: *mut FILE,
1826 arg2: *const ::std::os::raw::c_char,
1827 arg3: __builtin_va_list,
1828 ) -> ::std::os::raw::c_int;
1829}
1830extern "C" {
1831 pub fn vsscanf(
1832 arg1: *const ::std::os::raw::c_char,
1833 arg2: *const ::std::os::raw::c_char,
1834 arg3: __builtin_va_list,
1835 ) -> ::std::os::raw::c_int;
1836}
1837extern "C" {
1838 pub fn perror(arg1: *const ::std::os::raw::c_char);
1839}
1840extern "C" {
1841 pub fn setvbuf(
1842 arg1: *mut FILE,
1843 arg2: *mut ::std::os::raw::c_char,
1844 arg3: ::std::os::raw::c_int,
1845 arg4: usize,
1846 ) -> ::std::os::raw::c_int;
1847}
1848extern "C" {
1849 pub fn setbuf(arg1: *mut FILE, arg2: *mut ::std::os::raw::c_char);
1850}
1851extern "C" {
1852 pub fn tmpnam(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1853}
1854extern "C" {
1855 pub fn tmpfile() -> *mut FILE;
1856}
1857extern "C" {
1858 pub fn fmemopen(
1859 arg1: *mut ::std::os::raw::c_void,
1860 arg2: usize,
1861 arg3: *const ::std::os::raw::c_char,
1862 ) -> *mut FILE;
1863}
1864extern "C" {
1865 pub fn open_memstream(arg1: *mut *mut ::std::os::raw::c_char, arg2: *mut usize) -> *mut FILE;
1866}
1867extern "C" {
1868 pub fn fdopen(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char) -> *mut FILE;
1869}
1870extern "C" {
1871 pub fn fileno(arg1: *mut FILE) -> ::std::os::raw::c_int;
1872}
1873extern "C" {
1874 pub fn fseeko(
1875 arg1: *mut FILE,
1876 arg2: off_t,
1877 arg3: ::std::os::raw::c_int,
1878 ) -> ::std::os::raw::c_int;
1879}
1880extern "C" {
1881 pub fn ftello(arg1: *mut FILE) -> off_t;
1882}
1883extern "C" {
1884 pub fn dprintf(
1885 arg1: ::std::os::raw::c_int,
1886 arg2: *const ::std::os::raw::c_char,
1887 ...
1888 ) -> ::std::os::raw::c_int;
1889}
1890extern "C" {
1891 pub fn vdprintf(
1892 arg1: ::std::os::raw::c_int,
1893 arg2: *const ::std::os::raw::c_char,
1894 arg3: __isoc_va_list,
1895 ) -> ::std::os::raw::c_int;
1896}
1897extern "C" {
1898 pub fn getc_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
1899}
1900extern "C" {
1901 pub fn getchar_unlocked() -> ::std::os::raw::c_int;
1902}
1903extern "C" {
1904 pub fn putc_unlocked(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1905}
1906extern "C" {
1907 pub fn putchar_unlocked(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1908}
1909extern "C" {
1910 pub fn getdelim(
1911 arg1: *mut *mut ::std::os::raw::c_char,
1912 arg2: *mut usize,
1913 arg3: ::std::os::raw::c_int,
1914 arg4: *mut FILE,
1915 ) -> isize;
1916}
1917extern "C" {
1918 pub fn getline(
1919 arg1: *mut *mut ::std::os::raw::c_char,
1920 arg2: *mut usize,
1921 arg3: *mut FILE,
1922 ) -> isize;
1923}
1924extern "C" {
1925 pub fn renameat(
1926 arg1: ::std::os::raw::c_int,
1927 arg2: *const ::std::os::raw::c_char,
1928 arg3: ::std::os::raw::c_int,
1929 arg4: *const ::std::os::raw::c_char,
1930 ) -> ::std::os::raw::c_int;
1931}
1932extern "C" {
1933 pub fn ctermid(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1934}
1935extern "C" {
1936 pub fn cuserid(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
1937}
1938extern "C" {
1939 pub fn setlinebuf(arg1: *mut FILE);
1940}
1941extern "C" {
1942 pub fn setbuffer(arg1: *mut FILE, arg2: *mut ::std::os::raw::c_char, arg3: usize);
1943}
1944extern "C" {
1945 pub fn fgetc_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
1946}
1947extern "C" {
1948 pub fn fputc_unlocked(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1949}
1950extern "C" {
1951 pub fn fflush_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
1952}
1953extern "C" {
1954 pub fn fread_unlocked(
1955 arg1: *mut ::std::os::raw::c_void,
1956 arg2: usize,
1957 arg3: usize,
1958 arg4: *mut FILE,
1959 ) -> usize;
1960}
1961extern "C" {
1962 pub fn fwrite_unlocked(
1963 arg1: *const ::std::os::raw::c_void,
1964 arg2: usize,
1965 arg3: usize,
1966 arg4: *mut FILE,
1967 ) -> usize;
1968}
1969extern "C" {
1970 pub fn clearerr_unlocked(arg1: *mut FILE);
1971}
1972extern "C" {
1973 pub fn feof_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
1974}
1975extern "C" {
1976 pub fn ferror_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
1977}
1978extern "C" {
1979 pub fn fileno_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
1980}
1981extern "C" {
1982 pub fn getw(arg1: *mut FILE) -> ::std::os::raw::c_int;
1983}
1984extern "C" {
1985 pub fn putw(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
1986}
1987extern "C" {
1988 pub fn fgetln(arg1: *mut FILE, arg2: *mut usize) -> *mut ::std::os::raw::c_char;
1989}
1990extern "C" {
1991 pub fn asprintf(
1992 arg1: *mut *mut ::std::os::raw::c_char,
1993 arg2: *const ::std::os::raw::c_char,
1994 ...
1995 ) -> ::std::os::raw::c_int;
1996}
1997extern "C" {
1998 pub fn vasprintf(
1999 arg1: *mut *mut ::std::os::raw::c_char,
2000 arg2: *const ::std::os::raw::c_char,
2001 arg3: __isoc_va_list,
2002 ) -> ::std::os::raw::c_int;
2003}
2004extern "C" {
2005 #[must_use]
2006 pub fn malloc(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
2007}
2008extern "C" {
2009 pub fn free(__ptr: *mut ::std::os::raw::c_void);
2010}
2011extern "C" {
2012 #[must_use]
2013 pub fn calloc(
2014 __nmemb: ::std::os::raw::c_ulong,
2015 __size: ::std::os::raw::c_ulong,
2016 ) -> *mut ::std::os::raw::c_void;
2017}
2018extern "C" {
2019 #[must_use]
2020 pub fn realloc(
2021 __ptr: *mut ::std::os::raw::c_void,
2022 __size: ::std::os::raw::c_ulong,
2023 ) -> *mut ::std::os::raw::c_void;
2024}
2025extern "C" {
2026 #[must_use]
2027 pub fn reallocarray(
2028 __ptr: *mut ::std::os::raw::c_void,
2029 __nmemb: usize,
2030 __size: usize,
2031 ) -> *mut ::std::os::raw::c_void;
2032}
2033extern "C" {
2034 pub fn abort() -> !;
2035}
2036extern "C" {
2037 pub fn qsort(
2038 arg1: *mut ::std::os::raw::c_void,
2039 arg2: usize,
2040 arg3: usize,
2041 arg4: ::std::option::Option<
2042 unsafe extern "C" fn(
2043 arg1: *const ::std::os::raw::c_void,
2044 arg2: *const ::std::os::raw::c_void,
2045 ) -> ::std::os::raw::c_int,
2046 >,
2047 );
2048}
2049extern "C" {
2050 pub fn _Exit(arg1: ::std::os::raw::c_int) -> !;
2051}
2052extern "C" {
2053 pub fn atoi(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2054}
2055extern "C" {
2056 pub fn atol(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
2057}
2058extern "C" {
2059 pub fn atoll(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong;
2060}
2061extern "C" {
2062 pub fn atof(arg1: *const ::std::os::raw::c_char) -> f64;
2063}
2064extern "C" {
2065 pub fn strtof(
2066 arg1: *const ::std::os::raw::c_char,
2067 arg2: *mut *mut ::std::os::raw::c_char,
2068 ) -> f32;
2069}
2070extern "C" {
2071 pub fn strtod(
2072 arg1: *const ::std::os::raw::c_char,
2073 arg2: *mut *mut ::std::os::raw::c_char,
2074 ) -> f64;
2075}
2076extern "C" {
2077 pub fn strtold(
2078 arg1: *const ::std::os::raw::c_char,
2079 arg2: *mut *mut ::std::os::raw::c_char,
2080 ) -> u128;
2081}
2082extern "C" {
2083 pub fn strtol(
2084 arg1: *const ::std::os::raw::c_char,
2085 arg2: *mut *mut ::std::os::raw::c_char,
2086 arg3: ::std::os::raw::c_int,
2087 ) -> ::std::os::raw::c_long;
2088}
2089extern "C" {
2090 pub fn strtoul(
2091 arg1: *const ::std::os::raw::c_char,
2092 arg2: *mut *mut ::std::os::raw::c_char,
2093 arg3: ::std::os::raw::c_int,
2094 ) -> ::std::os::raw::c_ulong;
2095}
2096extern "C" {
2097 pub fn strtoll(
2098 arg1: *const ::std::os::raw::c_char,
2099 arg2: *mut *mut ::std::os::raw::c_char,
2100 arg3: ::std::os::raw::c_int,
2101 ) -> ::std::os::raw::c_longlong;
2102}
2103extern "C" {
2104 pub fn strtoull(
2105 arg1: *const ::std::os::raw::c_char,
2106 arg2: *mut *mut ::std::os::raw::c_char,
2107 arg3: ::std::os::raw::c_int,
2108 ) -> ::std::os::raw::c_ulonglong;
2109}
2110extern "C" {
2111 pub fn rand() -> ::std::os::raw::c_int;
2112}
2113extern "C" {
2114 pub fn srand(arg1: ::std::os::raw::c_uint);
2115}
2116extern "C" {
2117 pub fn aligned_alloc(
2118 arg1: ::std::os::raw::c_ulong,
2119 arg2: ::std::os::raw::c_ulong,
2120 ) -> *mut ::std::os::raw::c_void;
2121}
2122extern "C" {
2123 pub fn atexit(arg1: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
2124}
2125extern "C" {
2126 pub fn exit(arg1: ::std::os::raw::c_int) -> !;
2127}
2128extern "C" {
2129 pub fn at_quick_exit(
2130 arg1: ::std::option::Option<unsafe extern "C" fn()>,
2131 ) -> ::std::os::raw::c_int;
2132}
2133extern "C" {
2134 pub fn quick_exit(arg1: ::std::os::raw::c_int) -> !;
2135}
2136extern "C" {
2137 pub fn getenv(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2138}
2139extern "C" {
2140 pub fn system(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2141}
2142extern "C" {
2143 pub fn bsearch(
2144 arg1: *const ::std::os::raw::c_void,
2145 arg2: *const ::std::os::raw::c_void,
2146 arg3: usize,
2147 arg4: usize,
2148 arg5: ::std::option::Option<
2149 unsafe extern "C" fn(
2150 arg1: *const ::std::os::raw::c_void,
2151 arg2: *const ::std::os::raw::c_void,
2152 ) -> ::std::os::raw::c_int,
2153 >,
2154 ) -> *mut ::std::os::raw::c_void;
2155}
2156extern "C" {
2157 pub fn abs(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
2158}
2159extern "C" {
2160 pub fn labs(arg1: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
2161}
2162extern "C" {
2163 pub fn llabs(arg1: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong;
2164}
2165#[repr(C)]
2166#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2167pub struct div_t {
2168 pub quot: ::std::os::raw::c_int,
2169 pub rem: ::std::os::raw::c_int,
2170}
2171#[repr(C)]
2172#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2173pub struct ldiv_t {
2174 pub quot: ::std::os::raw::c_long,
2175 pub rem: ::std::os::raw::c_long,
2176}
2177#[repr(C)]
2178#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2179pub struct lldiv_t {
2180 pub quot: ::std::os::raw::c_longlong,
2181 pub rem: ::std::os::raw::c_longlong,
2182}
2183extern "C" {
2184 pub fn div(arg1: ::std::os::raw::c_int, arg2: ::std::os::raw::c_int) -> div_t;
2185}
2186extern "C" {
2187 pub fn ldiv(arg1: ::std::os::raw::c_long, arg2: ::std::os::raw::c_long) -> ldiv_t;
2188}
2189extern "C" {
2190 pub fn lldiv(arg1: ::std::os::raw::c_longlong, arg2: ::std::os::raw::c_longlong) -> lldiv_t;
2191}
2192extern "C" {
2193 pub fn mblen(arg1: *const ::std::os::raw::c_char, arg2: usize) -> ::std::os::raw::c_int;
2194}
2195extern "C" {
2196 pub fn mbtowc(
2197 arg1: *mut wchar_t,
2198 arg2: *const ::std::os::raw::c_char,
2199 arg3: usize,
2200 ) -> ::std::os::raw::c_int;
2201}
2202extern "C" {
2203 pub fn wctomb(arg1: *mut ::std::os::raw::c_char, arg2: wchar_t) -> ::std::os::raw::c_int;
2204}
2205extern "C" {
2206 pub fn mbstowcs(arg1: *mut wchar_t, arg2: *const ::std::os::raw::c_char, arg3: usize) -> usize;
2207}
2208extern "C" {
2209 pub fn wcstombs(arg1: *mut ::std::os::raw::c_char, arg2: *const wchar_t, arg3: usize) -> usize;
2210}
2211extern "C" {
2212 pub fn __ctype_get_mb_cur_max() -> usize;
2213}
2214extern "C" {
2215 pub fn posix_memalign(
2216 arg1: *mut *mut ::std::os::raw::c_void,
2217 arg2: usize,
2218 arg3: usize,
2219 ) -> ::std::os::raw::c_int;
2220}
2221extern "C" {
2222 pub fn setenv(
2223 arg1: *const ::std::os::raw::c_char,
2224 arg2: *const ::std::os::raw::c_char,
2225 arg3: ::std::os::raw::c_int,
2226 ) -> ::std::os::raw::c_int;
2227}
2228extern "C" {
2229 pub fn unsetenv(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2230}
2231extern "C" {
2232 pub fn getsubopt(
2233 arg1: *mut *mut ::std::os::raw::c_char,
2234 arg2: *const *mut ::std::os::raw::c_char,
2235 arg3: *mut *mut ::std::os::raw::c_char,
2236 ) -> ::std::os::raw::c_int;
2237}
2238extern "C" {
2239 pub fn rand_r(arg1: *mut ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
2240}
2241extern "C" {
2242 pub fn random() -> ::std::os::raw::c_long;
2243}
2244extern "C" {
2245 pub fn srandom(arg1: ::std::os::raw::c_uint);
2246}
2247extern "C" {
2248 pub fn initstate(
2249 arg1: ::std::os::raw::c_uint,
2250 arg2: *mut ::std::os::raw::c_char,
2251 arg3: usize,
2252 ) -> *mut ::std::os::raw::c_char;
2253}
2254extern "C" {
2255 pub fn setstate(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2256}
2257extern "C" {
2258 pub fn putenv(arg1: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2259}
2260extern "C" {
2261 pub fn l64a(arg1: ::std::os::raw::c_long) -> *mut ::std::os::raw::c_char;
2262}
2263extern "C" {
2264 pub fn a64l(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
2265}
2266extern "C" {
2267 pub fn setkey(arg1: *const ::std::os::raw::c_char);
2268}
2269extern "C" {
2270 pub fn drand48() -> f64;
2271}
2272extern "C" {
2273 pub fn erand48(arg1: *mut ::std::os::raw::c_ushort) -> f64;
2274}
2275extern "C" {
2276 pub fn lrand48() -> ::std::os::raw::c_long;
2277}
2278extern "C" {
2279 pub fn nrand48(arg1: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
2280}
2281extern "C" {
2282 pub fn mrand48() -> ::std::os::raw::c_long;
2283}
2284extern "C" {
2285 pub fn jrand48(arg1: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
2286}
2287extern "C" {
2288 pub fn srand48(arg1: ::std::os::raw::c_long);
2289}
2290extern "C" {
2291 pub fn seed48(arg1: *mut ::std::os::raw::c_ushort) -> *mut ::std::os::raw::c_ushort;
2292}
2293extern "C" {
2294 pub fn lcong48(arg1: *mut ::std::os::raw::c_ushort);
2295}
2296extern "C" {
2297 pub fn alloca(arg1: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
2298}
2299extern "C" {
2300 pub fn clearenv() -> ::std::os::raw::c_int;
2301}
2302extern "C" {
2303 pub fn arc4random() -> u32;
2304}
2305extern "C" {
2306 pub fn arc4random_buf(arg1: *mut ::std::os::raw::c_void, arg2: usize);
2307}
2308extern "C" {
2309 pub fn arc4random_uniform(arg1: u32) -> u32;
2310}
2311extern "C" {
2312 pub fn memcpy(
2313 __dst: *mut ::std::os::raw::c_void,
2314 __src: *const ::std::os::raw::c_void,
2315 __n: ::std::os::raw::c_ulong,
2316 ) -> *mut ::std::os::raw::c_void;
2317}
2318extern "C" {
2319 pub fn memmove(
2320 __dst: *mut ::std::os::raw::c_void,
2321 __src: *const ::std::os::raw::c_void,
2322 __n: ::std::os::raw::c_ulong,
2323 ) -> *mut ::std::os::raw::c_void;
2324}
2325extern "C" {
2326 pub fn memset(
2327 __dst: *mut ::std::os::raw::c_void,
2328 __c: ::std::os::raw::c_int,
2329 __n: ::std::os::raw::c_ulong,
2330 ) -> *mut ::std::os::raw::c_void;
2331}
2332extern "C" {
2333 pub fn strlen(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulong;
2334}
2335extern "C" {
2336 pub fn strdup(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2337}
2338extern "C" {
2339 pub fn strcmp(
2340 arg1: *const ::std::os::raw::c_char,
2341 arg2: *const ::std::os::raw::c_char,
2342 ) -> ::std::os::raw::c_int;
2343}
2344extern "C" {
2345 pub fn memchr(
2346 arg1: *const ::std::os::raw::c_void,
2347 arg2: ::std::os::raw::c_int,
2348 arg3: ::std::os::raw::c_ulong,
2349 ) -> *mut ::std::os::raw::c_void;
2350}
2351#[repr(C)]
2352#[derive(Debug, Copy, Clone)]
2353pub struct __locale_struct {
2354 _unused: [u8; 0],
2355}
2356pub type locale_t = *mut __locale_struct;
2357extern "C" {
2358 pub fn memcmp(
2359 arg1: *const ::std::os::raw::c_void,
2360 arg2: *const ::std::os::raw::c_void,
2361 arg3: ::std::os::raw::c_ulong,
2362 ) -> ::std::os::raw::c_int;
2363}
2364extern "C" {
2365 pub fn strcpy(
2366 arg1: *mut ::std::os::raw::c_char,
2367 arg2: *const ::std::os::raw::c_char,
2368 ) -> *mut ::std::os::raw::c_char;
2369}
2370extern "C" {
2371 pub fn strncpy(
2372 arg1: *mut ::std::os::raw::c_char,
2373 arg2: *const ::std::os::raw::c_char,
2374 arg3: ::std::os::raw::c_ulong,
2375 ) -> *mut ::std::os::raw::c_char;
2376}
2377extern "C" {
2378 pub fn strcat(
2379 arg1: *mut ::std::os::raw::c_char,
2380 arg2: *const ::std::os::raw::c_char,
2381 ) -> *mut ::std::os::raw::c_char;
2382}
2383extern "C" {
2384 pub fn strncat(
2385 arg1: *mut ::std::os::raw::c_char,
2386 arg2: *const ::std::os::raw::c_char,
2387 arg3: ::std::os::raw::c_ulong,
2388 ) -> *mut ::std::os::raw::c_char;
2389}
2390extern "C" {
2391 pub fn strncmp(
2392 arg1: *const ::std::os::raw::c_char,
2393 arg2: *const ::std::os::raw::c_char,
2394 arg3: ::std::os::raw::c_ulong,
2395 ) -> ::std::os::raw::c_int;
2396}
2397extern "C" {
2398 pub fn strcoll(
2399 arg1: *const ::std::os::raw::c_char,
2400 arg2: *const ::std::os::raw::c_char,
2401 ) -> ::std::os::raw::c_int;
2402}
2403extern "C" {
2404 pub fn strxfrm(
2405 arg1: *mut ::std::os::raw::c_char,
2406 arg2: *const ::std::os::raw::c_char,
2407 arg3: ::std::os::raw::c_ulong,
2408 ) -> ::std::os::raw::c_ulong;
2409}
2410extern "C" {
2411 pub fn strchr(
2412 arg1: *const ::std::os::raw::c_char,
2413 arg2: ::std::os::raw::c_int,
2414 ) -> *mut ::std::os::raw::c_char;
2415}
2416extern "C" {
2417 pub fn strrchr(
2418 arg1: *const ::std::os::raw::c_char,
2419 arg2: ::std::os::raw::c_int,
2420 ) -> *mut ::std::os::raw::c_char;
2421}
2422extern "C" {
2423 pub fn strcspn(
2424 arg1: *const ::std::os::raw::c_char,
2425 arg2: *const ::std::os::raw::c_char,
2426 ) -> ::std::os::raw::c_ulong;
2427}
2428extern "C" {
2429 pub fn strspn(
2430 arg1: *const ::std::os::raw::c_char,
2431 arg2: *const ::std::os::raw::c_char,
2432 ) -> ::std::os::raw::c_ulong;
2433}
2434extern "C" {
2435 pub fn strpbrk(
2436 arg1: *const ::std::os::raw::c_char,
2437 arg2: *const ::std::os::raw::c_char,
2438 ) -> *mut ::std::os::raw::c_char;
2439}
2440extern "C" {
2441 pub fn strstr(
2442 arg1: *const ::std::os::raw::c_char,
2443 arg2: *const ::std::os::raw::c_char,
2444 ) -> *mut ::std::os::raw::c_char;
2445}
2446extern "C" {
2447 pub fn strtok(
2448 arg1: *mut ::std::os::raw::c_char,
2449 arg2: *const ::std::os::raw::c_char,
2450 ) -> *mut ::std::os::raw::c_char;
2451}
2452extern "C" {
2453 pub fn strerror(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
2454}
2455extern "C" {
2456 pub fn bcmp(
2457 arg1: *const ::std::os::raw::c_void,
2458 arg2: *const ::std::os::raw::c_void,
2459 arg3: ::std::os::raw::c_ulong,
2460 ) -> ::std::os::raw::c_int;
2461}
2462extern "C" {
2463 pub fn bcopy(
2464 arg1: *const ::std::os::raw::c_void,
2465 arg2: *mut ::std::os::raw::c_void,
2466 arg3: usize,
2467 );
2468}
2469extern "C" {
2470 pub fn bzero(arg1: *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_ulong);
2471}
2472extern "C" {
2473 pub fn index(
2474 arg1: *const ::std::os::raw::c_char,
2475 arg2: ::std::os::raw::c_int,
2476 ) -> *mut ::std::os::raw::c_char;
2477}
2478extern "C" {
2479 pub fn rindex(
2480 arg1: *const ::std::os::raw::c_char,
2481 arg2: ::std::os::raw::c_int,
2482 ) -> *mut ::std::os::raw::c_char;
2483}
2484extern "C" {
2485 pub fn ffs(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
2486}
2487extern "C" {
2488 pub fn ffsl(arg1: ::std::os::raw::c_long) -> ::std::os::raw::c_int;
2489}
2490extern "C" {
2491 pub fn ffsll(arg1: ::std::os::raw::c_longlong) -> ::std::os::raw::c_int;
2492}
2493extern "C" {
2494 pub fn strcasecmp(
2495 arg1: *const ::std::os::raw::c_char,
2496 arg2: *const ::std::os::raw::c_char,
2497 ) -> ::std::os::raw::c_int;
2498}
2499extern "C" {
2500 pub fn strncasecmp(
2501 arg1: *const ::std::os::raw::c_char,
2502 arg2: *const ::std::os::raw::c_char,
2503 arg3: ::std::os::raw::c_ulong,
2504 ) -> ::std::os::raw::c_int;
2505}
2506extern "C" {
2507 pub fn strcasecmp_l(
2508 arg1: *const ::std::os::raw::c_char,
2509 arg2: *const ::std::os::raw::c_char,
2510 arg3: locale_t,
2511 ) -> ::std::os::raw::c_int;
2512}
2513extern "C" {
2514 pub fn strncasecmp_l(
2515 arg1: *const ::std::os::raw::c_char,
2516 arg2: *const ::std::os::raw::c_char,
2517 arg3: usize,
2518 arg4: locale_t,
2519 ) -> ::std::os::raw::c_int;
2520}
2521extern "C" {
2522 pub fn strtok_r(
2523 arg1: *mut ::std::os::raw::c_char,
2524 arg2: *const ::std::os::raw::c_char,
2525 arg3: *mut *mut ::std::os::raw::c_char,
2526 ) -> *mut ::std::os::raw::c_char;
2527}
2528extern "C" {
2529 pub fn strerror_r(
2530 arg1: ::std::os::raw::c_int,
2531 arg2: *mut ::std::os::raw::c_char,
2532 arg3: usize,
2533 ) -> ::std::os::raw::c_int;
2534}
2535extern "C" {
2536 pub fn stpcpy(
2537 arg1: *mut ::std::os::raw::c_char,
2538 arg2: *const ::std::os::raw::c_char,
2539 ) -> *mut ::std::os::raw::c_char;
2540}
2541extern "C" {
2542 pub fn stpncpy(
2543 arg1: *mut ::std::os::raw::c_char,
2544 arg2: *const ::std::os::raw::c_char,
2545 arg3: ::std::os::raw::c_ulong,
2546 ) -> *mut ::std::os::raw::c_char;
2547}
2548extern "C" {
2549 pub fn strnlen(arg1: *const ::std::os::raw::c_char, arg2: usize) -> usize;
2550}
2551extern "C" {
2552 pub fn strndup(
2553 arg1: *const ::std::os::raw::c_char,
2554 arg2: ::std::os::raw::c_ulong,
2555 ) -> *mut ::std::os::raw::c_char;
2556}
2557extern "C" {
2558 pub fn strsignal(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
2559}
2560extern "C" {
2561 pub fn strerror_l(arg1: ::std::os::raw::c_int, arg2: locale_t) -> *mut ::std::os::raw::c_char;
2562}
2563extern "C" {
2564 pub fn strcoll_l(
2565 arg1: *const ::std::os::raw::c_char,
2566 arg2: *const ::std::os::raw::c_char,
2567 arg3: locale_t,
2568 ) -> ::std::os::raw::c_int;
2569}
2570extern "C" {
2571 pub fn strxfrm_l(
2572 arg1: *mut ::std::os::raw::c_char,
2573 arg2: *const ::std::os::raw::c_char,
2574 arg3: usize,
2575 arg4: locale_t,
2576 ) -> usize;
2577}
2578extern "C" {
2579 pub fn memccpy(
2580 arg1: *mut ::std::os::raw::c_void,
2581 arg2: *const ::std::os::raw::c_void,
2582 arg3: ::std::os::raw::c_int,
2583 arg4: ::std::os::raw::c_ulong,
2584 ) -> *mut ::std::os::raw::c_void;
2585}
2586extern "C" {
2587 pub fn strsep(
2588 arg1: *mut *mut ::std::os::raw::c_char,
2589 arg2: *const ::std::os::raw::c_char,
2590 ) -> *mut ::std::os::raw::c_char;
2591}
2592extern "C" {
2593 pub fn strlcat(
2594 arg1: *mut ::std::os::raw::c_char,
2595 arg2: *const ::std::os::raw::c_char,
2596 arg3: ::std::os::raw::c_ulong,
2597 ) -> ::std::os::raw::c_ulong;
2598}
2599extern "C" {
2600 pub fn strlcpy(
2601 arg1: *mut ::std::os::raw::c_char,
2602 arg2: *const ::std::os::raw::c_char,
2603 arg3: ::std::os::raw::c_ulong,
2604 ) -> ::std::os::raw::c_ulong;
2605}
2606extern "C" {
2607 pub fn explicit_bzero(arg1: *mut ::std::os::raw::c_void, arg2: usize);
2608}
2609extern "C" {
2610 #[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"]
2611 pub fn av_strerror(
2612 errnum: ::std::os::raw::c_int,
2613 errbuf: *mut ::std::os::raw::c_char,
2614 errbuf_size: usize,
2615 ) -> ::std::os::raw::c_int;
2616}
2617extern "C" {
2618 #[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()"]
2619 pub fn av_malloc(size: usize) -> *mut ::std::os::raw::c_void;
2620}
2621extern "C" {
2622 #[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()"]
2623 pub fn av_mallocz(size: usize) -> *mut ::std::os::raw::c_void;
2624}
2625extern "C" {
2626 #[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()"]
2627 pub fn av_malloc_array(nmemb: usize, size: usize) -> *mut ::std::os::raw::c_void;
2628}
2629extern "C" {
2630 #[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()"]
2631 pub fn av_calloc(nmemb: usize, size: usize) -> *mut ::std::os::raw::c_void;
2632}
2633extern "C" {
2634 #[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()"]
2635 pub fn av_realloc(ptr: *mut ::std::os::raw::c_void, size: usize)
2636 -> *mut ::std::os::raw::c_void;
2637}
2638extern "C" {
2639 #[must_use]
2640 #[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."]
2641 pub fn av_reallocp(ptr: *mut ::std::os::raw::c_void, size: usize) -> ::std::os::raw::c_int;
2642}
2643extern "C" {
2644 #[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."]
2645 pub fn av_realloc_f(
2646 ptr: *mut ::std::os::raw::c_void,
2647 nelem: usize,
2648 elsize: usize,
2649 ) -> *mut ::std::os::raw::c_void;
2650}
2651extern "C" {
2652 #[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()"]
2653 pub fn av_realloc_array(
2654 ptr: *mut ::std::os::raw::c_void,
2655 nmemb: usize,
2656 size: usize,
2657 ) -> *mut ::std::os::raw::c_void;
2658}
2659extern "C" {
2660 #[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."]
2661 pub fn av_reallocp_array(
2662 ptr: *mut ::std::os::raw::c_void,
2663 nmemb: usize,
2664 size: usize,
2665 ) -> ::std::os::raw::c_int;
2666}
2667extern "C" {
2668 #[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()"]
2669 pub fn av_fast_realloc(
2670 ptr: *mut ::std::os::raw::c_void,
2671 size: *mut ::std::os::raw::c_uint,
2672 min_size: usize,
2673 ) -> *mut ::std::os::raw::c_void;
2674}
2675extern "C" {
2676 #[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()"]
2677 pub fn av_fast_malloc(
2678 ptr: *mut ::std::os::raw::c_void,
2679 size: *mut ::std::os::raw::c_uint,
2680 min_size: usize,
2681 );
2682}
2683extern "C" {
2684 #[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()"]
2685 pub fn av_fast_mallocz(
2686 ptr: *mut ::std::os::raw::c_void,
2687 size: *mut ::std::os::raw::c_uint,
2688 min_size: usize,
2689 );
2690}
2691extern "C" {
2692 #[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()"]
2693 pub fn av_free(ptr: *mut ::std::os::raw::c_void);
2694}
2695extern "C" {
2696 #[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()"]
2697 pub fn av_freep(ptr: *mut ::std::os::raw::c_void);
2698}
2699extern "C" {
2700 #[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()"]
2701 pub fn av_strdup(s: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2702}
2703extern "C" {
2704 #[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"]
2705 pub fn av_strndup(s: *const ::std::os::raw::c_char, len: usize) -> *mut ::std::os::raw::c_char;
2706}
2707extern "C" {
2708 #[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"]
2709 pub fn av_memdup(p: *const ::std::os::raw::c_void, size: usize) -> *mut ::std::os::raw::c_void;
2710}
2711extern "C" {
2712 #[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`."]
2713 pub fn av_memcpy_backptr(dst: *mut u8, back: ::std::os::raw::c_int, cnt: ::std::os::raw::c_int);
2714}
2715extern "C" {
2716 #[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()"]
2717 pub fn av_dynarray_add(
2718 tab_ptr: *mut ::std::os::raw::c_void,
2719 nb_ptr: *mut ::std::os::raw::c_int,
2720 elem: *mut ::std::os::raw::c_void,
2721 );
2722}
2723extern "C" {
2724 #[must_use]
2725 #[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()"]
2726 pub fn av_dynarray_add_nofree(
2727 tab_ptr: *mut ::std::os::raw::c_void,
2728 nb_ptr: *mut ::std::os::raw::c_int,
2729 elem: *mut ::std::os::raw::c_void,
2730 ) -> ::std::os::raw::c_int;
2731}
2732extern "C" {
2733 #[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()"]
2734 pub fn av_dynarray2_add(
2735 tab_ptr: *mut *mut ::std::os::raw::c_void,
2736 nb_ptr: *mut ::std::os::raw::c_int,
2737 elem_size: usize,
2738 elem_data: *const u8,
2739 ) -> *mut ::std::os::raw::c_void;
2740}
2741extern "C" {
2742 #[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"]
2743 pub fn av_size_mult(a: usize, b: usize, r: *mut usize) -> ::std::os::raw::c_int;
2744}
2745extern "C" {
2746 #[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."]
2747 pub fn av_max_alloc(max: usize);
2748}
2749extern "C" {
2750 pub fn av_log2(v: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
2751}
2752extern "C" {
2753 pub fn av_log2_16bit(v: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
2754}
2755#[doc = " Rational number (pair of numerator and denominator)."]
2756#[repr(C)]
2757#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2758pub struct AVRational {
2759 #[doc = "< Numerator"]
2760 pub num: ::std::os::raw::c_int,
2761 #[doc = "< Denominator"]
2762 pub den: ::std::os::raw::c_int,
2763}
2764extern "C" {
2765 #[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"]
2766 pub fn av_reduce(
2767 dst_num: *mut ::std::os::raw::c_int,
2768 dst_den: *mut ::std::os::raw::c_int,
2769 num: i64,
2770 den: i64,
2771 max: i64,
2772 ) -> ::std::os::raw::c_int;
2773}
2774extern "C" {
2775 #[doc = " Multiply two rationals.\n @param b First rational\n @param c Second rational\n @return b*c"]
2776 pub fn av_mul_q(b: AVRational, c: AVRational) -> AVRational;
2777}
2778extern "C" {
2779 #[doc = " Divide one rational by another.\n @param b First rational\n @param c Second rational\n @return b/c"]
2780 pub fn av_div_q(b: AVRational, c: AVRational) -> AVRational;
2781}
2782extern "C" {
2783 #[doc = " Add two rationals.\n @param b First rational\n @param c Second rational\n @return b+c"]
2784 pub fn av_add_q(b: AVRational, c: AVRational) -> AVRational;
2785}
2786extern "C" {
2787 #[doc = " Subtract one rational from another.\n @param b First rational\n @param c Second rational\n @return b-c"]
2788 pub fn av_sub_q(b: AVRational, c: AVRational) -> AVRational;
2789}
2790extern "C" {
2791 #[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()"]
2792 pub fn av_d2q(d: f64, max: ::std::os::raw::c_int) -> AVRational;
2793}
2794extern "C" {
2795 #[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"]
2796 pub fn av_nearer_q(q: AVRational, q1: AVRational, q2: AVRational) -> ::std::os::raw::c_int;
2797}
2798extern "C" {
2799 #[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"]
2800 pub fn av_find_nearest_q_idx(q: AVRational, q_list: *const AVRational)
2801 -> ::std::os::raw::c_int;
2802}
2803extern "C" {
2804 #[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."]
2805 pub fn av_q2intfloat(q: AVRational) -> u32;
2806}
2807extern "C" {
2808 #[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."]
2809 pub fn av_gcd_q(
2810 a: AVRational,
2811 b: AVRational,
2812 max_den: ::std::os::raw::c_int,
2813 def: AVRational,
2814 ) -> AVRational;
2815}
2816#[repr(C)]
2817#[derive(Copy, Clone)]
2818pub union av_intfloat32 {
2819 pub i: u32,
2820 pub f: f32,
2821}
2822impl Default for av_intfloat32 {
2823 fn default() -> Self {
2824 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2825 unsafe {
2826 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2827 s.assume_init()
2828 }
2829 }
2830}
2831#[repr(C)]
2832#[derive(Copy, Clone)]
2833pub union av_intfloat64 {
2834 pub i: u64,
2835 pub f: f64,
2836}
2837impl Default for av_intfloat64 {
2838 fn default() -> Self {
2839 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2840 unsafe {
2841 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2842 s.assume_init()
2843 }
2844 }
2845}
2846#[doc = "< Round toward zero."]
2847pub const AVRounding_AV_ROUND_ZERO: AVRounding = 0;
2848#[doc = "< Round away from zero."]
2849pub const AVRounding_AV_ROUND_INF: AVRounding = 1;
2850#[doc = "< Round toward -infinity."]
2851pub const AVRounding_AV_ROUND_DOWN: AVRounding = 2;
2852#[doc = "< Round toward +infinity."]
2853pub const AVRounding_AV_ROUND_UP: AVRounding = 3;
2854#[doc = "< Round to nearest and halfway cases away from zero."]
2855pub const AVRounding_AV_ROUND_NEAR_INF: AVRounding = 5;
2856#[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"]
2857pub const AVRounding_AV_ROUND_PASS_MINMAX: AVRounding = 8192;
2858#[doc = " Rounding methods."]
2859pub type AVRounding = ::std::os::raw::c_uint;
2860extern "C" {
2861 #[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."]
2862 pub fn av_gcd(a: i64, b: i64) -> i64;
2863}
2864extern "C" {
2865 #[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()"]
2866 pub fn av_rescale(a: i64, b: i64, c: i64) -> i64;
2867}
2868extern "C" {
2869 #[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()"]
2870 pub fn av_rescale_rnd(a: i64, b: i64, c: i64, rnd: AVRounding) -> i64;
2871}
2872extern "C" {
2873 #[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()"]
2874 pub fn av_rescale_q(a: i64, bq: AVRational, cq: AVRational) -> i64;
2875}
2876extern "C" {
2877 #[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()"]
2878 pub fn av_rescale_q_rnd(a: i64, bq: AVRational, cq: AVRational, rnd: AVRounding) -> i64;
2879}
2880extern "C" {
2881 #[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."]
2882 pub fn av_compare_ts(
2883 ts_a: i64,
2884 tb_a: AVRational,
2885 ts_b: i64,
2886 tb_b: AVRational,
2887 ) -> ::std::os::raw::c_int;
2888}
2889extern "C" {
2890 #[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`"]
2891 pub fn av_compare_mod(a: u64, b: u64, mod_: u64) -> i64;
2892}
2893extern "C" {
2894 #[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."]
2895 pub fn av_rescale_delta(
2896 in_tb: AVRational,
2897 in_ts: i64,
2898 fs_tb: AVRational,
2899 duration: ::std::os::raw::c_int,
2900 last: *mut i64,
2901 out_tb: AVRational,
2902 ) -> i64;
2903}
2904extern "C" {
2905 #[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`"]
2906 pub fn av_add_stable(ts_tb: AVRational, ts: i64, inc_tb: AVRational, inc: i64) -> i64;
2907}
2908extern "C" {
2909 #[doc = " 0th order modified bessel function of the first kind."]
2910 pub fn av_bessel_i0(x: f64) -> f64;
2911}
2912pub type __gnuc_va_list = __builtin_va_list;
2913pub const AVClassCategory_AV_CLASS_CATEGORY_NA: AVClassCategory = 0;
2914pub const AVClassCategory_AV_CLASS_CATEGORY_INPUT: AVClassCategory = 1;
2915pub const AVClassCategory_AV_CLASS_CATEGORY_OUTPUT: AVClassCategory = 2;
2916pub const AVClassCategory_AV_CLASS_CATEGORY_MUXER: AVClassCategory = 3;
2917pub const AVClassCategory_AV_CLASS_CATEGORY_DEMUXER: AVClassCategory = 4;
2918pub const AVClassCategory_AV_CLASS_CATEGORY_ENCODER: AVClassCategory = 5;
2919pub const AVClassCategory_AV_CLASS_CATEGORY_DECODER: AVClassCategory = 6;
2920pub const AVClassCategory_AV_CLASS_CATEGORY_FILTER: AVClassCategory = 7;
2921pub const AVClassCategory_AV_CLASS_CATEGORY_BITSTREAM_FILTER: AVClassCategory = 8;
2922pub const AVClassCategory_AV_CLASS_CATEGORY_SWSCALER: AVClassCategory = 9;
2923pub const AVClassCategory_AV_CLASS_CATEGORY_SWRESAMPLER: AVClassCategory = 10;
2924pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT: AVClassCategory = 40;
2925pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT: AVClassCategory = 41;
2926pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT: AVClassCategory = 42;
2927pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT: AVClassCategory = 43;
2928pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_OUTPUT: AVClassCategory = 44;
2929pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_INPUT: AVClassCategory = 45;
2930#[doc = "< not part of ABI/API"]
2931pub const AVClassCategory_AV_CLASS_CATEGORY_NB: AVClassCategory = 46;
2932pub type AVClassCategory = ::std::os::raw::c_uint;
2933#[repr(C)]
2934#[derive(Debug, Copy, Clone)]
2935pub struct AVOptionRanges {
2936 _unused: [u8; 0],
2937}
2938#[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.)."]
2939#[repr(C)]
2940#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2941pub struct AVClass {
2942 #[doc = " The name of the class; usually it is the same name as the\n context structure type to which the AVClass is associated."]
2943 pub class_name: *const ::std::os::raw::c_char,
2944 #[doc = " A pointer to a function which returns the name of a context\n instance ctx associated with the class."]
2945 pub item_name: ::std::option::Option<
2946 unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void) -> *const ::std::os::raw::c_char,
2947 >,
2948 #[doc = " a pointer to the first option specified in the class if any or NULL\n\n @see av_set_default_options()"]
2949 pub option: *mut AVOption,
2950 #[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."]
2951 pub version: ::std::os::raw::c_int,
2952 #[doc = " Offset in the structure where log_level_offset is stored.\n 0 means there is no such variable"]
2953 pub log_level_offset_offset: ::std::os::raw::c_int,
2954 #[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."]
2955 pub parent_log_context_offset: ::std::os::raw::c_int,
2956 #[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)"]
2957 pub category: AVClassCategory,
2958 #[doc = " Callback to return the category.\n available since version (51 << 16 | 59 << 8 | 100)"]
2959 pub get_category: ::std::option::Option<
2960 unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void) -> AVClassCategory,
2961 >,
2962 #[doc = " Callback to return the supported/allowed ranges.\n available since version (52.12)"]
2963 pub query_ranges: ::std::option::Option<
2964 unsafe extern "C" fn(
2965 arg1: *mut *mut AVOptionRanges,
2966 obj: *mut ::std::os::raw::c_void,
2967 key: *const ::std::os::raw::c_char,
2968 flags: ::std::os::raw::c_int,
2969 ) -> ::std::os::raw::c_int,
2970 >,
2971 #[doc = " Return next AVOptions-enabled child or NULL"]
2972 pub child_next: ::std::option::Option<
2973 unsafe extern "C" fn(
2974 obj: *mut ::std::os::raw::c_void,
2975 prev: *mut ::std::os::raw::c_void,
2976 ) -> *mut ::std::os::raw::c_void,
2977 >,
2978 #[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."]
2979 pub child_class_iterate: ::std::option::Option<
2980 unsafe extern "C" fn(iter: *mut *mut ::std::os::raw::c_void) -> *const AVClass,
2981 >,
2982}
2983impl Default for AVClass {
2984 fn default() -> Self {
2985 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2986 unsafe {
2987 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2988 s.assume_init()
2989 }
2990 }
2991}
2992extern "C" {
2993 #[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."]
2994 pub fn av_log(
2995 avcl: *mut ::std::os::raw::c_void,
2996 level: ::std::os::raw::c_int,
2997 fmt: *const ::std::os::raw::c_char,
2998 ...
2999 );
3000}
3001extern "C" {
3002 #[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."]
3003 pub fn av_log_once(
3004 avcl: *mut ::std::os::raw::c_void,
3005 initial_level: ::std::os::raw::c_int,
3006 subsequent_level: ::std::os::raw::c_int,
3007 state: *mut ::std::os::raw::c_int,
3008 fmt: *const ::std::os::raw::c_char,
3009 ...
3010 );
3011}
3012extern "C" {
3013 #[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."]
3014 pub fn av_vlog(
3015 avcl: *mut ::std::os::raw::c_void,
3016 level: ::std::os::raw::c_int,
3017 fmt: *const ::std::os::raw::c_char,
3018 vl: va_list,
3019 );
3020}
3021extern "C" {
3022 #[doc = " Get the current log level\n\n @see lavu_log_constants\n\n @return Current log level"]
3023 pub fn av_log_get_level() -> ::std::os::raw::c_int;
3024}
3025extern "C" {
3026 #[doc = " Set the log level\n\n @see lavu_log_constants\n\n @param level Logging level"]
3027 pub fn av_log_set_level(level: ::std::os::raw::c_int);
3028}
3029extern "C" {
3030 #[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."]
3031 pub fn av_log_set_callback(
3032 callback: ::std::option::Option<
3033 unsafe extern "C" fn(
3034 arg1: *mut ::std::os::raw::c_void,
3035 arg2: ::std::os::raw::c_int,
3036 arg3: *const ::std::os::raw::c_char,
3037 arg4: va_list,
3038 ),
3039 >,
3040 );
3041}
3042extern "C" {
3043 #[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."]
3044 pub fn av_log_default_callback(
3045 avcl: *mut ::std::os::raw::c_void,
3046 level: ::std::os::raw::c_int,
3047 fmt: *const ::std::os::raw::c_char,
3048 vl: va_list,
3049 );
3050}
3051extern "C" {
3052 #[doc = " Return the context name\n\n @param ctx The AVClass context\n\n @return The AVClass class_name"]
3053 pub fn av_default_item_name(ctx: *mut ::std::os::raw::c_void) -> *const ::std::os::raw::c_char;
3054}
3055extern "C" {
3056 pub fn av_default_get_category(ptr: *mut ::std::os::raw::c_void) -> AVClassCategory;
3057}
3058extern "C" {
3059 #[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"]
3060 pub fn av_log_format_line(
3061 ptr: *mut ::std::os::raw::c_void,
3062 level: ::std::os::raw::c_int,
3063 fmt: *const ::std::os::raw::c_char,
3064 vl: va_list,
3065 line: *mut ::std::os::raw::c_char,
3066 line_size: ::std::os::raw::c_int,
3067 print_prefix: *mut ::std::os::raw::c_int,
3068 );
3069}
3070extern "C" {
3071 #[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."]
3072 pub fn av_log_format_line2(
3073 ptr: *mut ::std::os::raw::c_void,
3074 level: ::std::os::raw::c_int,
3075 fmt: *const ::std::os::raw::c_char,
3076 vl: va_list,
3077 line: *mut ::std::os::raw::c_char,
3078 line_size: ::std::os::raw::c_int,
3079 print_prefix: *mut ::std::os::raw::c_int,
3080 ) -> ::std::os::raw::c_int;
3081}
3082extern "C" {
3083 pub fn av_log_set_flags(arg: ::std::os::raw::c_int);
3084}
3085extern "C" {
3086 pub fn av_log_get_flags() -> ::std::os::raw::c_int;
3087}
3088pub const AVPixelFormat_AV_PIX_FMT_NONE: AVPixelFormat = -1;
3089#[doc = "< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)"]
3090pub const AVPixelFormat_AV_PIX_FMT_YUV420P: AVPixelFormat = 0;
3091#[doc = "< packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr"]
3092pub const AVPixelFormat_AV_PIX_FMT_YUYV422: AVPixelFormat = 1;
3093#[doc = "< packed RGB 8:8:8, 24bpp, RGBRGB..."]
3094pub const AVPixelFormat_AV_PIX_FMT_RGB24: AVPixelFormat = 2;
3095#[doc = "< packed RGB 8:8:8, 24bpp, BGRBGR..."]
3096pub const AVPixelFormat_AV_PIX_FMT_BGR24: AVPixelFormat = 3;
3097#[doc = "< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)"]
3098pub const AVPixelFormat_AV_PIX_FMT_YUV422P: AVPixelFormat = 4;
3099#[doc = "< planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)"]
3100pub const AVPixelFormat_AV_PIX_FMT_YUV444P: AVPixelFormat = 5;
3101#[doc = "< planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)"]
3102pub const AVPixelFormat_AV_PIX_FMT_YUV410P: AVPixelFormat = 6;
3103#[doc = "< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)"]
3104pub const AVPixelFormat_AV_PIX_FMT_YUV411P: AVPixelFormat = 7;
3105#[doc = "< Y , 8bpp"]
3106pub const AVPixelFormat_AV_PIX_FMT_GRAY8: AVPixelFormat = 8;
3107#[doc = "< Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb"]
3108pub const AVPixelFormat_AV_PIX_FMT_MONOWHITE: AVPixelFormat = 9;
3109#[doc = "< Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb"]
3110pub const AVPixelFormat_AV_PIX_FMT_MONOBLACK: AVPixelFormat = 10;
3111#[doc = "< 8 bits with AV_PIX_FMT_RGB32 palette"]
3112pub const AVPixelFormat_AV_PIX_FMT_PAL8: AVPixelFormat = 11;
3113#[doc = "< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting color_range"]
3114pub const AVPixelFormat_AV_PIX_FMT_YUVJ420P: AVPixelFormat = 12;
3115#[doc = "< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting color_range"]
3116pub const AVPixelFormat_AV_PIX_FMT_YUVJ422P: AVPixelFormat = 13;
3117#[doc = "< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting color_range"]
3118pub const AVPixelFormat_AV_PIX_FMT_YUVJ444P: AVPixelFormat = 14;
3119#[doc = "< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1"]
3120pub const AVPixelFormat_AV_PIX_FMT_UYVY422: AVPixelFormat = 15;
3121#[doc = "< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3"]
3122pub const AVPixelFormat_AV_PIX_FMT_UYYVYY411: AVPixelFormat = 16;
3123#[doc = "< packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)"]
3124pub const AVPixelFormat_AV_PIX_FMT_BGR8: AVPixelFormat = 17;
3125#[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"]
3126pub const AVPixelFormat_AV_PIX_FMT_BGR4: AVPixelFormat = 18;
3127#[doc = "< packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)"]
3128pub const AVPixelFormat_AV_PIX_FMT_BGR4_BYTE: AVPixelFormat = 19;
3129#[doc = "< packed RGB 3:3:2, 8bpp, (msb)3R 3G 2B(lsb)"]
3130pub const AVPixelFormat_AV_PIX_FMT_RGB8: AVPixelFormat = 20;
3131#[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"]
3132pub const AVPixelFormat_AV_PIX_FMT_RGB4: AVPixelFormat = 21;
3133#[doc = "< packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)"]
3134pub const AVPixelFormat_AV_PIX_FMT_RGB4_BYTE: AVPixelFormat = 22;
3135#[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)"]
3136pub const AVPixelFormat_AV_PIX_FMT_NV12: AVPixelFormat = 23;
3137#[doc = "< as above, but U and V bytes are swapped"]
3138pub const AVPixelFormat_AV_PIX_FMT_NV21: AVPixelFormat = 24;
3139#[doc = "< packed ARGB 8:8:8:8, 32bpp, ARGBARGB..."]
3140pub const AVPixelFormat_AV_PIX_FMT_ARGB: AVPixelFormat = 25;
3141#[doc = "< packed RGBA 8:8:8:8, 32bpp, RGBARGBA..."]
3142pub const AVPixelFormat_AV_PIX_FMT_RGBA: AVPixelFormat = 26;
3143#[doc = "< packed ABGR 8:8:8:8, 32bpp, ABGRABGR..."]
3144pub const AVPixelFormat_AV_PIX_FMT_ABGR: AVPixelFormat = 27;
3145#[doc = "< packed BGRA 8:8:8:8, 32bpp, BGRABGRA..."]
3146pub const AVPixelFormat_AV_PIX_FMT_BGRA: AVPixelFormat = 28;
3147#[doc = "< Y , 16bpp, big-endian"]
3148pub const AVPixelFormat_AV_PIX_FMT_GRAY16BE: AVPixelFormat = 29;
3149#[doc = "< Y , 16bpp, little-endian"]
3150pub const AVPixelFormat_AV_PIX_FMT_GRAY16LE: AVPixelFormat = 30;
3151#[doc = "< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)"]
3152pub const AVPixelFormat_AV_PIX_FMT_YUV440P: AVPixelFormat = 31;
3153#[doc = "< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range"]
3154pub const AVPixelFormat_AV_PIX_FMT_YUVJ440P: AVPixelFormat = 32;
3155#[doc = "< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)"]
3156pub const AVPixelFormat_AV_PIX_FMT_YUVA420P: AVPixelFormat = 33;
3157#[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"]
3158pub const AVPixelFormat_AV_PIX_FMT_RGB48BE: AVPixelFormat = 34;
3159#[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"]
3160pub const AVPixelFormat_AV_PIX_FMT_RGB48LE: AVPixelFormat = 35;
3161#[doc = "< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian"]
3162pub const AVPixelFormat_AV_PIX_FMT_RGB565BE: AVPixelFormat = 36;
3163#[doc = "< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian"]
3164pub const AVPixelFormat_AV_PIX_FMT_RGB565LE: AVPixelFormat = 37;
3165#[doc = "< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined"]
3166pub const AVPixelFormat_AV_PIX_FMT_RGB555BE: AVPixelFormat = 38;
3167#[doc = "< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined"]
3168pub const AVPixelFormat_AV_PIX_FMT_RGB555LE: AVPixelFormat = 39;
3169#[doc = "< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian"]
3170pub const AVPixelFormat_AV_PIX_FMT_BGR565BE: AVPixelFormat = 40;
3171#[doc = "< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian"]
3172pub const AVPixelFormat_AV_PIX_FMT_BGR565LE: AVPixelFormat = 41;
3173#[doc = "< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined"]
3174pub const AVPixelFormat_AV_PIX_FMT_BGR555BE: AVPixelFormat = 42;
3175#[doc = "< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined"]
3176pub const AVPixelFormat_AV_PIX_FMT_BGR555LE: AVPixelFormat = 43;
3177#[doc = " Hardware acceleration through VA-API, data[3] contains a\n VASurfaceID."]
3178pub const AVPixelFormat_AV_PIX_FMT_VAAPI: AVPixelFormat = 44;
3179#[doc = "< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian"]
3180pub const AVPixelFormat_AV_PIX_FMT_YUV420P16LE: AVPixelFormat = 45;
3181#[doc = "< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian"]
3182pub const AVPixelFormat_AV_PIX_FMT_YUV420P16BE: AVPixelFormat = 46;
3183#[doc = "< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3184pub const AVPixelFormat_AV_PIX_FMT_YUV422P16LE: AVPixelFormat = 47;
3185#[doc = "< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3186pub const AVPixelFormat_AV_PIX_FMT_YUV422P16BE: AVPixelFormat = 48;
3187#[doc = "< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian"]
3188pub const AVPixelFormat_AV_PIX_FMT_YUV444P16LE: AVPixelFormat = 49;
3189#[doc = "< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian"]
3190pub const AVPixelFormat_AV_PIX_FMT_YUV444P16BE: AVPixelFormat = 50;
3191#[doc = "< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer"]
3192pub const AVPixelFormat_AV_PIX_FMT_DXVA2_VLD: AVPixelFormat = 51;
3193#[doc = "< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined"]
3194pub const AVPixelFormat_AV_PIX_FMT_RGB444LE: AVPixelFormat = 52;
3195#[doc = "< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined"]
3196pub const AVPixelFormat_AV_PIX_FMT_RGB444BE: AVPixelFormat = 53;
3197#[doc = "< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined"]
3198pub const AVPixelFormat_AV_PIX_FMT_BGR444LE: AVPixelFormat = 54;
3199#[doc = "< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined"]
3200pub const AVPixelFormat_AV_PIX_FMT_BGR444BE: AVPixelFormat = 55;
3201#[doc = "< 8 bits gray, 8 bits alpha"]
3202pub const AVPixelFormat_AV_PIX_FMT_YA8: AVPixelFormat = 56;
3203#[doc = "< alias for AV_PIX_FMT_YA8"]
3204pub const AVPixelFormat_AV_PIX_FMT_Y400A: AVPixelFormat = 56;
3205#[doc = "< alias for AV_PIX_FMT_YA8"]
3206pub const AVPixelFormat_AV_PIX_FMT_GRAY8A: AVPixelFormat = 56;
3207#[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"]
3208pub const AVPixelFormat_AV_PIX_FMT_BGR48BE: AVPixelFormat = 57;
3209#[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"]
3210pub const AVPixelFormat_AV_PIX_FMT_BGR48LE: AVPixelFormat = 58;
3211#[doc = "< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian"]
3212pub const AVPixelFormat_AV_PIX_FMT_YUV420P9BE: AVPixelFormat = 59;
3213#[doc = "< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian"]
3214pub const AVPixelFormat_AV_PIX_FMT_YUV420P9LE: AVPixelFormat = 60;
3215#[doc = "< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian"]
3216pub const AVPixelFormat_AV_PIX_FMT_YUV420P10BE: AVPixelFormat = 61;
3217#[doc = "< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian"]
3218pub const AVPixelFormat_AV_PIX_FMT_YUV420P10LE: AVPixelFormat = 62;
3219#[doc = "< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3220pub const AVPixelFormat_AV_PIX_FMT_YUV422P10BE: AVPixelFormat = 63;
3221#[doc = "< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3222pub const AVPixelFormat_AV_PIX_FMT_YUV422P10LE: AVPixelFormat = 64;
3223#[doc = "< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian"]
3224pub const AVPixelFormat_AV_PIX_FMT_YUV444P9BE: AVPixelFormat = 65;
3225#[doc = "< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian"]
3226pub const AVPixelFormat_AV_PIX_FMT_YUV444P9LE: AVPixelFormat = 66;
3227#[doc = "< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian"]
3228pub const AVPixelFormat_AV_PIX_FMT_YUV444P10BE: AVPixelFormat = 67;
3229#[doc = "< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian"]
3230pub const AVPixelFormat_AV_PIX_FMT_YUV444P10LE: AVPixelFormat = 68;
3231#[doc = "< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3232pub const AVPixelFormat_AV_PIX_FMT_YUV422P9BE: AVPixelFormat = 69;
3233#[doc = "< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3234pub const AVPixelFormat_AV_PIX_FMT_YUV422P9LE: AVPixelFormat = 70;
3235#[doc = "< planar GBR 4:4:4 24bpp"]
3236pub const AVPixelFormat_AV_PIX_FMT_GBRP: AVPixelFormat = 71;
3237pub const AVPixelFormat_AV_PIX_FMT_GBR24P: AVPixelFormat = 71;
3238#[doc = "< planar GBR 4:4:4 27bpp, big-endian"]
3239pub const AVPixelFormat_AV_PIX_FMT_GBRP9BE: AVPixelFormat = 72;
3240#[doc = "< planar GBR 4:4:4 27bpp, little-endian"]
3241pub const AVPixelFormat_AV_PIX_FMT_GBRP9LE: AVPixelFormat = 73;
3242#[doc = "< planar GBR 4:4:4 30bpp, big-endian"]
3243pub const AVPixelFormat_AV_PIX_FMT_GBRP10BE: AVPixelFormat = 74;
3244#[doc = "< planar GBR 4:4:4 30bpp, little-endian"]
3245pub const AVPixelFormat_AV_PIX_FMT_GBRP10LE: AVPixelFormat = 75;
3246#[doc = "< planar GBR 4:4:4 48bpp, big-endian"]
3247pub const AVPixelFormat_AV_PIX_FMT_GBRP16BE: AVPixelFormat = 76;
3248#[doc = "< planar GBR 4:4:4 48bpp, little-endian"]
3249pub const AVPixelFormat_AV_PIX_FMT_GBRP16LE: AVPixelFormat = 77;
3250#[doc = "< planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)"]
3251pub const AVPixelFormat_AV_PIX_FMT_YUVA422P: AVPixelFormat = 78;
3252#[doc = "< planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)"]
3253pub const AVPixelFormat_AV_PIX_FMT_YUVA444P: AVPixelFormat = 79;
3254#[doc = "< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian"]
3255pub const AVPixelFormat_AV_PIX_FMT_YUVA420P9BE: AVPixelFormat = 80;
3256#[doc = "< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian"]
3257pub const AVPixelFormat_AV_PIX_FMT_YUVA420P9LE: AVPixelFormat = 81;
3258#[doc = "< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian"]
3259pub const AVPixelFormat_AV_PIX_FMT_YUVA422P9BE: AVPixelFormat = 82;
3260#[doc = "< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian"]
3261pub const AVPixelFormat_AV_PIX_FMT_YUVA422P9LE: AVPixelFormat = 83;
3262#[doc = "< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian"]
3263pub const AVPixelFormat_AV_PIX_FMT_YUVA444P9BE: AVPixelFormat = 84;
3264#[doc = "< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian"]
3265pub const AVPixelFormat_AV_PIX_FMT_YUVA444P9LE: AVPixelFormat = 85;
3266#[doc = "< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)"]
3267pub const AVPixelFormat_AV_PIX_FMT_YUVA420P10BE: AVPixelFormat = 86;
3268#[doc = "< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)"]
3269pub const AVPixelFormat_AV_PIX_FMT_YUVA420P10LE: AVPixelFormat = 87;
3270#[doc = "< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)"]
3271pub const AVPixelFormat_AV_PIX_FMT_YUVA422P10BE: AVPixelFormat = 88;
3272#[doc = "< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)"]
3273pub const AVPixelFormat_AV_PIX_FMT_YUVA422P10LE: AVPixelFormat = 89;
3274#[doc = "< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)"]
3275pub const AVPixelFormat_AV_PIX_FMT_YUVA444P10BE: AVPixelFormat = 90;
3276#[doc = "< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)"]
3277pub const AVPixelFormat_AV_PIX_FMT_YUVA444P10LE: AVPixelFormat = 91;
3278#[doc = "< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)"]
3279pub const AVPixelFormat_AV_PIX_FMT_YUVA420P16BE: AVPixelFormat = 92;
3280#[doc = "< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)"]
3281pub const AVPixelFormat_AV_PIX_FMT_YUVA420P16LE: AVPixelFormat = 93;
3282#[doc = "< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)"]
3283pub const AVPixelFormat_AV_PIX_FMT_YUVA422P16BE: AVPixelFormat = 94;
3284#[doc = "< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)"]
3285pub const AVPixelFormat_AV_PIX_FMT_YUVA422P16LE: AVPixelFormat = 95;
3286#[doc = "< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)"]
3287pub const AVPixelFormat_AV_PIX_FMT_YUVA444P16BE: AVPixelFormat = 96;
3288#[doc = "< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)"]
3289pub const AVPixelFormat_AV_PIX_FMT_YUVA444P16LE: AVPixelFormat = 97;
3290#[doc = "< HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface"]
3291pub const AVPixelFormat_AV_PIX_FMT_VDPAU: AVPixelFormat = 98;
3292#[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"]
3293pub const AVPixelFormat_AV_PIX_FMT_XYZ12LE: AVPixelFormat = 99;
3294#[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"]
3295pub const AVPixelFormat_AV_PIX_FMT_XYZ12BE: AVPixelFormat = 100;
3296#[doc = "< interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)"]
3297pub const AVPixelFormat_AV_PIX_FMT_NV16: AVPixelFormat = 101;
3298#[doc = "< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3299pub const AVPixelFormat_AV_PIX_FMT_NV20LE: AVPixelFormat = 102;
3300#[doc = "< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3301pub const AVPixelFormat_AV_PIX_FMT_NV20BE: AVPixelFormat = 103;
3302#[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"]
3303pub const AVPixelFormat_AV_PIX_FMT_RGBA64BE: AVPixelFormat = 104;
3304#[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"]
3305pub const AVPixelFormat_AV_PIX_FMT_RGBA64LE: AVPixelFormat = 105;
3306#[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"]
3307pub const AVPixelFormat_AV_PIX_FMT_BGRA64BE: AVPixelFormat = 106;
3308#[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"]
3309pub const AVPixelFormat_AV_PIX_FMT_BGRA64LE: AVPixelFormat = 107;
3310#[doc = "< packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb"]
3311pub const AVPixelFormat_AV_PIX_FMT_YVYU422: AVPixelFormat = 108;
3312#[doc = "< 16 bits gray, 16 bits alpha (big-endian)"]
3313pub const AVPixelFormat_AV_PIX_FMT_YA16BE: AVPixelFormat = 109;
3314#[doc = "< 16 bits gray, 16 bits alpha (little-endian)"]
3315pub const AVPixelFormat_AV_PIX_FMT_YA16LE: AVPixelFormat = 110;
3316#[doc = "< planar GBRA 4:4:4:4 32bpp"]
3317pub const AVPixelFormat_AV_PIX_FMT_GBRAP: AVPixelFormat = 111;
3318#[doc = "< planar GBRA 4:4:4:4 64bpp, big-endian"]
3319pub const AVPixelFormat_AV_PIX_FMT_GBRAP16BE: AVPixelFormat = 112;
3320#[doc = "< planar GBRA 4:4:4:4 64bpp, little-endian"]
3321pub const AVPixelFormat_AV_PIX_FMT_GBRAP16LE: AVPixelFormat = 113;
3322#[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."]
3323pub const AVPixelFormat_AV_PIX_FMT_QSV: AVPixelFormat = 114;
3324#[doc = " HW acceleration though MMAL, data[3] contains a pointer to the\n MMAL_BUFFER_HEADER_T structure."]
3325pub const AVPixelFormat_AV_PIX_FMT_MMAL: AVPixelFormat = 115;
3326#[doc = "< HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView pointer"]
3327pub const AVPixelFormat_AV_PIX_FMT_D3D11VA_VLD: AVPixelFormat = 116;
3328#[doc = " HW acceleration through CUDA. data[i] contain CUdeviceptr pointers\n exactly as for system memory frames."]
3329pub const AVPixelFormat_AV_PIX_FMT_CUDA: AVPixelFormat = 117;
3330#[doc = "< packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined"]
3331pub const AVPixelFormat_AV_PIX_FMT_0RGB: AVPixelFormat = 118;
3332#[doc = "< packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined"]
3333pub const AVPixelFormat_AV_PIX_FMT_RGB0: AVPixelFormat = 119;
3334#[doc = "< packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined"]
3335pub const AVPixelFormat_AV_PIX_FMT_0BGR: AVPixelFormat = 120;
3336#[doc = "< packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined"]
3337pub const AVPixelFormat_AV_PIX_FMT_BGR0: AVPixelFormat = 121;
3338#[doc = "< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian"]
3339pub const AVPixelFormat_AV_PIX_FMT_YUV420P12BE: AVPixelFormat = 122;
3340#[doc = "< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian"]
3341pub const AVPixelFormat_AV_PIX_FMT_YUV420P12LE: AVPixelFormat = 123;
3342#[doc = "< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian"]
3343pub const AVPixelFormat_AV_PIX_FMT_YUV420P14BE: AVPixelFormat = 124;
3344#[doc = "< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian"]
3345pub const AVPixelFormat_AV_PIX_FMT_YUV420P14LE: AVPixelFormat = 125;
3346#[doc = "< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3347pub const AVPixelFormat_AV_PIX_FMT_YUV422P12BE: AVPixelFormat = 126;
3348#[doc = "< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3349pub const AVPixelFormat_AV_PIX_FMT_YUV422P12LE: AVPixelFormat = 127;
3350#[doc = "< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3351pub const AVPixelFormat_AV_PIX_FMT_YUV422P14BE: AVPixelFormat = 128;
3352#[doc = "< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3353pub const AVPixelFormat_AV_PIX_FMT_YUV422P14LE: AVPixelFormat = 129;
3354#[doc = "< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian"]
3355pub const AVPixelFormat_AV_PIX_FMT_YUV444P12BE: AVPixelFormat = 130;
3356#[doc = "< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian"]
3357pub const AVPixelFormat_AV_PIX_FMT_YUV444P12LE: AVPixelFormat = 131;
3358#[doc = "< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian"]
3359pub const AVPixelFormat_AV_PIX_FMT_YUV444P14BE: AVPixelFormat = 132;
3360#[doc = "< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian"]
3361pub const AVPixelFormat_AV_PIX_FMT_YUV444P14LE: AVPixelFormat = 133;
3362#[doc = "< planar GBR 4:4:4 36bpp, big-endian"]
3363pub const AVPixelFormat_AV_PIX_FMT_GBRP12BE: AVPixelFormat = 134;
3364#[doc = "< planar GBR 4:4:4 36bpp, little-endian"]
3365pub const AVPixelFormat_AV_PIX_FMT_GBRP12LE: AVPixelFormat = 135;
3366#[doc = "< planar GBR 4:4:4 42bpp, big-endian"]
3367pub const AVPixelFormat_AV_PIX_FMT_GBRP14BE: AVPixelFormat = 136;
3368#[doc = "< planar GBR 4:4:4 42bpp, little-endian"]
3369pub const AVPixelFormat_AV_PIX_FMT_GBRP14LE: AVPixelFormat = 137;
3370#[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"]
3371pub const AVPixelFormat_AV_PIX_FMT_YUVJ411P: AVPixelFormat = 138;
3372#[doc = "< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples"]
3373pub const AVPixelFormat_AV_PIX_FMT_BAYER_BGGR8: AVPixelFormat = 139;
3374#[doc = "< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples"]
3375pub const AVPixelFormat_AV_PIX_FMT_BAYER_RGGB8: AVPixelFormat = 140;
3376#[doc = "< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples"]
3377pub const AVPixelFormat_AV_PIX_FMT_BAYER_GBRG8: AVPixelFormat = 141;
3378#[doc = "< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples"]
3379pub const AVPixelFormat_AV_PIX_FMT_BAYER_GRBG8: AVPixelFormat = 142;
3380#[doc = "< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian"]
3381pub const AVPixelFormat_AV_PIX_FMT_BAYER_BGGR16LE: AVPixelFormat = 143;
3382#[doc = "< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian"]
3383pub const AVPixelFormat_AV_PIX_FMT_BAYER_BGGR16BE: AVPixelFormat = 144;
3384#[doc = "< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian"]
3385pub const AVPixelFormat_AV_PIX_FMT_BAYER_RGGB16LE: AVPixelFormat = 145;
3386#[doc = "< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian"]
3387pub const AVPixelFormat_AV_PIX_FMT_BAYER_RGGB16BE: AVPixelFormat = 146;
3388#[doc = "< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian"]
3389pub const AVPixelFormat_AV_PIX_FMT_BAYER_GBRG16LE: AVPixelFormat = 147;
3390#[doc = "< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian"]
3391pub const AVPixelFormat_AV_PIX_FMT_BAYER_GBRG16BE: AVPixelFormat = 148;
3392#[doc = "< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian"]
3393pub const AVPixelFormat_AV_PIX_FMT_BAYER_GRBG16LE: AVPixelFormat = 149;
3394#[doc = "< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian"]
3395pub const AVPixelFormat_AV_PIX_FMT_BAYER_GRBG16BE: AVPixelFormat = 150;
3396#[doc = "< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian"]
3397pub const AVPixelFormat_AV_PIX_FMT_YUV440P10LE: AVPixelFormat = 151;
3398#[doc = "< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian"]
3399pub const AVPixelFormat_AV_PIX_FMT_YUV440P10BE: AVPixelFormat = 152;
3400#[doc = "< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian"]
3401pub const AVPixelFormat_AV_PIX_FMT_YUV440P12LE: AVPixelFormat = 153;
3402#[doc = "< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian"]
3403pub const AVPixelFormat_AV_PIX_FMT_YUV440P12BE: AVPixelFormat = 154;
3404#[doc = "< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian"]
3405pub const AVPixelFormat_AV_PIX_FMT_AYUV64LE: AVPixelFormat = 155;
3406#[doc = "< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), big-endian"]
3407pub const AVPixelFormat_AV_PIX_FMT_AYUV64BE: AVPixelFormat = 156;
3408#[doc = "< hardware decoding through Videotoolbox"]
3409pub const AVPixelFormat_AV_PIX_FMT_VIDEOTOOLBOX: AVPixelFormat = 157;
3410#[doc = "< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, little-endian"]
3411pub const AVPixelFormat_AV_PIX_FMT_P010LE: AVPixelFormat = 158;
3412#[doc = "< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, big-endian"]
3413pub const AVPixelFormat_AV_PIX_FMT_P010BE: AVPixelFormat = 159;
3414#[doc = "< planar GBR 4:4:4:4 48bpp, big-endian"]
3415pub const AVPixelFormat_AV_PIX_FMT_GBRAP12BE: AVPixelFormat = 160;
3416#[doc = "< planar GBR 4:4:4:4 48bpp, little-endian"]
3417pub const AVPixelFormat_AV_PIX_FMT_GBRAP12LE: AVPixelFormat = 161;
3418#[doc = "< planar GBR 4:4:4:4 40bpp, big-endian"]
3419pub const AVPixelFormat_AV_PIX_FMT_GBRAP10BE: AVPixelFormat = 162;
3420#[doc = "< planar GBR 4:4:4:4 40bpp, little-endian"]
3421pub const AVPixelFormat_AV_PIX_FMT_GBRAP10LE: AVPixelFormat = 163;
3422#[doc = "< hardware decoding through MediaCodec"]
3423pub const AVPixelFormat_AV_PIX_FMT_MEDIACODEC: AVPixelFormat = 164;
3424#[doc = "< Y , 12bpp, big-endian"]
3425pub const AVPixelFormat_AV_PIX_FMT_GRAY12BE: AVPixelFormat = 165;
3426#[doc = "< Y , 12bpp, little-endian"]
3427pub const AVPixelFormat_AV_PIX_FMT_GRAY12LE: AVPixelFormat = 166;
3428#[doc = "< Y , 10bpp, big-endian"]
3429pub const AVPixelFormat_AV_PIX_FMT_GRAY10BE: AVPixelFormat = 167;
3430#[doc = "< Y , 10bpp, little-endian"]
3431pub const AVPixelFormat_AV_PIX_FMT_GRAY10LE: AVPixelFormat = 168;
3432#[doc = "< like NV12, with 16bpp per component, little-endian"]
3433pub const AVPixelFormat_AV_PIX_FMT_P016LE: AVPixelFormat = 169;
3434#[doc = "< like NV12, with 16bpp per component, big-endian"]
3435pub const AVPixelFormat_AV_PIX_FMT_P016BE: AVPixelFormat = 170;
3436#[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)."]
3437pub const AVPixelFormat_AV_PIX_FMT_D3D11: AVPixelFormat = 171;
3438#[doc = "< Y , 9bpp, big-endian"]
3439pub const AVPixelFormat_AV_PIX_FMT_GRAY9BE: AVPixelFormat = 172;
3440#[doc = "< Y , 9bpp, little-endian"]
3441pub const AVPixelFormat_AV_PIX_FMT_GRAY9LE: AVPixelFormat = 173;
3442#[doc = "< IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian"]
3443pub const AVPixelFormat_AV_PIX_FMT_GBRPF32BE: AVPixelFormat = 174;
3444#[doc = "< IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian"]
3445pub const AVPixelFormat_AV_PIX_FMT_GBRPF32LE: AVPixelFormat = 175;
3446#[doc = "< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian"]
3447pub const AVPixelFormat_AV_PIX_FMT_GBRAPF32BE: AVPixelFormat = 176;
3448#[doc = "< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian"]
3449pub const AVPixelFormat_AV_PIX_FMT_GBRAPF32LE: AVPixelFormat = 177;
3450#[doc = " DRM-managed buffers exposed through PRIME buffer sharing.\n\n data[0] points to an AVDRMFrameDescriptor."]
3451pub const AVPixelFormat_AV_PIX_FMT_DRM_PRIME: AVPixelFormat = 178;
3452#[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."]
3453pub const AVPixelFormat_AV_PIX_FMT_OPENCL: AVPixelFormat = 179;
3454#[doc = "< Y , 14bpp, big-endian"]
3455pub const AVPixelFormat_AV_PIX_FMT_GRAY14BE: AVPixelFormat = 180;
3456#[doc = "< Y , 14bpp, little-endian"]
3457pub const AVPixelFormat_AV_PIX_FMT_GRAY14LE: AVPixelFormat = 181;
3458#[doc = "< IEEE-754 single precision Y, 32bpp, big-endian"]
3459pub const AVPixelFormat_AV_PIX_FMT_GRAYF32BE: AVPixelFormat = 182;
3460#[doc = "< IEEE-754 single precision Y, 32bpp, little-endian"]
3461pub const AVPixelFormat_AV_PIX_FMT_GRAYF32LE: AVPixelFormat = 183;
3462#[doc = "< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian"]
3463pub const AVPixelFormat_AV_PIX_FMT_YUVA422P12BE: AVPixelFormat = 184;
3464#[doc = "< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian"]
3465pub const AVPixelFormat_AV_PIX_FMT_YUVA422P12LE: AVPixelFormat = 185;
3466#[doc = "< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian"]
3467pub const AVPixelFormat_AV_PIX_FMT_YUVA444P12BE: AVPixelFormat = 186;
3468#[doc = "< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian"]
3469pub const AVPixelFormat_AV_PIX_FMT_YUVA444P12LE: AVPixelFormat = 187;
3470#[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)"]
3471pub const AVPixelFormat_AV_PIX_FMT_NV24: AVPixelFormat = 188;
3472#[doc = "< as above, but U and V bytes are swapped"]
3473pub const AVPixelFormat_AV_PIX_FMT_NV42: AVPixelFormat = 189;
3474#[doc = " Vulkan hardware images.\n\n data[0] points to an AVVkFrame"]
3475pub const AVPixelFormat_AV_PIX_FMT_VULKAN: AVPixelFormat = 190;
3476#[doc = "< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, big-endian"]
3477pub const AVPixelFormat_AV_PIX_FMT_Y210BE: AVPixelFormat = 191;
3478#[doc = "< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian"]
3479pub const AVPixelFormat_AV_PIX_FMT_Y210LE: AVPixelFormat = 192;
3480#[doc = "< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined"]
3481pub const AVPixelFormat_AV_PIX_FMT_X2RGB10LE: AVPixelFormat = 193;
3482#[doc = "< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), big-endian, X=unused/undefined"]
3483pub const AVPixelFormat_AV_PIX_FMT_X2RGB10BE: AVPixelFormat = 194;
3484#[doc = "< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined"]
3485pub const AVPixelFormat_AV_PIX_FMT_X2BGR10LE: AVPixelFormat = 195;
3486#[doc = "< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), big-endian, X=unused/undefined"]
3487pub const AVPixelFormat_AV_PIX_FMT_X2BGR10BE: AVPixelFormat = 196;
3488#[doc = "< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, big-endian"]
3489pub const AVPixelFormat_AV_PIX_FMT_P210BE: AVPixelFormat = 197;
3490#[doc = "< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, little-endian"]
3491pub const AVPixelFormat_AV_PIX_FMT_P210LE: AVPixelFormat = 198;
3492#[doc = "< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, big-endian"]
3493pub const AVPixelFormat_AV_PIX_FMT_P410BE: AVPixelFormat = 199;
3494#[doc = "< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, little-endian"]
3495pub const AVPixelFormat_AV_PIX_FMT_P410LE: AVPixelFormat = 200;
3496#[doc = "< interleaved chroma YUV 4:2:2, 32bpp, big-endian"]
3497pub const AVPixelFormat_AV_PIX_FMT_P216BE: AVPixelFormat = 201;
3498#[doc = "< interleaved chroma YUV 4:2:2, 32bpp, little-endian"]
3499pub const AVPixelFormat_AV_PIX_FMT_P216LE: AVPixelFormat = 202;
3500#[doc = "< interleaved chroma YUV 4:4:4, 48bpp, big-endian"]
3501pub const AVPixelFormat_AV_PIX_FMT_P416BE: AVPixelFormat = 203;
3502#[doc = "< interleaved chroma YUV 4:4:4, 48bpp, little-endian"]
3503pub const AVPixelFormat_AV_PIX_FMT_P416LE: AVPixelFormat = 204;
3504#[doc = "< packed VUYA 4:4:4, 32bpp, VUYAVUYA..."]
3505pub const AVPixelFormat_AV_PIX_FMT_VUYA: AVPixelFormat = 205;
3506#[doc = "< IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., big-endian"]
3507pub const AVPixelFormat_AV_PIX_FMT_RGBAF16BE: AVPixelFormat = 206;
3508#[doc = "< IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., little-endian"]
3509pub const AVPixelFormat_AV_PIX_FMT_RGBAF16LE: AVPixelFormat = 207;
3510#[doc = "< packed VUYX 4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined"]
3511pub const AVPixelFormat_AV_PIX_FMT_VUYX: AVPixelFormat = 208;
3512#[doc = "< like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, little-endian"]
3513pub const AVPixelFormat_AV_PIX_FMT_P012LE: AVPixelFormat = 209;
3514#[doc = "< like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, big-endian"]
3515pub const AVPixelFormat_AV_PIX_FMT_P012BE: AVPixelFormat = 210;
3516#[doc = "< packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, big-endian"]
3517pub const AVPixelFormat_AV_PIX_FMT_Y212BE: AVPixelFormat = 211;
3518#[doc = "< packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, little-endian"]
3519pub const AVPixelFormat_AV_PIX_FMT_Y212LE: AVPixelFormat = 212;
3520#[doc = "< packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), big-endian, variant of Y410 where alpha channel is left undefined"]
3521pub const AVPixelFormat_AV_PIX_FMT_XV30BE: AVPixelFormat = 213;
3522#[doc = "< packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), little-endian, variant of Y410 where alpha channel is left undefined"]
3523pub const AVPixelFormat_AV_PIX_FMT_XV30LE: AVPixelFormat = 214;
3524#[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"]
3525pub const AVPixelFormat_AV_PIX_FMT_XV36BE: AVPixelFormat = 215;
3526#[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"]
3527pub const AVPixelFormat_AV_PIX_FMT_XV36LE: AVPixelFormat = 216;
3528#[doc = "< IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., big-endian"]
3529pub const AVPixelFormat_AV_PIX_FMT_RGBF32BE: AVPixelFormat = 217;
3530#[doc = "< IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., little-endian"]
3531pub const AVPixelFormat_AV_PIX_FMT_RGBF32LE: AVPixelFormat = 218;
3532#[doc = "< IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., big-endian"]
3533pub const AVPixelFormat_AV_PIX_FMT_RGBAF32BE: AVPixelFormat = 219;
3534#[doc = "< IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., little-endian"]
3535pub const AVPixelFormat_AV_PIX_FMT_RGBAF32LE: AVPixelFormat = 220;
3536#[doc = "< interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, big-endian"]
3537pub const AVPixelFormat_AV_PIX_FMT_P212BE: AVPixelFormat = 221;
3538#[doc = "< interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, little-endian"]
3539pub const AVPixelFormat_AV_PIX_FMT_P212LE: AVPixelFormat = 222;
3540#[doc = "< interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, big-endian"]
3541pub const AVPixelFormat_AV_PIX_FMT_P412BE: AVPixelFormat = 223;
3542#[doc = "< interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, little-endian"]
3543pub const AVPixelFormat_AV_PIX_FMT_P412LE: AVPixelFormat = 224;
3544#[doc = "< planar GBR 4:4:4:4 56bpp, big-endian"]
3545pub const AVPixelFormat_AV_PIX_FMT_GBRAP14BE: AVPixelFormat = 225;
3546#[doc = "< planar GBR 4:4:4:4 56bpp, little-endian"]
3547pub const AVPixelFormat_AV_PIX_FMT_GBRAP14LE: AVPixelFormat = 226;
3548#[doc = " Hardware surfaces for Direct3D 12.\n\n data[0] points to an AVD3D12VAFrame"]
3549pub const AVPixelFormat_AV_PIX_FMT_D3D12: AVPixelFormat = 227;
3550#[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"]
3551pub const AVPixelFormat_AV_PIX_FMT_NB: AVPixelFormat = 228;
3552#[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."]
3553pub type AVPixelFormat = ::std::os::raw::c_int;
3554pub const AVColorPrimaries_AVCOL_PRI_RESERVED0: AVColorPrimaries = 0;
3555#[doc = "< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B"]
3556pub const AVColorPrimaries_AVCOL_PRI_BT709: AVColorPrimaries = 1;
3557pub const AVColorPrimaries_AVCOL_PRI_UNSPECIFIED: AVColorPrimaries = 2;
3558pub const AVColorPrimaries_AVCOL_PRI_RESERVED: AVColorPrimaries = 3;
3559#[doc = "< also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)"]
3560pub const AVColorPrimaries_AVCOL_PRI_BT470M: AVColorPrimaries = 4;
3561#[doc = "< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM"]
3562pub const AVColorPrimaries_AVCOL_PRI_BT470BG: AVColorPrimaries = 5;
3563#[doc = "< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC"]
3564pub const AVColorPrimaries_AVCOL_PRI_SMPTE170M: AVColorPrimaries = 6;
3565#[doc = "< identical to above, also called \"SMPTE C\" even though it uses D65"]
3566pub const AVColorPrimaries_AVCOL_PRI_SMPTE240M: AVColorPrimaries = 7;
3567#[doc = "< colour filters using Illuminant C"]
3568pub const AVColorPrimaries_AVCOL_PRI_FILM: AVColorPrimaries = 8;
3569#[doc = "< ITU-R BT2020"]
3570pub const AVColorPrimaries_AVCOL_PRI_BT2020: AVColorPrimaries = 9;
3571#[doc = "< SMPTE ST 428-1 (CIE 1931 XYZ)"]
3572pub const AVColorPrimaries_AVCOL_PRI_SMPTE428: AVColorPrimaries = 10;
3573pub const AVColorPrimaries_AVCOL_PRI_SMPTEST428_1: AVColorPrimaries = 10;
3574#[doc = "< SMPTE ST 431-2 (2011) / DCI P3"]
3575pub const AVColorPrimaries_AVCOL_PRI_SMPTE431: AVColorPrimaries = 11;
3576#[doc = "< SMPTE ST 432-1 (2010) / P3 D65 / Display P3"]
3577pub const AVColorPrimaries_AVCOL_PRI_SMPTE432: AVColorPrimaries = 12;
3578#[doc = "< EBU Tech. 3213-E (nothing there) / one of JEDEC P22 group phosphors"]
3579pub const AVColorPrimaries_AVCOL_PRI_EBU3213: AVColorPrimaries = 22;
3580pub const AVColorPrimaries_AVCOL_PRI_JEDEC_P22: AVColorPrimaries = 22;
3581#[doc = "< Not part of ABI"]
3582pub const AVColorPrimaries_AVCOL_PRI_NB: AVColorPrimaries = 23;
3583#[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."]
3584pub type AVColorPrimaries = ::std::os::raw::c_uint;
3585pub const AVColorTransferCharacteristic_AVCOL_TRC_RESERVED0: AVColorTransferCharacteristic = 0;
3586#[doc = "< also ITU-R BT1361"]
3587pub const AVColorTransferCharacteristic_AVCOL_TRC_BT709: AVColorTransferCharacteristic = 1;
3588pub const AVColorTransferCharacteristic_AVCOL_TRC_UNSPECIFIED: AVColorTransferCharacteristic = 2;
3589pub const AVColorTransferCharacteristic_AVCOL_TRC_RESERVED: AVColorTransferCharacteristic = 3;
3590#[doc = "< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM"]
3591pub const AVColorTransferCharacteristic_AVCOL_TRC_GAMMA22: AVColorTransferCharacteristic = 4;
3592#[doc = "< also ITU-R BT470BG"]
3593pub const AVColorTransferCharacteristic_AVCOL_TRC_GAMMA28: AVColorTransferCharacteristic = 5;
3594#[doc = "< also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC"]
3595pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTE170M: AVColorTransferCharacteristic = 6;
3596pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTE240M: AVColorTransferCharacteristic = 7;
3597#[doc = "< \"Linear transfer characteristics\""]
3598pub const AVColorTransferCharacteristic_AVCOL_TRC_LINEAR: AVColorTransferCharacteristic = 8;
3599#[doc = "< \"Logarithmic transfer characteristic (100:1 range)\""]
3600pub const AVColorTransferCharacteristic_AVCOL_TRC_LOG: AVColorTransferCharacteristic = 9;
3601#[doc = "< \"Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)\""]
3602pub const AVColorTransferCharacteristic_AVCOL_TRC_LOG_SQRT: AVColorTransferCharacteristic = 10;
3603#[doc = "< IEC 61966-2-4"]
3604pub const AVColorTransferCharacteristic_AVCOL_TRC_IEC61966_2_4: AVColorTransferCharacteristic = 11;
3605#[doc = "< ITU-R BT1361 Extended Colour Gamut"]
3606pub const AVColorTransferCharacteristic_AVCOL_TRC_BT1361_ECG: AVColorTransferCharacteristic = 12;
3607#[doc = "< IEC 61966-2-1 (sRGB or sYCC)"]
3608pub const AVColorTransferCharacteristic_AVCOL_TRC_IEC61966_2_1: AVColorTransferCharacteristic = 13;
3609#[doc = "< ITU-R BT2020 for 10-bit system"]
3610pub const AVColorTransferCharacteristic_AVCOL_TRC_BT2020_10: AVColorTransferCharacteristic = 14;
3611#[doc = "< ITU-R BT2020 for 12-bit system"]
3612pub const AVColorTransferCharacteristic_AVCOL_TRC_BT2020_12: AVColorTransferCharacteristic = 15;
3613#[doc = "< SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems"]
3614pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTE2084: AVColorTransferCharacteristic = 16;
3615pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTEST2084: AVColorTransferCharacteristic = 16;
3616#[doc = "< SMPTE ST 428-1"]
3617pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTE428: AVColorTransferCharacteristic = 17;
3618pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTEST428_1: AVColorTransferCharacteristic = 17;
3619#[doc = "< ARIB STD-B67, known as \"Hybrid log-gamma\""]
3620pub const AVColorTransferCharacteristic_AVCOL_TRC_ARIB_STD_B67: AVColorTransferCharacteristic = 18;
3621#[doc = "< Not part of ABI"]
3622pub const AVColorTransferCharacteristic_AVCOL_TRC_NB: AVColorTransferCharacteristic = 19;
3623#[doc = " Color Transfer Characteristic.\n These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.2."]
3624pub type AVColorTransferCharacteristic = ::std::os::raw::c_uint;
3625#[doc = "< order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1"]
3626pub const AVColorSpace_AVCOL_SPC_RGB: AVColorSpace = 0;
3627#[doc = "< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B"]
3628pub const AVColorSpace_AVCOL_SPC_BT709: AVColorSpace = 1;
3629pub const AVColorSpace_AVCOL_SPC_UNSPECIFIED: AVColorSpace = 2;
3630#[doc = "< reserved for future use by ITU-T and ISO/IEC just like 15-255 are"]
3631pub const AVColorSpace_AVCOL_SPC_RESERVED: AVColorSpace = 3;
3632#[doc = "< FCC Title 47 Code of Federal Regulations 73.682 (a)(20)"]
3633pub const AVColorSpace_AVCOL_SPC_FCC: AVColorSpace = 4;
3634#[doc = "< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601"]
3635pub const AVColorSpace_AVCOL_SPC_BT470BG: AVColorSpace = 5;
3636#[doc = "< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above"]
3637pub const AVColorSpace_AVCOL_SPC_SMPTE170M: AVColorSpace = 6;
3638#[doc = "< derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries"]
3639pub const AVColorSpace_AVCOL_SPC_SMPTE240M: AVColorSpace = 7;
3640#[doc = "< used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16"]
3641pub const AVColorSpace_AVCOL_SPC_YCGCO: AVColorSpace = 8;
3642pub const AVColorSpace_AVCOL_SPC_YCOCG: AVColorSpace = 8;
3643#[doc = "< ITU-R BT2020 non-constant luminance system"]
3644pub const AVColorSpace_AVCOL_SPC_BT2020_NCL: AVColorSpace = 9;
3645#[doc = "< ITU-R BT2020 constant luminance system"]
3646pub const AVColorSpace_AVCOL_SPC_BT2020_CL: AVColorSpace = 10;
3647#[doc = "< SMPTE 2085, Y'D'zD'x"]
3648pub const AVColorSpace_AVCOL_SPC_SMPTE2085: AVColorSpace = 11;
3649#[doc = "< Chromaticity-derived non-constant luminance system"]
3650pub const AVColorSpace_AVCOL_SPC_CHROMA_DERIVED_NCL: AVColorSpace = 12;
3651#[doc = "< Chromaticity-derived constant luminance system"]
3652pub const AVColorSpace_AVCOL_SPC_CHROMA_DERIVED_CL: AVColorSpace = 13;
3653#[doc = "< ITU-R BT.2100-0, ICtCp"]
3654pub const AVColorSpace_AVCOL_SPC_ICTCP: AVColorSpace = 14;
3655#[doc = "< SMPTE ST 2128, IPT-C2"]
3656pub const AVColorSpace_AVCOL_SPC_IPT_C2: AVColorSpace = 15;
3657#[doc = "< YCgCo-R, even addition of bits"]
3658pub const AVColorSpace_AVCOL_SPC_YCGCO_RE: AVColorSpace = 16;
3659#[doc = "< YCgCo-R, odd addition of bits"]
3660pub const AVColorSpace_AVCOL_SPC_YCGCO_RO: AVColorSpace = 17;
3661#[doc = "< Not part of ABI"]
3662pub const AVColorSpace_AVCOL_SPC_NB: AVColorSpace = 18;
3663#[doc = " YUV colorspace type.\n These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.3."]
3664pub type AVColorSpace = ::std::os::raw::c_uint;
3665pub const AVColorRange_AVCOL_RANGE_UNSPECIFIED: AVColorRange = 0;
3666#[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"]
3667pub const AVColorRange_AVCOL_RANGE_MPEG: AVColorRange = 1;
3668#[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"]
3669pub const AVColorRange_AVCOL_RANGE_JPEG: AVColorRange = 2;
3670#[doc = "< Not part of ABI"]
3671pub const AVColorRange_AVCOL_RANGE_NB: AVColorRange = 3;
3672#[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)."]
3673pub type AVColorRange = ::std::os::raw::c_uint;
3674pub const AVChromaLocation_AVCHROMA_LOC_UNSPECIFIED: AVChromaLocation = 0;
3675#[doc = "< MPEG-2/4 4:2:0, H.264 default for 4:2:0"]
3676pub const AVChromaLocation_AVCHROMA_LOC_LEFT: AVChromaLocation = 1;
3677#[doc = "< MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0"]
3678pub const AVChromaLocation_AVCHROMA_LOC_CENTER: AVChromaLocation = 2;
3679#[doc = "< ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2"]
3680pub const AVChromaLocation_AVCHROMA_LOC_TOPLEFT: AVChromaLocation = 3;
3681pub const AVChromaLocation_AVCHROMA_LOC_TOP: AVChromaLocation = 4;
3682pub const AVChromaLocation_AVCHROMA_LOC_BOTTOMLEFT: AVChromaLocation = 5;
3683pub const AVChromaLocation_AVCHROMA_LOC_BOTTOM: AVChromaLocation = 6;
3684#[doc = "< Not part of ABI"]
3685pub const AVChromaLocation_AVCHROMA_LOC_NB: AVChromaLocation = 7;
3686#[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"]
3687pub type AVChromaLocation = ::std::os::raw::c_uint;
3688extern "C" {
3689 #[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"]
3690 pub fn av_int_list_length_for_size(
3691 elsize: ::std::os::raw::c_uint,
3692 list: *const ::std::os::raw::c_void,
3693 term: u64,
3694 ) -> ::std::os::raw::c_uint;
3695}
3696extern "C" {
3697 #[doc = " Return the fractional representation of the internal time base."]
3698 pub fn av_get_time_base_q() -> AVRational;
3699}
3700extern "C" {
3701 #[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"]
3702 pub fn av_fourcc_make_string(
3703 buf: *mut ::std::os::raw::c_char,
3704 fourcc: u32,
3705 ) -> *mut ::std::os::raw::c_char;
3706}
3707pub type __builtin_va_list = *mut ::std::os::raw::c_void;
3708#[doc = " a pointer to the first option specified in the class if any or NULL\n\n @see av_set_default_options()"]
3709#[repr(C)]
3710#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3711pub struct AVOption {
3712 pub _address: u8,
3713}