1pub const __LITTLE_ENDIAN: u32 = 1234;
4pub const __BIG_ENDIAN: u32 = 4321;
5pub const __USE_TIME_BITS64: u32 = 1;
6pub const INT8_MIN: i32 = -128;
7pub const INT16_MIN: i32 = -32768;
8pub const INT32_MIN: i32 = -2147483648;
9pub const INT64_MIN: i64 = -9223372036854775808;
10pub const INT8_MAX: u32 = 127;
11pub const INT16_MAX: u32 = 32767;
12pub const INT32_MAX: u32 = 2147483647;
13pub const INT64_MAX: u64 = 9223372036854775807;
14pub const UINT8_MAX: u32 = 255;
15pub const UINT16_MAX: u32 = 65535;
16pub const UINT32_MAX: u32 = 4294967295;
17pub const UINT64_MAX: i32 = -1;
18pub const INT_FAST8_MIN: i32 = -128;
19pub const INT_FAST64_MIN: i64 = -9223372036854775808;
20pub const INT_LEAST8_MIN: i32 = -128;
21pub const INT_LEAST16_MIN: i32 = -32768;
22pub const INT_LEAST32_MIN: i32 = -2147483648;
23pub const INT_LEAST64_MIN: i64 = -9223372036854775808;
24pub const INT_FAST8_MAX: u32 = 127;
25pub const INT_FAST64_MAX: u64 = 9223372036854775807;
26pub const INT_LEAST8_MAX: u32 = 127;
27pub const INT_LEAST16_MAX: u32 = 32767;
28pub const INT_LEAST32_MAX: u32 = 2147483647;
29pub const INT_LEAST64_MAX: u64 = 9223372036854775807;
30pub const UINT_FAST8_MAX: u32 = 255;
31pub const UINT_FAST64_MAX: i32 = -1;
32pub const UINT_LEAST8_MAX: u32 = 255;
33pub const UINT_LEAST16_MAX: u32 = 65535;
34pub const UINT_LEAST32_MAX: u32 = 4294967295;
35pub const UINT_LEAST64_MAX: i32 = -1;
36pub const INTMAX_MIN: i64 = -9223372036854775808;
37pub const INTMAX_MAX: u64 = 9223372036854775807;
38pub const UINTMAX_MAX: i32 = -1;
39pub const WINT_MIN: u32 = 0;
40pub const WINT_MAX: u32 = 4294967295;
41pub const SIG_ATOMIC_MIN: i32 = -2147483648;
42pub const SIG_ATOMIC_MAX: u32 = 2147483647;
43pub const INT_FAST16_MIN: i32 = -32768;
44pub const INT_FAST32_MIN: i32 = -2147483648;
45pub const INT_FAST16_MAX: u32 = 32767;
46pub const INT_FAST32_MAX: u32 = 2147483647;
47pub const UINT_FAST16_MAX: u32 = 65535;
48pub const UINT_FAST32_MAX: u32 = 4294967295;
49pub const INTPTR_MIN: i32 = -2147483648;
50pub const INTPTR_MAX: u32 = 2147483647;
51pub const UINTPTR_MAX: u32 = 4294967295;
52pub const PTRDIFF_MIN: i32 = -2147483648;
53pub const PTRDIFF_MAX: u32 = 2147483647;
54pub const SIZE_MAX: u32 = 4294967295;
55pub const FF_LAMBDA_SHIFT: u32 = 7;
56pub const FF_LAMBDA_SCALE: u32 = 128;
57pub const FF_QP2LAMBDA: u32 = 118;
58pub const FF_LAMBDA_MAX: u32 = 32767;
59pub const FF_QUALITY_SCALE: u32 = 128;
60pub const AV_TIME_BASE: u32 = 1000000;
61pub const _BSD_SOURCE: u32 = 1;
62pub const _XOPEN_SOURCE: u32 = 700;
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;
229pub const AV_BUFFER_FLAG_READONLY: u32 = 1;
230pub const AV_CHANNEL_LAYOUT_RETYPE_FLAG_LOSSLESS: u32 = 1;
231pub const AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL: u32 = 2;
232pub const AV_DICT_MATCH_CASE: u32 = 1;
233pub const AV_DICT_IGNORE_SUFFIX: u32 = 2;
234pub const AV_DICT_DONT_STRDUP_KEY: u32 = 4;
235pub const AV_DICT_DONT_STRDUP_VAL: u32 = 8;
236pub const AV_DICT_DONT_OVERWRITE: u32 = 16;
237pub const AV_DICT_APPEND: u32 = 32;
238pub const AV_DICT_MULTIKEY: u32 = 64;
239pub const AV_NUM_DATA_POINTERS: u32 = 8;
240pub const AV_FRAME_FLAG_CORRUPT: u32 = 1;
241pub const AV_FRAME_FLAG_KEY: u32 = 2;
242pub const AV_FRAME_FLAG_DISCARD: u32 = 4;
243pub const AV_FRAME_FLAG_INTERLACED: u32 = 8;
244pub const AV_FRAME_FLAG_TOP_FIELD_FIRST: u32 = 16;
245pub const FF_DECODE_ERROR_INVALID_BITSTREAM: u32 = 1;
246pub const FF_DECODE_ERROR_MISSING_REFERENCE: u32 = 2;
247pub const FF_DECODE_ERROR_CONCEALMENT_ACTIVE: u32 = 4;
248pub const FF_DECODE_ERROR_DECODE_SLICES: u32 = 8;
249pub const AV_FRAME_SIDE_DATA_FLAG_UNIQUE: u32 = 1;
250pub const AV_FRAME_SIDE_DATA_FLAG_REPLACE: u32 = 2;
251pub const LIBAVCODEC_VERSION_MAJOR: u32 = 61;
252pub const AV_CODEC_CAP_DRAW_HORIZ_BAND: u32 = 1;
253pub const AV_CODEC_CAP_DR1: u32 = 2;
254pub const AV_CODEC_CAP_DELAY: u32 = 32;
255pub const AV_CODEC_CAP_SMALL_LAST_FRAME: u32 = 64;
256pub const AV_CODEC_CAP_SUBFRAMES: u32 = 256;
257pub const AV_CODEC_CAP_EXPERIMENTAL: u32 = 512;
258pub const AV_CODEC_CAP_CHANNEL_CONF: u32 = 1024;
259pub const AV_CODEC_CAP_FRAME_THREADS: u32 = 4096;
260pub const AV_CODEC_CAP_SLICE_THREADS: u32 = 8192;
261pub const AV_CODEC_CAP_PARAM_CHANGE: u32 = 16384;
262pub const AV_CODEC_CAP_OTHER_THREADS: u32 = 32768;
263pub const AV_CODEC_CAP_VARIABLE_FRAME_SIZE: u32 = 65536;
264pub const AV_CODEC_CAP_AVOID_PROBING: u32 = 131072;
265pub const AV_CODEC_CAP_HARDWARE: u32 = 262144;
266pub const AV_CODEC_CAP_HYBRID: u32 = 524288;
267pub const AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE: u32 = 1048576;
268pub const AV_CODEC_CAP_ENCODER_FLUSH: u32 = 2097152;
269pub const AV_CODEC_CAP_ENCODER_RECON_FRAME: u32 = 4194304;
270pub const AV_INPUT_BUFFER_PADDING_SIZE: u32 = 64;
271pub const AV_EF_CRCCHECK: u32 = 1;
272pub const AV_EF_BITSTREAM: u32 = 2;
273pub const AV_EF_BUFFER: u32 = 4;
274pub const AV_EF_EXPLODE: u32 = 8;
275pub const AV_EF_IGNORE_ERR: u32 = 32768;
276pub const AV_EF_CAREFUL: u32 = 65536;
277pub const AV_EF_COMPLIANT: u32 = 131072;
278pub const AV_EF_AGGRESSIVE: u32 = 262144;
279pub const FF_COMPLIANCE_VERY_STRICT: u32 = 2;
280pub const FF_COMPLIANCE_STRICT: u32 = 1;
281pub const FF_COMPLIANCE_NORMAL: u32 = 0;
282pub const FF_COMPLIANCE_UNOFFICIAL: i32 = -1;
283pub const FF_COMPLIANCE_EXPERIMENTAL: i32 = -2;
284pub const AV_PROFILE_UNKNOWN: i32 = -99;
285pub const AV_PROFILE_RESERVED: i32 = -100;
286pub const AV_PROFILE_AAC_MAIN: u32 = 0;
287pub const AV_PROFILE_AAC_LOW: u32 = 1;
288pub const AV_PROFILE_AAC_SSR: u32 = 2;
289pub const AV_PROFILE_AAC_LTP: u32 = 3;
290pub const AV_PROFILE_AAC_HE: u32 = 4;
291pub const AV_PROFILE_AAC_HE_V2: u32 = 28;
292pub const AV_PROFILE_AAC_LD: u32 = 22;
293pub const AV_PROFILE_AAC_ELD: u32 = 38;
294pub const AV_PROFILE_MPEG2_AAC_LOW: u32 = 128;
295pub const AV_PROFILE_MPEG2_AAC_HE: u32 = 131;
296pub const AV_PROFILE_DNXHD: u32 = 0;
297pub const AV_PROFILE_DNXHR_LB: u32 = 1;
298pub const AV_PROFILE_DNXHR_SQ: u32 = 2;
299pub const AV_PROFILE_DNXHR_HQ: u32 = 3;
300pub const AV_PROFILE_DNXHR_HQX: u32 = 4;
301pub const AV_PROFILE_DNXHR_444: u32 = 5;
302pub const AV_PROFILE_DTS: u32 = 20;
303pub const AV_PROFILE_DTS_ES: u32 = 30;
304pub const AV_PROFILE_DTS_96_24: u32 = 40;
305pub const AV_PROFILE_DTS_HD_HRA: u32 = 50;
306pub const AV_PROFILE_DTS_HD_MA: u32 = 60;
307pub const AV_PROFILE_DTS_EXPRESS: u32 = 70;
308pub const AV_PROFILE_DTS_HD_MA_X: u32 = 61;
309pub const AV_PROFILE_DTS_HD_MA_X_IMAX: u32 = 62;
310pub const AV_PROFILE_EAC3_DDP_ATMOS: u32 = 30;
311pub const AV_PROFILE_TRUEHD_ATMOS: u32 = 30;
312pub const AV_PROFILE_MPEG2_422: u32 = 0;
313pub const AV_PROFILE_MPEG2_HIGH: u32 = 1;
314pub const AV_PROFILE_MPEG2_SS: u32 = 2;
315pub const AV_PROFILE_MPEG2_SNR_SCALABLE: u32 = 3;
316pub const AV_PROFILE_MPEG2_MAIN: u32 = 4;
317pub const AV_PROFILE_MPEG2_SIMPLE: u32 = 5;
318pub const AV_PROFILE_H264_CONSTRAINED: u32 = 512;
319pub const AV_PROFILE_H264_INTRA: u32 = 2048;
320pub const AV_PROFILE_H264_BASELINE: u32 = 66;
321pub const AV_PROFILE_H264_CONSTRAINED_BASELINE: u32 = 578;
322pub const AV_PROFILE_H264_MAIN: u32 = 77;
323pub const AV_PROFILE_H264_EXTENDED: u32 = 88;
324pub const AV_PROFILE_H264_HIGH: u32 = 100;
325pub const AV_PROFILE_H264_HIGH_10: u32 = 110;
326pub const AV_PROFILE_H264_HIGH_10_INTRA: u32 = 2158;
327pub const AV_PROFILE_H264_MULTIVIEW_HIGH: u32 = 118;
328pub const AV_PROFILE_H264_HIGH_422: u32 = 122;
329pub const AV_PROFILE_H264_HIGH_422_INTRA: u32 = 2170;
330pub const AV_PROFILE_H264_STEREO_HIGH: u32 = 128;
331pub const AV_PROFILE_H264_HIGH_444: u32 = 144;
332pub const AV_PROFILE_H264_HIGH_444_PREDICTIVE: u32 = 244;
333pub const AV_PROFILE_H264_HIGH_444_INTRA: u32 = 2292;
334pub const AV_PROFILE_H264_CAVLC_444: u32 = 44;
335pub const AV_PROFILE_VC1_SIMPLE: u32 = 0;
336pub const AV_PROFILE_VC1_MAIN: u32 = 1;
337pub const AV_PROFILE_VC1_COMPLEX: u32 = 2;
338pub const AV_PROFILE_VC1_ADVANCED: u32 = 3;
339pub const AV_PROFILE_MPEG4_SIMPLE: u32 = 0;
340pub const AV_PROFILE_MPEG4_SIMPLE_SCALABLE: u32 = 1;
341pub const AV_PROFILE_MPEG4_CORE: u32 = 2;
342pub const AV_PROFILE_MPEG4_MAIN: u32 = 3;
343pub const AV_PROFILE_MPEG4_N_BIT: u32 = 4;
344pub const AV_PROFILE_MPEG4_SCALABLE_TEXTURE: u32 = 5;
345pub const AV_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION: u32 = 6;
346pub const AV_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE: u32 = 7;
347pub const AV_PROFILE_MPEG4_HYBRID: u32 = 8;
348pub const AV_PROFILE_MPEG4_ADVANCED_REAL_TIME: u32 = 9;
349pub const AV_PROFILE_MPEG4_CORE_SCALABLE: u32 = 10;
350pub const AV_PROFILE_MPEG4_ADVANCED_CODING: u32 = 11;
351pub const AV_PROFILE_MPEG4_ADVANCED_CORE: u32 = 12;
352pub const AV_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE: u32 = 13;
353pub const AV_PROFILE_MPEG4_SIMPLE_STUDIO: u32 = 14;
354pub const AV_PROFILE_MPEG4_ADVANCED_SIMPLE: u32 = 15;
355pub const AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0: u32 = 1;
356pub const AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1: u32 = 2;
357pub const AV_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION: u32 = 32768;
358pub const AV_PROFILE_JPEG2000_DCINEMA_2K: u32 = 3;
359pub const AV_PROFILE_JPEG2000_DCINEMA_4K: u32 = 4;
360pub const AV_PROFILE_VP9_0: u32 = 0;
361pub const AV_PROFILE_VP9_1: u32 = 1;
362pub const AV_PROFILE_VP9_2: u32 = 2;
363pub const AV_PROFILE_VP9_3: u32 = 3;
364pub const AV_PROFILE_HEVC_MAIN: u32 = 1;
365pub const AV_PROFILE_HEVC_MAIN_10: u32 = 2;
366pub const AV_PROFILE_HEVC_MAIN_STILL_PICTURE: u32 = 3;
367pub const AV_PROFILE_HEVC_REXT: u32 = 4;
368pub const AV_PROFILE_HEVC_SCC: u32 = 9;
369pub const AV_PROFILE_VVC_MAIN_10: u32 = 1;
370pub const AV_PROFILE_VVC_MAIN_10_444: u32 = 33;
371pub const AV_PROFILE_AV1_MAIN: u32 = 0;
372pub const AV_PROFILE_AV1_HIGH: u32 = 1;
373pub const AV_PROFILE_AV1_PROFESSIONAL: u32 = 2;
374pub const AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT: u32 = 192;
375pub const AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT: u32 = 193;
376pub const AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT: u32 = 194;
377pub const AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS: u32 = 195;
378pub const AV_PROFILE_MJPEG_JPEG_LS: u32 = 247;
379pub const AV_PROFILE_SBC_MSBC: u32 = 1;
380pub const AV_PROFILE_PRORES_PROXY: u32 = 0;
381pub const AV_PROFILE_PRORES_LT: u32 = 1;
382pub const AV_PROFILE_PRORES_STANDARD: u32 = 2;
383pub const AV_PROFILE_PRORES_HQ: u32 = 3;
384pub const AV_PROFILE_PRORES_4444: u32 = 4;
385pub const AV_PROFILE_PRORES_XQ: u32 = 5;
386pub const AV_PROFILE_ARIB_PROFILE_A: u32 = 0;
387pub const AV_PROFILE_ARIB_PROFILE_C: u32 = 1;
388pub const AV_PROFILE_KLVA_SYNC: u32 = 0;
389pub const AV_PROFILE_KLVA_ASYNC: u32 = 1;
390pub const AV_PROFILE_EVC_BASELINE: u32 = 0;
391pub const AV_PROFILE_EVC_MAIN: u32 = 1;
392pub const AV_LEVEL_UNKNOWN: i32 = -99;
393pub const AV_PKT_FLAG_KEY: u32 = 1;
394pub const AV_PKT_FLAG_CORRUPT: u32 = 2;
395pub const AV_PKT_FLAG_DISCARD: u32 = 4;
396pub const AV_PKT_FLAG_TRUSTED: u32 = 8;
397pub const AV_PKT_FLAG_DISPOSABLE: u32 = 16;
398pub const LIBAVCODEC_VERSION_MINOR: u32 = 5;
399pub const LIBAVCODEC_VERSION_MICRO: u32 = 103;
400pub const AV_CODEC_PROP_INTRA_ONLY: u32 = 1;
401pub const AV_CODEC_PROP_LOSSY: u32 = 2;
402pub const AV_CODEC_PROP_LOSSLESS: u32 = 4;
403pub const AV_CODEC_PROP_REORDER: u32 = 8;
404pub const AV_CODEC_PROP_FIELDS: u32 = 16;
405pub const AV_CODEC_PROP_BITMAP_SUB: u32 = 65536;
406pub const AV_CODEC_PROP_TEXT_SUB: u32 = 131072;
407pub const AV_INPUT_BUFFER_MIN_SIZE: u32 = 16384;
408pub const AV_CODEC_FLAG_UNALIGNED: u32 = 1;
409pub const AV_CODEC_FLAG_QSCALE: u32 = 2;
410pub const AV_CODEC_FLAG_4MV: u32 = 4;
411pub const AV_CODEC_FLAG_OUTPUT_CORRUPT: u32 = 8;
412pub const AV_CODEC_FLAG_QPEL: u32 = 16;
413pub const AV_CODEC_FLAG_DROPCHANGED: u32 = 32;
414pub const AV_CODEC_FLAG_RECON_FRAME: u32 = 64;
415pub const AV_CODEC_FLAG_COPY_OPAQUE: u32 = 128;
416pub const AV_CODEC_FLAG_FRAME_DURATION: u32 = 256;
417pub const AV_CODEC_FLAG_PASS1: u32 = 512;
418pub const AV_CODEC_FLAG_PASS2: u32 = 1024;
419pub const AV_CODEC_FLAG_LOOP_FILTER: u32 = 2048;
420pub const AV_CODEC_FLAG_GRAY: u32 = 8192;
421pub const AV_CODEC_FLAG_PSNR: u32 = 32768;
422pub const AV_CODEC_FLAG_INTERLACED_DCT: u32 = 262144;
423pub const AV_CODEC_FLAG_LOW_DELAY: u32 = 524288;
424pub const AV_CODEC_FLAG_GLOBAL_HEADER: u32 = 4194304;
425pub const AV_CODEC_FLAG_BITEXACT: u32 = 8388608;
426pub const AV_CODEC_FLAG_AC_PRED: u32 = 16777216;
427pub const AV_CODEC_FLAG_INTERLACED_ME: u32 = 536870912;
428pub const AV_CODEC_FLAG_CLOSED_GOP: u32 = 2147483648;
429pub const AV_CODEC_FLAG2_FAST: u32 = 1;
430pub const AV_CODEC_FLAG2_NO_OUTPUT: u32 = 4;
431pub const AV_CODEC_FLAG2_LOCAL_HEADER: u32 = 8;
432pub const AV_CODEC_FLAG2_CHUNKS: u32 = 32768;
433pub const AV_CODEC_FLAG2_IGNORE_CROP: u32 = 65536;
434pub const AV_CODEC_FLAG2_SHOW_ALL: u32 = 4194304;
435pub const AV_CODEC_FLAG2_EXPORT_MVS: u32 = 268435456;
436pub const AV_CODEC_FLAG2_SKIP_MANUAL: u32 = 536870912;
437pub const AV_CODEC_FLAG2_RO_FLUSH_NOOP: u32 = 1073741824;
438pub const AV_CODEC_FLAG2_ICC_PROFILES: u32 = 2147483648;
439pub const AV_CODEC_EXPORT_DATA_MVS: u32 = 1;
440pub const AV_CODEC_EXPORT_DATA_PRFT: u32 = 2;
441pub const AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS: u32 = 4;
442pub const AV_CODEC_EXPORT_DATA_FILM_GRAIN: u32 = 8;
443pub const AV_GET_BUFFER_FLAG_REF: u32 = 1;
444pub const AV_GET_ENCODE_BUFFER_FLAG_REF: u32 = 1;
445pub const SLICE_FLAG_CODED_ORDER: u32 = 1;
446pub const SLICE_FLAG_ALLOW_FIELD: u32 = 2;
447pub const SLICE_FLAG_ALLOW_PLANE: u32 = 4;
448pub const FF_CMP_SAD: u32 = 0;
449pub const FF_CMP_SSE: u32 = 1;
450pub const FF_CMP_SATD: u32 = 2;
451pub const FF_CMP_DCT: u32 = 3;
452pub const FF_CMP_PSNR: u32 = 4;
453pub const FF_CMP_BIT: u32 = 5;
454pub const FF_CMP_RD: u32 = 6;
455pub const FF_CMP_ZERO: u32 = 7;
456pub const FF_CMP_VSAD: u32 = 8;
457pub const FF_CMP_VSSE: u32 = 9;
458pub const FF_CMP_NSSE: u32 = 10;
459pub const FF_CMP_W53: u32 = 11;
460pub const FF_CMP_W97: u32 = 12;
461pub const FF_CMP_DCTMAX: u32 = 13;
462pub const FF_CMP_DCT264: u32 = 14;
463pub const FF_CMP_MEDIAN_SAD: u32 = 15;
464pub const FF_CMP_CHROMA: u32 = 256;
465pub const FF_MB_DECISION_SIMPLE: u32 = 0;
466pub const FF_MB_DECISION_BITS: u32 = 1;
467pub const FF_MB_DECISION_RD: u32 = 2;
468pub const FF_COMPRESSION_DEFAULT: i32 = -1;
469pub const FF_BUG_AUTODETECT: u32 = 1;
470pub const FF_BUG_XVID_ILACE: u32 = 4;
471pub const FF_BUG_UMP4: u32 = 8;
472pub const FF_BUG_NO_PADDING: u32 = 16;
473pub const FF_BUG_AMV: u32 = 32;
474pub const FF_BUG_QPEL_CHROMA: u32 = 64;
475pub const FF_BUG_STD_QPEL: u32 = 128;
476pub const FF_BUG_QPEL_CHROMA2: u32 = 256;
477pub const FF_BUG_DIRECT_BLOCKSIZE: u32 = 512;
478pub const FF_BUG_EDGE: u32 = 1024;
479pub const FF_BUG_HPEL_CHROMA: u32 = 2048;
480pub const FF_BUG_DC_CLIP: u32 = 4096;
481pub const FF_BUG_MS: u32 = 8192;
482pub const FF_BUG_TRUNCATED: u32 = 16384;
483pub const FF_BUG_IEDGE: u32 = 32768;
484pub const FF_EC_GUESS_MVS: u32 = 1;
485pub const FF_EC_DEBLOCK: u32 = 2;
486pub const FF_EC_FAVOR_INTER: u32 = 256;
487pub const FF_DEBUG_PICT_INFO: u32 = 1;
488pub const FF_DEBUG_RC: u32 = 2;
489pub const FF_DEBUG_BITSTREAM: u32 = 4;
490pub const FF_DEBUG_MB_TYPE: u32 = 8;
491pub const FF_DEBUG_QP: u32 = 16;
492pub const FF_DEBUG_DCT_COEFF: u32 = 64;
493pub const FF_DEBUG_SKIP: u32 = 128;
494pub const FF_DEBUG_STARTCODE: u32 = 256;
495pub const FF_DEBUG_ER: u32 = 1024;
496pub const FF_DEBUG_MMCO: u32 = 2048;
497pub const FF_DEBUG_BUGS: u32 = 4096;
498pub const FF_DEBUG_BUFFERS: u32 = 32768;
499pub const FF_DEBUG_THREADS: u32 = 65536;
500pub const FF_DEBUG_GREEN_MD: u32 = 8388608;
501pub const FF_DEBUG_NOMC: u32 = 16777216;
502pub const FF_DCT_AUTO: u32 = 0;
503pub const FF_DCT_FASTINT: u32 = 1;
504pub const FF_DCT_INT: u32 = 2;
505pub const FF_DCT_MMX: u32 = 3;
506pub const FF_DCT_ALTIVEC: u32 = 5;
507pub const FF_DCT_FAAN: u32 = 6;
508pub const FF_IDCT_AUTO: u32 = 0;
509pub const FF_IDCT_INT: u32 = 1;
510pub const FF_IDCT_SIMPLE: u32 = 2;
511pub const FF_IDCT_SIMPLEMMX: u32 = 3;
512pub const FF_IDCT_ARM: u32 = 7;
513pub const FF_IDCT_ALTIVEC: u32 = 8;
514pub const FF_IDCT_SIMPLEARM: u32 = 10;
515pub const FF_IDCT_XVID: u32 = 14;
516pub const FF_IDCT_SIMPLEARMV5TE: u32 = 16;
517pub const FF_IDCT_SIMPLEARMV6: u32 = 17;
518pub const FF_IDCT_FAAN: u32 = 20;
519pub const FF_IDCT_SIMPLENEON: u32 = 22;
520pub const FF_IDCT_SIMPLEAUTO: u32 = 128;
521pub const FF_THREAD_FRAME: u32 = 1;
522pub const FF_THREAD_SLICE: u32 = 2;
523pub const FF_PROFILE_UNKNOWN: i32 = -99;
524pub const FF_PROFILE_RESERVED: i32 = -100;
525pub const FF_PROFILE_AAC_MAIN: u32 = 0;
526pub const FF_PROFILE_AAC_LOW: u32 = 1;
527pub const FF_PROFILE_AAC_SSR: u32 = 2;
528pub const FF_PROFILE_AAC_LTP: u32 = 3;
529pub const FF_PROFILE_AAC_HE: u32 = 4;
530pub const FF_PROFILE_AAC_HE_V2: u32 = 28;
531pub const FF_PROFILE_AAC_LD: u32 = 22;
532pub const FF_PROFILE_AAC_ELD: u32 = 38;
533pub const FF_PROFILE_MPEG2_AAC_LOW: u32 = 128;
534pub const FF_PROFILE_MPEG2_AAC_HE: u32 = 131;
535pub const FF_PROFILE_DNXHD: u32 = 0;
536pub const FF_PROFILE_DNXHR_LB: u32 = 1;
537pub const FF_PROFILE_DNXHR_SQ: u32 = 2;
538pub const FF_PROFILE_DNXHR_HQ: u32 = 3;
539pub const FF_PROFILE_DNXHR_HQX: u32 = 4;
540pub const FF_PROFILE_DNXHR_444: u32 = 5;
541pub const FF_PROFILE_DTS: u32 = 20;
542pub const FF_PROFILE_DTS_ES: u32 = 30;
543pub const FF_PROFILE_DTS_96_24: u32 = 40;
544pub const FF_PROFILE_DTS_HD_HRA: u32 = 50;
545pub const FF_PROFILE_DTS_HD_MA: u32 = 60;
546pub const FF_PROFILE_DTS_EXPRESS: u32 = 70;
547pub const FF_PROFILE_DTS_HD_MA_X: u32 = 61;
548pub const FF_PROFILE_DTS_HD_MA_X_IMAX: u32 = 62;
549pub const FF_PROFILE_EAC3_DDP_ATMOS: u32 = 30;
550pub const FF_PROFILE_TRUEHD_ATMOS: u32 = 30;
551pub const FF_PROFILE_MPEG2_422: u32 = 0;
552pub const FF_PROFILE_MPEG2_HIGH: u32 = 1;
553pub const FF_PROFILE_MPEG2_SS: u32 = 2;
554pub const FF_PROFILE_MPEG2_SNR_SCALABLE: u32 = 3;
555pub const FF_PROFILE_MPEG2_MAIN: u32 = 4;
556pub const FF_PROFILE_MPEG2_SIMPLE: u32 = 5;
557pub const FF_PROFILE_H264_CONSTRAINED: u32 = 512;
558pub const FF_PROFILE_H264_INTRA: u32 = 2048;
559pub const FF_PROFILE_H264_BASELINE: u32 = 66;
560pub const FF_PROFILE_H264_CONSTRAINED_BASELINE: u32 = 578;
561pub const FF_PROFILE_H264_MAIN: u32 = 77;
562pub const FF_PROFILE_H264_EXTENDED: u32 = 88;
563pub const FF_PROFILE_H264_HIGH: u32 = 100;
564pub const FF_PROFILE_H264_HIGH_10: u32 = 110;
565pub const FF_PROFILE_H264_HIGH_10_INTRA: u32 = 2158;
566pub const FF_PROFILE_H264_MULTIVIEW_HIGH: u32 = 118;
567pub const FF_PROFILE_H264_HIGH_422: u32 = 122;
568pub const FF_PROFILE_H264_HIGH_422_INTRA: u32 = 2170;
569pub const FF_PROFILE_H264_STEREO_HIGH: u32 = 128;
570pub const FF_PROFILE_H264_HIGH_444: u32 = 144;
571pub const FF_PROFILE_H264_HIGH_444_PREDICTIVE: u32 = 244;
572pub const FF_PROFILE_H264_HIGH_444_INTRA: u32 = 2292;
573pub const FF_PROFILE_H264_CAVLC_444: u32 = 44;
574pub const FF_PROFILE_VC1_SIMPLE: u32 = 0;
575pub const FF_PROFILE_VC1_MAIN: u32 = 1;
576pub const FF_PROFILE_VC1_COMPLEX: u32 = 2;
577pub const FF_PROFILE_VC1_ADVANCED: u32 = 3;
578pub const FF_PROFILE_MPEG4_SIMPLE: u32 = 0;
579pub const FF_PROFILE_MPEG4_SIMPLE_SCALABLE: u32 = 1;
580pub const FF_PROFILE_MPEG4_CORE: u32 = 2;
581pub const FF_PROFILE_MPEG4_MAIN: u32 = 3;
582pub const FF_PROFILE_MPEG4_N_BIT: u32 = 4;
583pub const FF_PROFILE_MPEG4_SCALABLE_TEXTURE: u32 = 5;
584pub const FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION: u32 = 6;
585pub const FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE: u32 = 7;
586pub const FF_PROFILE_MPEG4_HYBRID: u32 = 8;
587pub const FF_PROFILE_MPEG4_ADVANCED_REAL_TIME: u32 = 9;
588pub const FF_PROFILE_MPEG4_CORE_SCALABLE: u32 = 10;
589pub const FF_PROFILE_MPEG4_ADVANCED_CODING: u32 = 11;
590pub const FF_PROFILE_MPEG4_ADVANCED_CORE: u32 = 12;
591pub const FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE: u32 = 13;
592pub const FF_PROFILE_MPEG4_SIMPLE_STUDIO: u32 = 14;
593pub const FF_PROFILE_MPEG4_ADVANCED_SIMPLE: u32 = 15;
594pub const FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0: u32 = 1;
595pub const FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1: u32 = 2;
596pub const FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION: u32 = 32768;
597pub const FF_PROFILE_JPEG2000_DCINEMA_2K: u32 = 3;
598pub const FF_PROFILE_JPEG2000_DCINEMA_4K: u32 = 4;
599pub const FF_PROFILE_VP9_0: u32 = 0;
600pub const FF_PROFILE_VP9_1: u32 = 1;
601pub const FF_PROFILE_VP9_2: u32 = 2;
602pub const FF_PROFILE_VP9_3: u32 = 3;
603pub const FF_PROFILE_HEVC_MAIN: u32 = 1;
604pub const FF_PROFILE_HEVC_MAIN_10: u32 = 2;
605pub const FF_PROFILE_HEVC_MAIN_STILL_PICTURE: u32 = 3;
606pub const FF_PROFILE_HEVC_REXT: u32 = 4;
607pub const FF_PROFILE_HEVC_SCC: u32 = 9;
608pub const FF_PROFILE_VVC_MAIN_10: u32 = 1;
609pub const FF_PROFILE_VVC_MAIN_10_444: u32 = 33;
610pub const FF_PROFILE_AV1_MAIN: u32 = 0;
611pub const FF_PROFILE_AV1_HIGH: u32 = 1;
612pub const FF_PROFILE_AV1_PROFESSIONAL: u32 = 2;
613pub const FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT: u32 = 192;
614pub const FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT: u32 = 193;
615pub const FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT: u32 = 194;
616pub const FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS: u32 = 195;
617pub const FF_PROFILE_MJPEG_JPEG_LS: u32 = 247;
618pub const FF_PROFILE_SBC_MSBC: u32 = 1;
619pub const FF_PROFILE_PRORES_PROXY: u32 = 0;
620pub const FF_PROFILE_PRORES_LT: u32 = 1;
621pub const FF_PROFILE_PRORES_STANDARD: u32 = 2;
622pub const FF_PROFILE_PRORES_HQ: u32 = 3;
623pub const FF_PROFILE_PRORES_4444: u32 = 4;
624pub const FF_PROFILE_PRORES_XQ: u32 = 5;
625pub const FF_PROFILE_ARIB_PROFILE_A: u32 = 0;
626pub const FF_PROFILE_ARIB_PROFILE_C: u32 = 1;
627pub const FF_PROFILE_KLVA_SYNC: u32 = 0;
628pub const FF_PROFILE_KLVA_ASYNC: u32 = 1;
629pub const FF_PROFILE_EVC_BASELINE: u32 = 0;
630pub const FF_PROFILE_EVC_MAIN: u32 = 1;
631pub const FF_LEVEL_UNKNOWN: i32 = -99;
632pub const FF_CODEC_PROPERTY_LOSSLESS: u32 = 1;
633pub const FF_CODEC_PROPERTY_CLOSED_CAPTIONS: u32 = 2;
634pub const FF_CODEC_PROPERTY_FILM_GRAIN: u32 = 4;
635pub const FF_SUB_CHARENC_MODE_DO_NOTHING: i32 = -1;
636pub const FF_SUB_CHARENC_MODE_AUTOMATIC: u32 = 0;
637pub const FF_SUB_CHARENC_MODE_PRE_DECODER: u32 = 1;
638pub const FF_SUB_CHARENC_MODE_IGNORE: u32 = 2;
639pub const AV_HWACCEL_CODEC_CAP_EXPERIMENTAL: u32 = 512;
640pub const AV_HWACCEL_FLAG_IGNORE_LEVEL: u32 = 1;
641pub const AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH: u32 = 2;
642pub const AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH: u32 = 4;
643pub const AV_HWACCEL_FLAG_UNSAFE_OUTPUT: u32 = 8;
644pub const AV_SUBTITLE_FLAG_FORCED: u32 = 1;
645pub const AV_PARSER_PTS_NB: u32 = 4;
646pub const PARSER_FLAG_COMPLETE_FRAMES: u32 = 1;
647pub const PARSER_FLAG_ONCE: u32 = 2;
648pub const PARSER_FLAG_FETCHED_OFFSET: u32 = 4;
649pub const PARSER_FLAG_USE_CODEC_TS: u32 = 4096;
650pub type intmax_t = ::std::os::raw::c_longlong;
651pub type uintmax_t = ::std::os::raw::c_ulonglong;
652pub type time_t = ::std::os::raw::c_longlong;
653pub type suseconds_t = ::std::os::raw::c_longlong;
654#[repr(C)]
655#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
656pub struct timeval {
657 pub tv_sec: time_t,
658 pub tv_usec: suseconds_t,
659}
660#[repr(C)]
661#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
662pub struct timespec {
663 pub tv_sec: time_t,
664 pub tv_nsec: ::std::os::raw::c_long,
665}
666#[repr(C)]
667#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
668pub struct iovec {
669 pub iov_base: *mut ::std::os::raw::c_void,
670 pub iov_len: usize,
671}
672impl Default for iovec {
673 fn default() -> Self {
674 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
675 unsafe {
676 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
677 s.assume_init()
678 }
679 }
680}
681pub type int_fast8_t = i8;
682pub type int_fast64_t = i64;
683pub type int_least8_t = i8;
684pub type int_least16_t = i16;
685pub type int_least32_t = i32;
686pub type int_least64_t = i64;
687pub type uint_fast8_t = u8;
688pub type uint_fast64_t = u64;
689pub type uint_least8_t = u8;
690pub type uint_least16_t = u16;
691pub type uint_least32_t = u32;
692pub type uint_least64_t = u64;
693pub type int_fast16_t = i16;
694pub type int_fast32_t = i32;
695pub type uint_fast16_t = u16;
696pub type uint_fast32_t = u32;
697pub const AVSampleFormat_AV_SAMPLE_FMT_NONE: AVSampleFormat = -1;
698#[doc = "< unsigned 8 bits"]
699pub const AVSampleFormat_AV_SAMPLE_FMT_U8: AVSampleFormat = 0;
700#[doc = "< signed 16 bits"]
701pub const AVSampleFormat_AV_SAMPLE_FMT_S16: AVSampleFormat = 1;
702#[doc = "< signed 32 bits"]
703pub const AVSampleFormat_AV_SAMPLE_FMT_S32: AVSampleFormat = 2;
704#[doc = "< float"]
705pub const AVSampleFormat_AV_SAMPLE_FMT_FLT: AVSampleFormat = 3;
706#[doc = "< double"]
707pub const AVSampleFormat_AV_SAMPLE_FMT_DBL: AVSampleFormat = 4;
708#[doc = "< unsigned 8 bits, planar"]
709pub const AVSampleFormat_AV_SAMPLE_FMT_U8P: AVSampleFormat = 5;
710#[doc = "< signed 16 bits, planar"]
711pub const AVSampleFormat_AV_SAMPLE_FMT_S16P: AVSampleFormat = 6;
712#[doc = "< signed 32 bits, planar"]
713pub const AVSampleFormat_AV_SAMPLE_FMT_S32P: AVSampleFormat = 7;
714#[doc = "< float, planar"]
715pub const AVSampleFormat_AV_SAMPLE_FMT_FLTP: AVSampleFormat = 8;
716#[doc = "< double, planar"]
717pub const AVSampleFormat_AV_SAMPLE_FMT_DBLP: AVSampleFormat = 9;
718#[doc = "< signed 64 bits"]
719pub const AVSampleFormat_AV_SAMPLE_FMT_S64: AVSampleFormat = 10;
720#[doc = "< signed 64 bits, planar"]
721pub const AVSampleFormat_AV_SAMPLE_FMT_S64P: AVSampleFormat = 11;
722#[doc = "< Number of sample formats. DO NOT USE if linking dynamically"]
723pub const AVSampleFormat_AV_SAMPLE_FMT_NB: AVSampleFormat = 12;
724#[doc = " Audio sample formats\n\n - The data described by the sample format is always in native-endian order.\n Sample values can be expressed by native C types, hence the lack of a signed\n 24-bit sample format even though it is a common raw audio data format.\n\n - The floating-point formats are based on full volume being in the range\n [-1.0, 1.0]. Any values outside this range are beyond full volume level.\n\n - The data layout as used in av_samples_fill_arrays() and elsewhere in FFmpeg\n (such as AVFrame in libavcodec) is as follows:\n\n @par\n For planar sample formats, each audio channel is in a separate data plane,\n and linesize is the buffer size, in bytes, for a single plane. All data\n planes must be the same size. For packed sample formats, only the first data\n plane is used, and samples for each channel are interleaved. In this case,\n linesize is the buffer size, in bytes, for the 1 plane.\n"]
725pub type AVSampleFormat = ::std::os::raw::c_int;
726extern "C" {
727 #[doc = " Return the name of sample_fmt, or NULL if sample_fmt is not\n recognized."]
728 pub fn av_get_sample_fmt_name(sample_fmt: AVSampleFormat) -> *const ::std::os::raw::c_char;
729}
730extern "C" {
731 #[doc = " Return a sample format corresponding to name, or AV_SAMPLE_FMT_NONE\n on error."]
732 pub fn av_get_sample_fmt(name: *const ::std::os::raw::c_char) -> AVSampleFormat;
733}
734extern "C" {
735 #[doc = " Return the planar<->packed alternative form of the given sample format, or\n AV_SAMPLE_FMT_NONE on error. If the passed sample_fmt is already in the\n requested planar/packed format, the format returned is the same as the\n input."]
736 pub fn av_get_alt_sample_fmt(
737 sample_fmt: AVSampleFormat,
738 planar: ::std::os::raw::c_int,
739 ) -> AVSampleFormat;
740}
741extern "C" {
742 #[doc = " Get the packed alternative form of the given sample format.\n\n If the passed sample_fmt is already in packed format, the format returned is\n the same as the input.\n\n @return the packed alternative form of the given sample format or\nAV_SAMPLE_FMT_NONE on error."]
743 pub fn av_get_packed_sample_fmt(sample_fmt: AVSampleFormat) -> AVSampleFormat;
744}
745extern "C" {
746 #[doc = " Get the planar alternative form of the given sample format.\n\n If the passed sample_fmt is already in planar format, the format returned is\n the same as the input.\n\n @return the planar alternative form of the given sample format or\nAV_SAMPLE_FMT_NONE on error."]
747 pub fn av_get_planar_sample_fmt(sample_fmt: AVSampleFormat) -> AVSampleFormat;
748}
749extern "C" {
750 #[doc = " Generate a string corresponding to the sample format with\n sample_fmt, or a header if sample_fmt is negative.\n\n @param buf the buffer where to write the string\n @param buf_size the size of buf\n @param sample_fmt the number of the sample format to print the\n corresponding info string, or a negative value to print the\n corresponding header.\n @return the pointer to the filled buffer or NULL if sample_fmt is\n unknown or in case of other errors"]
751 pub fn av_get_sample_fmt_string(
752 buf: *mut ::std::os::raw::c_char,
753 buf_size: ::std::os::raw::c_int,
754 sample_fmt: AVSampleFormat,
755 ) -> *mut ::std::os::raw::c_char;
756}
757extern "C" {
758 #[doc = " Return number of bytes per sample.\n\n @param sample_fmt the sample format\n @return number of bytes per sample or zero if unknown for the given\n sample format"]
759 pub fn av_get_bytes_per_sample(sample_fmt: AVSampleFormat) -> ::std::os::raw::c_int;
760}
761extern "C" {
762 #[doc = " Check if the sample format is planar.\n\n @param sample_fmt the sample format to inspect\n @return 1 if the sample format is planar, 0 if it is interleaved"]
763 pub fn av_sample_fmt_is_planar(sample_fmt: AVSampleFormat) -> ::std::os::raw::c_int;
764}
765extern "C" {
766 #[doc = " Get the required buffer size for the given audio parameters.\n\n @param[out] linesize calculated linesize, may be NULL\n @param nb_channels the number of channels\n @param nb_samples the number of samples in a single channel\n @param sample_fmt the sample format\n @param align buffer size alignment (0 = default, 1 = no alignment)\n @return required buffer size, or negative error code on failure"]
767 pub fn av_samples_get_buffer_size(
768 linesize: *mut ::std::os::raw::c_int,
769 nb_channels: ::std::os::raw::c_int,
770 nb_samples: ::std::os::raw::c_int,
771 sample_fmt: AVSampleFormat,
772 align: ::std::os::raw::c_int,
773 ) -> ::std::os::raw::c_int;
774}
775extern "C" {
776 #[doc = " Fill plane data pointers and linesize for samples with sample\n format sample_fmt.\n\n The audio_data array is filled with the pointers to the samples data planes:\n for planar, set the start point of each channel's data within the buffer,\n for packed, set the start point of the entire buffer only.\n\n The value pointed to by linesize is set to the aligned size of each\n channel's data buffer for planar layout, or to the aligned size of the\n buffer for all channels for packed layout.\n\n The buffer in buf must be big enough to contain all the samples\n (use av_samples_get_buffer_size() to compute its minimum size),\n otherwise the audio_data pointers will point to invalid data.\n\n @see enum AVSampleFormat\n The documentation for AVSampleFormat describes the data layout.\n\n @param[out] audio_data array to be filled with the pointer for each channel\n @param[out] linesize calculated linesize, may be NULL\n @param buf the pointer to a buffer containing the samples\n @param nb_channels the number of channels\n @param nb_samples the number of samples in a single channel\n @param sample_fmt the sample format\n @param align buffer size alignment (0 = default, 1 = no alignment)\n @return minimum size in bytes required for the buffer on success,\n or a negative error code on failure"]
777 pub fn av_samples_fill_arrays(
778 audio_data: *mut *mut u8,
779 linesize: *mut ::std::os::raw::c_int,
780 buf: *const u8,
781 nb_channels: ::std::os::raw::c_int,
782 nb_samples: ::std::os::raw::c_int,
783 sample_fmt: AVSampleFormat,
784 align: ::std::os::raw::c_int,
785 ) -> ::std::os::raw::c_int;
786}
787extern "C" {
788 #[doc = " Allocate a samples buffer for nb_samples samples, and fill data pointers and\n linesize accordingly.\n The allocated samples buffer can be freed by using av_freep(&audio_data[0])\n Allocated data will be initialized to silence.\n\n @see enum AVSampleFormat\n The documentation for AVSampleFormat describes the data layout.\n\n @param[out] audio_data array to be filled with the pointer for each channel\n @param[out] linesize aligned size for audio buffer(s), may be NULL\n @param nb_channels number of audio channels\n @param nb_samples number of samples per channel\n @param sample_fmt the sample format\n @param align buffer size alignment (0 = default, 1 = no alignment)\n @return >=0 on success or a negative error code on failure\n @todo return the size of the allocated buffer in case of success at the next bump\n @see av_samples_fill_arrays()\n @see av_samples_alloc_array_and_samples()"]
789 pub fn av_samples_alloc(
790 audio_data: *mut *mut u8,
791 linesize: *mut ::std::os::raw::c_int,
792 nb_channels: ::std::os::raw::c_int,
793 nb_samples: ::std::os::raw::c_int,
794 sample_fmt: AVSampleFormat,
795 align: ::std::os::raw::c_int,
796 ) -> ::std::os::raw::c_int;
797}
798extern "C" {
799 #[doc = " Allocate a data pointers array, samples buffer for nb_samples\n samples, and fill data pointers and linesize accordingly.\n\n This is the same as av_samples_alloc(), but also allocates the data\n pointers array.\n\n @see av_samples_alloc()"]
800 pub fn av_samples_alloc_array_and_samples(
801 audio_data: *mut *mut *mut u8,
802 linesize: *mut ::std::os::raw::c_int,
803 nb_channels: ::std::os::raw::c_int,
804 nb_samples: ::std::os::raw::c_int,
805 sample_fmt: AVSampleFormat,
806 align: ::std::os::raw::c_int,
807 ) -> ::std::os::raw::c_int;
808}
809extern "C" {
810 #[doc = " Copy samples from src to dst.\n\n @param dst destination array of pointers to data planes\n @param src source array of pointers to data planes\n @param dst_offset offset in samples at which the data will be written to dst\n @param src_offset offset in samples at which the data will be read from src\n @param nb_samples number of samples to be copied\n @param nb_channels number of audio channels\n @param sample_fmt audio sample format"]
811 pub fn av_samples_copy(
812 dst: *const *mut u8,
813 src: *const *mut u8,
814 dst_offset: ::std::os::raw::c_int,
815 src_offset: ::std::os::raw::c_int,
816 nb_samples: ::std::os::raw::c_int,
817 nb_channels: ::std::os::raw::c_int,
818 sample_fmt: AVSampleFormat,
819 ) -> ::std::os::raw::c_int;
820}
821extern "C" {
822 #[doc = " Fill an audio buffer with silence.\n\n @param audio_data array of pointers to data planes\n @param offset offset in samples at which to start filling\n @param nb_samples number of samples to fill\n @param nb_channels number of audio channels\n @param sample_fmt audio sample format"]
823 pub fn av_samples_set_silence(
824 audio_data: *const *mut u8,
825 offset: ::std::os::raw::c_int,
826 nb_samples: ::std::os::raw::c_int,
827 nb_channels: ::std::os::raw::c_int,
828 sample_fmt: AVSampleFormat,
829 ) -> ::std::os::raw::c_int;
830}
831extern "C" {
832 #[doc = " Return the LIBAVUTIL_VERSION_INT constant."]
833 pub fn avutil_version() -> ::std::os::raw::c_uint;
834}
835extern "C" {
836 #[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."]
837 pub fn av_version_info() -> *const ::std::os::raw::c_char;
838}
839extern "C" {
840 #[doc = " Return the libavutil build-time configuration."]
841 pub fn avutil_configuration() -> *const ::std::os::raw::c_char;
842}
843extern "C" {
844 #[doc = " Return the libavutil license."]
845 pub fn avutil_license() -> *const ::std::os::raw::c_char;
846}
847#[doc = "< Usually treated as AVMEDIA_TYPE_DATA"]
848pub const AVMediaType_AVMEDIA_TYPE_UNKNOWN: AVMediaType = -1;
849pub const AVMediaType_AVMEDIA_TYPE_VIDEO: AVMediaType = 0;
850pub const AVMediaType_AVMEDIA_TYPE_AUDIO: AVMediaType = 1;
851#[doc = "< Opaque data information usually continuous"]
852pub const AVMediaType_AVMEDIA_TYPE_DATA: AVMediaType = 2;
853pub const AVMediaType_AVMEDIA_TYPE_SUBTITLE: AVMediaType = 3;
854#[doc = "< Opaque data information usually sparse"]
855pub const AVMediaType_AVMEDIA_TYPE_ATTACHMENT: AVMediaType = 4;
856pub const AVMediaType_AVMEDIA_TYPE_NB: AVMediaType = 5;
857#[doc = " @addtogroup lavu_media Media Type\n @brief Media Type"]
858pub type AVMediaType = ::std::os::raw::c_int;
859extern "C" {
860 #[doc = " Return a string describing the media_type enum, NULL if media_type\n is unknown."]
861 pub fn av_get_media_type_string(media_type: AVMediaType) -> *const ::std::os::raw::c_char;
862}
863#[doc = "< Undefined"]
864pub const AVPictureType_AV_PICTURE_TYPE_NONE: AVPictureType = 0;
865#[doc = "< Intra"]
866pub const AVPictureType_AV_PICTURE_TYPE_I: AVPictureType = 1;
867#[doc = "< Predicted"]
868pub const AVPictureType_AV_PICTURE_TYPE_P: AVPictureType = 2;
869#[doc = "< Bi-dir predicted"]
870pub const AVPictureType_AV_PICTURE_TYPE_B: AVPictureType = 3;
871#[doc = "< S(GMC)-VOP MPEG-4"]
872pub const AVPictureType_AV_PICTURE_TYPE_S: AVPictureType = 4;
873#[doc = "< Switching Intra"]
874pub const AVPictureType_AV_PICTURE_TYPE_SI: AVPictureType = 5;
875#[doc = "< Switching Predicted"]
876pub const AVPictureType_AV_PICTURE_TYPE_SP: AVPictureType = 6;
877#[doc = "< BI type"]
878pub const AVPictureType_AV_PICTURE_TYPE_BI: AVPictureType = 7;
879#[doc = " @}\n @}\n @defgroup lavu_picture Image related\n\n AVPicture types, pixel formats and basic image planes manipulation.\n\n @{"]
880pub type AVPictureType = ::std::os::raw::c_uint;
881extern "C" {
882 #[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"]
883 pub fn av_get_picture_type_char(pict_type: AVPictureType) -> ::std::os::raw::c_char;
884}
885extern "C" {
886 pub static mut errno: ::std::os::raw::c_int;
887}
888pub type wchar_t = ::std::os::raw::c_int;
889#[repr(C)]
890#[repr(align(16))]
891#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)]
892pub struct max_align_t {
893 pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
894 pub __bindgen_padding_0: u64,
895 pub __clang_max_align_nonce2: u128,
896}
897pub type __wasi_size_t = ::std::os::raw::c_ulong;
898#[doc = " Non-negative file size or length of a region within a file."]
899pub type __wasi_filesize_t = u64;
900#[doc = " Timestamp in nanoseconds."]
901pub type __wasi_timestamp_t = u64;
902#[doc = " Identifiers for clocks."]
903pub type __wasi_clockid_t = u32;
904#[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."]
905pub type __wasi_errno_t = u16;
906#[doc = " File descriptor rights, determining which actions may be performed."]
907pub type __wasi_rights_t = u64;
908#[doc = " A file descriptor handle."]
909pub type __wasi_fd_t = ::std::os::raw::c_int;
910#[doc = " A region of memory for scatter/gather reads."]
911#[repr(C)]
912#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
913pub struct __wasi_iovec_t {
914 #[doc = " The address of the buffer to be filled."]
915 pub buf: *mut u8,
916 #[doc = " The length of the buffer to be filled."]
917 pub buf_len: __wasi_size_t,
918}
919impl Default for __wasi_iovec_t {
920 fn default() -> Self {
921 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
922 unsafe {
923 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
924 s.assume_init()
925 }
926 }
927}
928#[doc = " A region of memory for scatter/gather writes."]
929#[repr(C)]
930#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
931pub struct __wasi_ciovec_t {
932 #[doc = " The address of the buffer to be written."]
933 pub buf: *const u8,
934 #[doc = " The length of the buffer to be written."]
935 pub buf_len: __wasi_size_t,
936}
937impl Default for __wasi_ciovec_t {
938 fn default() -> Self {
939 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
940 unsafe {
941 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
942 s.assume_init()
943 }
944 }
945}
946#[doc = " Relative offset within a file."]
947pub type __wasi_filedelta_t = i64;
948#[doc = " The position relative to which to set the offset of the file descriptor."]
949pub type __wasi_whence_t = u8;
950#[doc = " A reference to the offset of a directory entry.\n\n The value 0 signifies the start of the directory."]
951pub type __wasi_dircookie_t = u64;
952#[doc = " The type for the `dirent::d_namlen` field of `dirent` struct."]
953pub type __wasi_dirnamlen_t = u32;
954#[doc = " File serial number that is unique within its file system."]
955pub type __wasi_inode_t = u64;
956#[doc = " The type of a file descriptor or file."]
957pub type __wasi_filetype_t = u8;
958#[doc = " A directory entry."]
959#[repr(C)]
960#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
961pub struct __wasi_dirent_t {
962 #[doc = " The offset of the next directory entry stored in this directory."]
963 pub d_next: __wasi_dircookie_t,
964 #[doc = " The serial number of the file referred to by this directory entry."]
965 pub d_ino: __wasi_inode_t,
966 #[doc = " The length of the name of the directory entry."]
967 pub d_namlen: __wasi_dirnamlen_t,
968 #[doc = " The type of the file referred to by this directory entry."]
969 pub d_type: __wasi_filetype_t,
970}
971#[doc = " File or memory access pattern advisory information."]
972pub type __wasi_advice_t = u8;
973#[doc = " File descriptor flags."]
974pub type __wasi_fdflags_t = u16;
975#[doc = " File descriptor attributes."]
976#[repr(C)]
977#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
978pub struct __wasi_fdstat_t {
979 #[doc = " File type."]
980 pub fs_filetype: __wasi_filetype_t,
981 #[doc = " File descriptor flags."]
982 pub fs_flags: __wasi_fdflags_t,
983 #[doc = " Rights that apply to this file descriptor."]
984 pub fs_rights_base: __wasi_rights_t,
985 #[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`."]
986 pub fs_rights_inheriting: __wasi_rights_t,
987}
988#[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."]
989pub type __wasi_device_t = u64;
990#[doc = " Which file time attributes to adjust."]
991pub type __wasi_fstflags_t = u16;
992#[doc = " Flags determining the method of how paths are resolved."]
993pub type __wasi_lookupflags_t = u32;
994#[doc = " Open flags used by `path_open`."]
995pub type __wasi_oflags_t = u16;
996#[doc = " Number of hard links to an inode."]
997pub type __wasi_linkcount_t = u64;
998#[doc = " File attributes."]
999#[repr(C)]
1000#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1001pub struct __wasi_filestat_t {
1002 #[doc = " Device ID of device containing the file."]
1003 pub dev: __wasi_device_t,
1004 #[doc = " File serial number."]
1005 pub ino: __wasi_inode_t,
1006 #[doc = " File type."]
1007 pub filetype: __wasi_filetype_t,
1008 #[doc = " Number of hard links to the file."]
1009 pub nlink: __wasi_linkcount_t,
1010 #[doc = " For regular files, the file size in bytes. For symbolic links, the length in bytes of the pathname contained in the symbolic link."]
1011 pub size: __wasi_filesize_t,
1012 #[doc = " Last data access timestamp."]
1013 pub atim: __wasi_timestamp_t,
1014 #[doc = " Last data modification timestamp."]
1015 pub mtim: __wasi_timestamp_t,
1016 #[doc = " Last file status change timestamp."]
1017 pub ctim: __wasi_timestamp_t,
1018}
1019#[doc = " User-provided value that may be attached to objects that is retained when\n extracted from the implementation."]
1020pub type __wasi_userdata_t = u64;
1021#[doc = " Type of a subscription to an event or its occurrence."]
1022pub type __wasi_eventtype_t = u8;
1023#[doc = " The state of the file descriptor subscribed to with\n `eventtype::fd_read` or `eventtype::fd_write`."]
1024pub type __wasi_eventrwflags_t = u16;
1025#[doc = " The contents of an `event` when type is `eventtype::fd_read` or\n `eventtype::fd_write`."]
1026#[repr(C)]
1027#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1028pub struct __wasi_event_fd_readwrite_t {
1029 #[doc = " The number of bytes available for reading or writing."]
1030 pub nbytes: __wasi_filesize_t,
1031 #[doc = " The state of the file descriptor."]
1032 pub flags: __wasi_eventrwflags_t,
1033}
1034#[doc = " An event that occurred."]
1035#[repr(C)]
1036#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1037pub struct __wasi_event_t {
1038 #[doc = " User-provided value that got attached to `subscription::userdata`."]
1039 pub userdata: __wasi_userdata_t,
1040 #[doc = " If non-zero, an error that occurred while processing the subscription request."]
1041 pub error: __wasi_errno_t,
1042 #[doc = " The type of event that occured"]
1043 pub type_: __wasi_eventtype_t,
1044 #[doc = " The contents of the event, if it is an `eventtype::fd_read` or\n `eventtype::fd_write`. `eventtype::clock` events ignore this field."]
1045 pub fd_readwrite: __wasi_event_fd_readwrite_t,
1046}
1047#[doc = " Flags determining how to interpret the timestamp provided in\n `subscription_clock::timeout`."]
1048pub type __wasi_subclockflags_t = u16;
1049#[doc = " The contents of a `subscription` when type is `eventtype::clock`."]
1050#[repr(C)]
1051#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1052pub struct __wasi_subscription_clock_t {
1053 #[doc = " The clock against which to compare the timestamp."]
1054 pub id: __wasi_clockid_t,
1055 #[doc = " The absolute or relative timestamp."]
1056 pub timeout: __wasi_timestamp_t,
1057 #[doc = " The amount of time that the implementation may wait additionally\n to coalesce with other events."]
1058 pub precision: __wasi_timestamp_t,
1059 #[doc = " Flags specifying whether the timeout is absolute or relative"]
1060 pub flags: __wasi_subclockflags_t,
1061}
1062#[doc = " The contents of a `subscription` when type is type is\n `eventtype::fd_read` or `eventtype::fd_write`."]
1063#[repr(C)]
1064#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1065pub struct __wasi_subscription_fd_readwrite_t {
1066 #[doc = " The file descriptor on which to wait for it to become ready for reading or writing."]
1067 pub file_descriptor: __wasi_fd_t,
1068}
1069#[doc = " The contents of a `subscription`."]
1070#[repr(C)]
1071#[derive(Copy, Clone)]
1072pub union __wasi_subscription_u_u_t {
1073 pub clock: __wasi_subscription_clock_t,
1074 pub fd_read: __wasi_subscription_fd_readwrite_t,
1075 pub fd_write: __wasi_subscription_fd_readwrite_t,
1076}
1077impl Default for __wasi_subscription_u_u_t {
1078 fn default() -> Self {
1079 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1080 unsafe {
1081 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1082 s.assume_init()
1083 }
1084 }
1085}
1086#[repr(C)]
1087#[derive(Copy, Clone)]
1088pub struct __wasi_subscription_u_t {
1089 pub tag: u8,
1090 pub u: __wasi_subscription_u_u_t,
1091}
1092impl Default for __wasi_subscription_u_t {
1093 fn default() -> Self {
1094 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1095 unsafe {
1096 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1097 s.assume_init()
1098 }
1099 }
1100}
1101#[doc = " Subscription to an event."]
1102#[repr(C)]
1103#[derive(Copy, Clone)]
1104pub struct __wasi_subscription_t {
1105 #[doc = " User-provided value that is attached to the subscription in the\n implementation and returned through `event::userdata`."]
1106 pub userdata: __wasi_userdata_t,
1107 #[doc = " The type of the event to which to subscribe, and its contents"]
1108 pub u: __wasi_subscription_u_t,
1109}
1110impl Default for __wasi_subscription_t {
1111 fn default() -> Self {
1112 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1113 unsafe {
1114 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1115 s.assume_init()
1116 }
1117 }
1118}
1119#[doc = " Exit code generated by a process when exiting."]
1120pub type __wasi_exitcode_t = u32;
1121#[doc = " Flags provided to `sock_recv`."]
1122pub type __wasi_riflags_t = u16;
1123#[doc = " Flags returned by `sock_recv`."]
1124pub type __wasi_roflags_t = u16;
1125#[doc = " Flags provided to `sock_send`. As there are currently no flags\n defined, it must be set to zero."]
1126pub type __wasi_siflags_t = u16;
1127#[doc = " Which channels on a socket to shut down."]
1128pub type __wasi_sdflags_t = u8;
1129#[doc = " Identifiers for preopened capabilities."]
1130pub type __wasi_preopentype_t = u8;
1131#[doc = " The contents of a $prestat when type is `preopentype::dir`."]
1132#[repr(C)]
1133#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1134pub struct __wasi_prestat_dir_t {
1135 #[doc = " The length of the directory name for use with `fd_prestat_dir_name`."]
1136 pub pr_name_len: __wasi_size_t,
1137}
1138#[doc = " Information about a pre-opened capability."]
1139#[repr(C)]
1140#[derive(Copy, Clone)]
1141pub union __wasi_prestat_u_t {
1142 pub dir: __wasi_prestat_dir_t,
1143}
1144impl Default for __wasi_prestat_u_t {
1145 fn default() -> Self {
1146 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1147 unsafe {
1148 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1149 s.assume_init()
1150 }
1151 }
1152}
1153#[repr(C)]
1154#[derive(Copy, Clone)]
1155pub struct __wasi_prestat_t {
1156 pub tag: u8,
1157 pub u: __wasi_prestat_u_t,
1158}
1159impl Default for __wasi_prestat_t {
1160 fn default() -> Self {
1161 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1162 unsafe {
1163 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1164 s.assume_init()
1165 }
1166 }
1167}
1168extern "C" {
1169 #[must_use]
1170 #[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."]
1171 pub fn __wasi_args_get(argv: *mut *mut u8, argv_buf: *mut u8) -> __wasi_errno_t;
1172}
1173extern "C" {
1174 #[must_use]
1175 #[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."]
1176 pub fn __wasi_args_sizes_get(
1177 retptr0: *mut __wasi_size_t,
1178 retptr1: *mut __wasi_size_t,
1179 ) -> __wasi_errno_t;
1180}
1181extern "C" {
1182 #[must_use]
1183 #[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."]
1184 pub fn __wasi_environ_get(environ: *mut *mut u8, environ_buf: *mut u8) -> __wasi_errno_t;
1185}
1186extern "C" {
1187 #[must_use]
1188 #[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."]
1189 pub fn __wasi_environ_sizes_get(
1190 retptr0: *mut __wasi_size_t,
1191 retptr1: *mut __wasi_size_t,
1192 ) -> __wasi_errno_t;
1193}
1194extern "C" {
1195 #[must_use]
1196 #[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."]
1197 pub fn __wasi_clock_res_get(
1198 id: __wasi_clockid_t,
1199 retptr0: *mut __wasi_timestamp_t,
1200 ) -> __wasi_errno_t;
1201}
1202extern "C" {
1203 #[must_use]
1204 #[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."]
1205 pub fn __wasi_clock_time_get(
1206 id: __wasi_clockid_t,
1207 precision: __wasi_timestamp_t,
1208 retptr0: *mut __wasi_timestamp_t,
1209 ) -> __wasi_errno_t;
1210}
1211extern "C" {
1212 #[must_use]
1213 #[doc = " Provide file advisory information on a file descriptor.\n Note: This is similar to `posix_fadvise` in POSIX."]
1214 pub fn __wasi_fd_advise(
1215 fd: __wasi_fd_t,
1216 offset: __wasi_filesize_t,
1217 len: __wasi_filesize_t,
1218 advice: __wasi_advice_t,
1219 ) -> __wasi_errno_t;
1220}
1221extern "C" {
1222 #[must_use]
1223 #[doc = " Force the allocation of space in a file.\n Note: This is similar to `posix_fallocate` in POSIX."]
1224 pub fn __wasi_fd_allocate(
1225 fd: __wasi_fd_t,
1226 offset: __wasi_filesize_t,
1227 len: __wasi_filesize_t,
1228 ) -> __wasi_errno_t;
1229}
1230extern "C" {
1231 #[must_use]
1232 #[doc = " Close a file descriptor.\n Note: This is similar to `close` in POSIX."]
1233 pub fn __wasi_fd_close(fd: __wasi_fd_t) -> __wasi_errno_t;
1234}
1235extern "C" {
1236 #[must_use]
1237 #[doc = " Synchronize the data of a file to disk.\n Note: This is similar to `fdatasync` in POSIX."]
1238 pub fn __wasi_fd_datasync(fd: __wasi_fd_t) -> __wasi_errno_t;
1239}
1240extern "C" {
1241 #[must_use]
1242 #[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."]
1243 pub fn __wasi_fd_fdstat_get(fd: __wasi_fd_t, retptr0: *mut __wasi_fdstat_t) -> __wasi_errno_t;
1244}
1245extern "C" {
1246 #[must_use]
1247 #[doc = " Adjust the flags associated with a file descriptor.\n Note: This is similar to `fcntl(fd, F_SETFL, flags)` in POSIX."]
1248 pub fn __wasi_fd_fdstat_set_flags(fd: __wasi_fd_t, flags: __wasi_fdflags_t) -> __wasi_errno_t;
1249}
1250extern "C" {
1251 #[must_use]
1252 #[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"]
1253 pub fn __wasi_fd_fdstat_set_rights(
1254 fd: __wasi_fd_t,
1255 fs_rights_base: __wasi_rights_t,
1256 fs_rights_inheriting: __wasi_rights_t,
1257 ) -> __wasi_errno_t;
1258}
1259extern "C" {
1260 #[must_use]
1261 #[doc = " Return the attributes of an open file.\n @return\n The buffer where the file's attributes are stored."]
1262 pub fn __wasi_fd_filestat_get(
1263 fd: __wasi_fd_t,
1264 retptr0: *mut __wasi_filestat_t,
1265 ) -> __wasi_errno_t;
1266}
1267extern "C" {
1268 #[must_use]
1269 #[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."]
1270 pub fn __wasi_fd_filestat_set_size(fd: __wasi_fd_t, size: __wasi_filesize_t) -> __wasi_errno_t;
1271}
1272extern "C" {
1273 #[must_use]
1274 #[doc = " Adjust the timestamps of an open file or directory.\n Note: This is similar to `futimens` in POSIX."]
1275 pub fn __wasi_fd_filestat_set_times(
1276 fd: __wasi_fd_t,
1277 atim: __wasi_timestamp_t,
1278 mtim: __wasi_timestamp_t,
1279 fst_flags: __wasi_fstflags_t,
1280 ) -> __wasi_errno_t;
1281}
1282extern "C" {
1283 #[must_use]
1284 #[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."]
1285 pub fn __wasi_fd_pread(
1286 fd: __wasi_fd_t,
1287 iovs: *const __wasi_iovec_t,
1288 iovs_len: usize,
1289 offset: __wasi_filesize_t,
1290 retptr0: *mut __wasi_size_t,
1291 ) -> __wasi_errno_t;
1292}
1293extern "C" {
1294 #[must_use]
1295 #[doc = " Return a description of the given preopened file descriptor.\n @return\n The buffer where the description is stored."]
1296 pub fn __wasi_fd_prestat_get(fd: __wasi_fd_t, retptr0: *mut __wasi_prestat_t)
1297 -> __wasi_errno_t;
1298}
1299extern "C" {
1300 #[must_use]
1301 #[doc = " Return a description of the given preopened file descriptor."]
1302 pub fn __wasi_fd_prestat_dir_name(
1303 fd: __wasi_fd_t,
1304 path: *mut u8,
1305 path_len: __wasi_size_t,
1306 ) -> __wasi_errno_t;
1307}
1308extern "C" {
1309 #[must_use]
1310 #[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."]
1311 pub fn __wasi_fd_pwrite(
1312 fd: __wasi_fd_t,
1313 iovs: *const __wasi_ciovec_t,
1314 iovs_len: usize,
1315 offset: __wasi_filesize_t,
1316 retptr0: *mut __wasi_size_t,
1317 ) -> __wasi_errno_t;
1318}
1319extern "C" {
1320 #[must_use]
1321 #[doc = " Read from a file descriptor.\n Note: This is similar to `readv` in POSIX.\n @return\n The number of bytes read."]
1322 pub fn __wasi_fd_read(
1323 fd: __wasi_fd_t,
1324 iovs: *const __wasi_iovec_t,
1325 iovs_len: usize,
1326 retptr0: *mut __wasi_size_t,
1327 ) -> __wasi_errno_t;
1328}
1329extern "C" {
1330 #[must_use]
1331 #[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."]
1332 pub fn __wasi_fd_readdir(
1333 fd: __wasi_fd_t,
1334 buf: *mut u8,
1335 buf_len: __wasi_size_t,
1336 cookie: __wasi_dircookie_t,
1337 retptr0: *mut __wasi_size_t,
1338 ) -> __wasi_errno_t;
1339}
1340extern "C" {
1341 #[must_use]
1342 #[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."]
1343 pub fn __wasi_fd_renumber(fd: __wasi_fd_t, to: __wasi_fd_t) -> __wasi_errno_t;
1344}
1345extern "C" {
1346 #[must_use]
1347 #[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."]
1348 pub fn __wasi_fd_seek(
1349 fd: __wasi_fd_t,
1350 offset: __wasi_filedelta_t,
1351 whence: __wasi_whence_t,
1352 retptr0: *mut __wasi_filesize_t,
1353 ) -> __wasi_errno_t;
1354}
1355extern "C" {
1356 #[must_use]
1357 #[doc = " Synchronize the data and metadata of a file to disk.\n Note: This is similar to `fsync` in POSIX."]
1358 pub fn __wasi_fd_sync(fd: __wasi_fd_t) -> __wasi_errno_t;
1359}
1360extern "C" {
1361 #[must_use]
1362 #[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."]
1363 pub fn __wasi_fd_tell(fd: __wasi_fd_t, retptr0: *mut __wasi_filesize_t) -> __wasi_errno_t;
1364}
1365extern "C" {
1366 #[must_use]
1367 #[doc = " Write to a file descriptor.\n Note: This is similar to `writev` in POSIX."]
1368 pub fn __wasi_fd_write(
1369 fd: __wasi_fd_t,
1370 iovs: *const __wasi_ciovec_t,
1371 iovs_len: usize,
1372 retptr0: *mut __wasi_size_t,
1373 ) -> __wasi_errno_t;
1374}
1375extern "C" {
1376 #[must_use]
1377 #[doc = " Create a directory.\n Note: This is similar to `mkdirat` in POSIX."]
1378 pub fn __wasi_path_create_directory(
1379 fd: __wasi_fd_t,
1380 path: *const ::std::os::raw::c_char,
1381 ) -> __wasi_errno_t;
1382}
1383extern "C" {
1384 #[must_use]
1385 #[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."]
1386 pub fn __wasi_path_filestat_get(
1387 fd: __wasi_fd_t,
1388 flags: __wasi_lookupflags_t,
1389 path: *const ::std::os::raw::c_char,
1390 retptr0: *mut __wasi_filestat_t,
1391 ) -> __wasi_errno_t;
1392}
1393extern "C" {
1394 #[must_use]
1395 #[doc = " Adjust the timestamps of a file or directory.\n Note: This is similar to `utimensat` in POSIX."]
1396 pub fn __wasi_path_filestat_set_times(
1397 fd: __wasi_fd_t,
1398 flags: __wasi_lookupflags_t,
1399 path: *const ::std::os::raw::c_char,
1400 atim: __wasi_timestamp_t,
1401 mtim: __wasi_timestamp_t,
1402 fst_flags: __wasi_fstflags_t,
1403 ) -> __wasi_errno_t;
1404}
1405extern "C" {
1406 #[must_use]
1407 #[doc = " Create a hard link.\n Note: This is similar to `linkat` in POSIX."]
1408 pub fn __wasi_path_link(
1409 old_fd: __wasi_fd_t,
1410 old_flags: __wasi_lookupflags_t,
1411 old_path: *const ::std::os::raw::c_char,
1412 new_fd: __wasi_fd_t,
1413 new_path: *const ::std::os::raw::c_char,
1414 ) -> __wasi_errno_t;
1415}
1416extern "C" {
1417 #[must_use]
1418 #[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."]
1419 pub fn __wasi_path_open(
1420 fd: __wasi_fd_t,
1421 dirflags: __wasi_lookupflags_t,
1422 path: *const ::std::os::raw::c_char,
1423 oflags: __wasi_oflags_t,
1424 fs_rights_base: __wasi_rights_t,
1425 fs_rights_inheriting: __wasi_rights_t,
1426 fdflags: __wasi_fdflags_t,
1427 retptr0: *mut __wasi_fd_t,
1428 ) -> __wasi_errno_t;
1429}
1430extern "C" {
1431 #[must_use]
1432 #[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."]
1433 pub fn __wasi_path_readlink(
1434 fd: __wasi_fd_t,
1435 path: *const ::std::os::raw::c_char,
1436 buf: *mut u8,
1437 buf_len: __wasi_size_t,
1438 retptr0: *mut __wasi_size_t,
1439 ) -> __wasi_errno_t;
1440}
1441extern "C" {
1442 #[must_use]
1443 #[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."]
1444 pub fn __wasi_path_remove_directory(
1445 fd: __wasi_fd_t,
1446 path: *const ::std::os::raw::c_char,
1447 ) -> __wasi_errno_t;
1448}
1449extern "C" {
1450 #[must_use]
1451 #[doc = " Rename a file or directory.\n Note: This is similar to `renameat` in POSIX."]
1452 pub fn __wasi_path_rename(
1453 fd: __wasi_fd_t,
1454 old_path: *const ::std::os::raw::c_char,
1455 new_fd: __wasi_fd_t,
1456 new_path: *const ::std::os::raw::c_char,
1457 ) -> __wasi_errno_t;
1458}
1459extern "C" {
1460 #[must_use]
1461 #[doc = " Create a symbolic link.\n Note: This is similar to `symlinkat` in POSIX."]
1462 pub fn __wasi_path_symlink(
1463 old_path: *const ::std::os::raw::c_char,
1464 fd: __wasi_fd_t,
1465 new_path: *const ::std::os::raw::c_char,
1466 ) -> __wasi_errno_t;
1467}
1468extern "C" {
1469 #[must_use]
1470 #[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."]
1471 pub fn __wasi_path_unlink_file(
1472 fd: __wasi_fd_t,
1473 path: *const ::std::os::raw::c_char,
1474 ) -> __wasi_errno_t;
1475}
1476extern "C" {
1477 #[must_use]
1478 #[doc = " Concurrently poll for the occurrence of a set of events.\n @return\n The number of events stored."]
1479 pub fn __wasi_poll_oneoff(
1480 in_: *const __wasi_subscription_t,
1481 out: *mut __wasi_event_t,
1482 nsubscriptions: __wasi_size_t,
1483 retptr0: *mut __wasi_size_t,
1484 ) -> __wasi_errno_t;
1485}
1486extern "C" {
1487 #[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."]
1488 pub fn __wasi_proc_exit(rval: __wasi_exitcode_t) -> !;
1489}
1490extern "C" {
1491 #[must_use]
1492 #[doc = " Temporarily yield execution of the calling thread.\n Note: This is similar to `sched_yield` in POSIX."]
1493 pub fn __wasi_sched_yield() -> __wasi_errno_t;
1494}
1495extern "C" {
1496 #[must_use]
1497 #[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."]
1498 pub fn __wasi_random_get(buf: *mut u8, buf_len: __wasi_size_t) -> __wasi_errno_t;
1499}
1500extern "C" {
1501 #[must_use]
1502 #[doc = " Accept a new incoming connection.\n Note: This is similar to `accept` in POSIX.\n @return\n New socket connection"]
1503 pub fn __wasi_sock_accept(
1504 fd: __wasi_fd_t,
1505 flags: __wasi_fdflags_t,
1506 retptr0: *mut __wasi_fd_t,
1507 ) -> __wasi_errno_t;
1508}
1509extern "C" {
1510 #[must_use]
1511 #[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."]
1512 pub fn __wasi_sock_recv(
1513 fd: __wasi_fd_t,
1514 ri_data: *const __wasi_iovec_t,
1515 ri_data_len: usize,
1516 ri_flags: __wasi_riflags_t,
1517 retptr0: *mut __wasi_size_t,
1518 retptr1: *mut __wasi_roflags_t,
1519 ) -> __wasi_errno_t;
1520}
1521extern "C" {
1522 #[must_use]
1523 #[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."]
1524 pub fn __wasi_sock_send(
1525 fd: __wasi_fd_t,
1526 si_data: *const __wasi_ciovec_t,
1527 si_data_len: usize,
1528 si_flags: __wasi_siflags_t,
1529 retptr0: *mut __wasi_size_t,
1530 ) -> __wasi_errno_t;
1531}
1532extern "C" {
1533 #[must_use]
1534 #[doc = " Shut down socket send and receive channels.\n Note: This is similar to `shutdown` in POSIX."]
1535 pub fn __wasi_sock_shutdown(fd: __wasi_fd_t, how: __wasi_sdflags_t) -> __wasi_errno_t;
1536}
1537#[repr(C)]
1538#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1539pub struct imaxdiv_t {
1540 pub quot: intmax_t,
1541 pub rem: intmax_t,
1542}
1543extern "C" {
1544 pub fn imaxabs(arg1: intmax_t) -> intmax_t;
1545}
1546extern "C" {
1547 pub fn imaxdiv(arg1: intmax_t, arg2: intmax_t) -> imaxdiv_t;
1548}
1549extern "C" {
1550 pub fn strtoimax(
1551 arg1: *const ::std::os::raw::c_char,
1552 arg2: *mut *mut ::std::os::raw::c_char,
1553 arg3: ::std::os::raw::c_int,
1554 ) -> intmax_t;
1555}
1556extern "C" {
1557 pub fn strtoumax(
1558 arg1: *const ::std::os::raw::c_char,
1559 arg2: *mut *mut ::std::os::raw::c_char,
1560 arg3: ::std::os::raw::c_int,
1561 ) -> uintmax_t;
1562}
1563extern "C" {
1564 pub fn wcstoimax(
1565 arg1: *const wchar_t,
1566 arg2: *mut *mut wchar_t,
1567 arg3: ::std::os::raw::c_int,
1568 ) -> intmax_t;
1569}
1570extern "C" {
1571 pub fn wcstoumax(
1572 arg1: *const wchar_t,
1573 arg2: *mut *mut wchar_t,
1574 arg3: ::std::os::raw::c_int,
1575 ) -> uintmax_t;
1576}
1577pub type float_t = f32;
1578pub type double_t = f64;
1579extern "C" {
1580 pub fn acos(arg1: f64) -> f64;
1581}
1582extern "C" {
1583 pub fn acosf(arg1: f32) -> f32;
1584}
1585extern "C" {
1586 pub fn acosl(arg1: u128) -> u128;
1587}
1588extern "C" {
1589 pub fn acosh(arg1: f64) -> f64;
1590}
1591extern "C" {
1592 pub fn acoshf(arg1: f32) -> f32;
1593}
1594extern "C" {
1595 pub fn acoshl(arg1: u128) -> u128;
1596}
1597extern "C" {
1598 pub fn asin(arg1: f64) -> f64;
1599}
1600extern "C" {
1601 pub fn asinf(arg1: f32) -> f32;
1602}
1603extern "C" {
1604 pub fn asinl(arg1: u128) -> u128;
1605}
1606extern "C" {
1607 pub fn asinh(arg1: f64) -> f64;
1608}
1609extern "C" {
1610 pub fn asinhf(arg1: f32) -> f32;
1611}
1612extern "C" {
1613 pub fn asinhl(arg1: u128) -> u128;
1614}
1615extern "C" {
1616 pub fn atan(arg1: f64) -> f64;
1617}
1618extern "C" {
1619 pub fn atanf(arg1: f32) -> f32;
1620}
1621extern "C" {
1622 pub fn atanl(arg1: u128) -> u128;
1623}
1624extern "C" {
1625 pub fn atan2(arg1: f64, arg2: f64) -> f64;
1626}
1627extern "C" {
1628 pub fn atan2f(arg1: f32, arg2: f32) -> f32;
1629}
1630extern "C" {
1631 pub fn atan2l(arg1: u128, arg2: u128) -> u128;
1632}
1633extern "C" {
1634 pub fn atanh(arg1: f64) -> f64;
1635}
1636extern "C" {
1637 pub fn atanhf(arg1: f32) -> f32;
1638}
1639extern "C" {
1640 pub fn atanhl(arg1: u128) -> u128;
1641}
1642extern "C" {
1643 pub fn cbrt(arg1: f64) -> f64;
1644}
1645extern "C" {
1646 pub fn cbrtf(arg1: f32) -> f32;
1647}
1648extern "C" {
1649 pub fn cbrtl(arg1: u128) -> u128;
1650}
1651extern "C" {
1652 pub fn ceil(arg1: f64) -> f64;
1653}
1654extern "C" {
1655 pub fn ceilf(arg1: f32) -> f32;
1656}
1657extern "C" {
1658 pub fn ceill(arg1: u128) -> u128;
1659}
1660extern "C" {
1661 pub fn copysign(arg1: f64, arg2: f64) -> f64;
1662}
1663extern "C" {
1664 pub fn copysignf(arg1: f32, arg2: f32) -> f32;
1665}
1666extern "C" {
1667 pub fn copysignl(arg1: u128, arg2: u128) -> u128;
1668}
1669extern "C" {
1670 pub fn cos(arg1: f64) -> f64;
1671}
1672extern "C" {
1673 pub fn cosf(arg1: f32) -> f32;
1674}
1675extern "C" {
1676 pub fn cosl(arg1: u128) -> u128;
1677}
1678extern "C" {
1679 pub fn cosh(arg1: f64) -> f64;
1680}
1681extern "C" {
1682 pub fn coshf(arg1: f32) -> f32;
1683}
1684extern "C" {
1685 pub fn coshl(arg1: u128) -> u128;
1686}
1687extern "C" {
1688 pub fn erf(arg1: f64) -> f64;
1689}
1690extern "C" {
1691 pub fn erff(arg1: f32) -> f32;
1692}
1693extern "C" {
1694 pub fn erfl(arg1: u128) -> u128;
1695}
1696extern "C" {
1697 pub fn erfc(arg1: f64) -> f64;
1698}
1699extern "C" {
1700 pub fn erfcf(arg1: f32) -> f32;
1701}
1702extern "C" {
1703 pub fn erfcl(arg1: u128) -> u128;
1704}
1705extern "C" {
1706 pub fn exp(arg1: f64) -> f64;
1707}
1708extern "C" {
1709 pub fn expf(arg1: f32) -> f32;
1710}
1711extern "C" {
1712 pub fn expl(arg1: u128) -> u128;
1713}
1714extern "C" {
1715 pub fn exp2(arg1: f64) -> f64;
1716}
1717extern "C" {
1718 pub fn exp2f(arg1: f32) -> f32;
1719}
1720extern "C" {
1721 pub fn exp2l(arg1: u128) -> u128;
1722}
1723extern "C" {
1724 pub fn expm1(arg1: f64) -> f64;
1725}
1726extern "C" {
1727 pub fn expm1f(arg1: f32) -> f32;
1728}
1729extern "C" {
1730 pub fn expm1l(arg1: u128) -> u128;
1731}
1732extern "C" {
1733 pub fn fabs(arg1: f64) -> f64;
1734}
1735extern "C" {
1736 pub fn fabsf(arg1: f32) -> f32;
1737}
1738extern "C" {
1739 pub fn fabsl(arg1: u128) -> u128;
1740}
1741extern "C" {
1742 pub fn fdim(arg1: f64, arg2: f64) -> f64;
1743}
1744extern "C" {
1745 pub fn fdimf(arg1: f32, arg2: f32) -> f32;
1746}
1747extern "C" {
1748 pub fn fdiml(arg1: u128, arg2: u128) -> u128;
1749}
1750extern "C" {
1751 pub fn floor(arg1: f64) -> f64;
1752}
1753extern "C" {
1754 pub fn floorf(arg1: f32) -> f32;
1755}
1756extern "C" {
1757 pub fn floorl(arg1: u128) -> u128;
1758}
1759extern "C" {
1760 pub fn fma(arg1: f64, arg2: f64, arg3: f64) -> f64;
1761}
1762extern "C" {
1763 pub fn fmaf(arg1: f32, arg2: f32, arg3: f32) -> f32;
1764}
1765extern "C" {
1766 pub fn fmal(arg1: u128, arg2: u128, arg3: u128) -> u128;
1767}
1768extern "C" {
1769 pub fn fmax(arg1: f64, arg2: f64) -> f64;
1770}
1771extern "C" {
1772 pub fn fmaxf(arg1: f32, arg2: f32) -> f32;
1773}
1774extern "C" {
1775 pub fn fmaxl(arg1: u128, arg2: u128) -> u128;
1776}
1777extern "C" {
1778 pub fn fmin(arg1: f64, arg2: f64) -> f64;
1779}
1780extern "C" {
1781 pub fn fminf(arg1: f32, arg2: f32) -> f32;
1782}
1783extern "C" {
1784 pub fn fminl(arg1: u128, arg2: u128) -> u128;
1785}
1786extern "C" {
1787 pub fn fmod(arg1: f64, arg2: f64) -> f64;
1788}
1789extern "C" {
1790 pub fn fmodf(arg1: f32, arg2: f32) -> f32;
1791}
1792extern "C" {
1793 pub fn fmodl(arg1: u128, arg2: u128) -> u128;
1794}
1795extern "C" {
1796 pub fn frexp(arg1: f64, arg2: *mut ::std::os::raw::c_int) -> f64;
1797}
1798extern "C" {
1799 pub fn frexpf(arg1: f32, arg2: *mut ::std::os::raw::c_int) -> f32;
1800}
1801extern "C" {
1802 pub fn frexpl(arg1: u128, arg2: *mut ::std::os::raw::c_int) -> u128;
1803}
1804extern "C" {
1805 pub fn hypot(arg1: f64, arg2: f64) -> f64;
1806}
1807extern "C" {
1808 pub fn hypotf(arg1: f32, arg2: f32) -> f32;
1809}
1810extern "C" {
1811 pub fn hypotl(arg1: u128, arg2: u128) -> u128;
1812}
1813extern "C" {
1814 pub fn ilogb(arg1: f64) -> ::std::os::raw::c_int;
1815}
1816extern "C" {
1817 pub fn ilogbf(arg1: f32) -> ::std::os::raw::c_int;
1818}
1819extern "C" {
1820 pub fn ilogbl(arg1: u128) -> ::std::os::raw::c_int;
1821}
1822extern "C" {
1823 pub fn ldexp(arg1: f64, arg2: ::std::os::raw::c_int) -> f64;
1824}
1825extern "C" {
1826 pub fn ldexpf(arg1: f32, arg2: ::std::os::raw::c_int) -> f32;
1827}
1828extern "C" {
1829 pub fn ldexpl(arg1: u128, arg2: ::std::os::raw::c_int) -> u128;
1830}
1831extern "C" {
1832 pub fn lgamma(arg1: f64) -> f64;
1833}
1834extern "C" {
1835 pub fn lgammaf(arg1: f32) -> f32;
1836}
1837extern "C" {
1838 pub fn lgammal(arg1: u128) -> u128;
1839}
1840extern "C" {
1841 pub fn llrint(arg1: f64) -> ::std::os::raw::c_longlong;
1842}
1843extern "C" {
1844 pub fn llrintf(arg1: f32) -> ::std::os::raw::c_longlong;
1845}
1846extern "C" {
1847 pub fn llrintl(arg1: u128) -> ::std::os::raw::c_longlong;
1848}
1849extern "C" {
1850 pub fn llround(arg1: f64) -> ::std::os::raw::c_longlong;
1851}
1852extern "C" {
1853 pub fn llroundf(arg1: f32) -> ::std::os::raw::c_longlong;
1854}
1855extern "C" {
1856 pub fn llroundl(arg1: u128) -> ::std::os::raw::c_longlong;
1857}
1858extern "C" {
1859 pub fn log(arg1: f64) -> f64;
1860}
1861extern "C" {
1862 pub fn logf(arg1: f32) -> f32;
1863}
1864extern "C" {
1865 pub fn logl(arg1: u128) -> u128;
1866}
1867extern "C" {
1868 pub fn log10(arg1: f64) -> f64;
1869}
1870extern "C" {
1871 pub fn log10f(arg1: f32) -> f32;
1872}
1873extern "C" {
1874 pub fn log10l(arg1: u128) -> u128;
1875}
1876extern "C" {
1877 pub fn log1p(arg1: f64) -> f64;
1878}
1879extern "C" {
1880 pub fn log1pf(arg1: f32) -> f32;
1881}
1882extern "C" {
1883 pub fn log1pl(arg1: u128) -> u128;
1884}
1885extern "C" {
1886 pub fn log2(arg1: f64) -> f64;
1887}
1888extern "C" {
1889 pub fn log2f(arg1: f32) -> f32;
1890}
1891extern "C" {
1892 pub fn log2l(arg1: u128) -> u128;
1893}
1894extern "C" {
1895 pub fn logb(arg1: f64) -> f64;
1896}
1897extern "C" {
1898 pub fn logbf(arg1: f32) -> f32;
1899}
1900extern "C" {
1901 pub fn logbl(arg1: u128) -> u128;
1902}
1903extern "C" {
1904 pub fn lrint(arg1: f64) -> ::std::os::raw::c_long;
1905}
1906extern "C" {
1907 pub fn lrintf(arg1: f32) -> ::std::os::raw::c_long;
1908}
1909extern "C" {
1910 pub fn lrintl(arg1: u128) -> ::std::os::raw::c_long;
1911}
1912extern "C" {
1913 pub fn lround(arg1: f64) -> ::std::os::raw::c_long;
1914}
1915extern "C" {
1916 pub fn lroundf(arg1: f32) -> ::std::os::raw::c_long;
1917}
1918extern "C" {
1919 pub fn lroundl(arg1: u128) -> ::std::os::raw::c_long;
1920}
1921extern "C" {
1922 pub fn modf(arg1: f64, arg2: *mut f64) -> f64;
1923}
1924extern "C" {
1925 pub fn modff(arg1: f32, arg2: *mut f32) -> f32;
1926}
1927extern "C" {
1928 pub fn modfl(arg1: u128, arg2: *mut u128) -> u128;
1929}
1930extern "C" {
1931 pub fn nan(arg1: *const ::std::os::raw::c_char) -> f64;
1932}
1933extern "C" {
1934 pub fn nanf(arg1: *const ::std::os::raw::c_char) -> f32;
1935}
1936extern "C" {
1937 pub fn nanl(arg1: *const ::std::os::raw::c_char) -> u128;
1938}
1939extern "C" {
1940 pub fn nearbyint(arg1: f64) -> f64;
1941}
1942extern "C" {
1943 pub fn nearbyintf(arg1: f32) -> f32;
1944}
1945extern "C" {
1946 pub fn nearbyintl(arg1: u128) -> u128;
1947}
1948extern "C" {
1949 pub fn nextafter(arg1: f64, arg2: f64) -> f64;
1950}
1951extern "C" {
1952 pub fn nextafterf(arg1: f32, arg2: f32) -> f32;
1953}
1954extern "C" {
1955 pub fn nextafterl(arg1: u128, arg2: u128) -> u128;
1956}
1957extern "C" {
1958 pub fn nexttoward(arg1: f64, arg2: u128) -> f64;
1959}
1960extern "C" {
1961 pub fn nexttowardf(arg1: f32, arg2: u128) -> f32;
1962}
1963extern "C" {
1964 pub fn nexttowardl(arg1: u128, arg2: u128) -> u128;
1965}
1966extern "C" {
1967 pub fn pow(arg1: f64, arg2: f64) -> f64;
1968}
1969extern "C" {
1970 pub fn powf(arg1: f32, arg2: f32) -> f32;
1971}
1972extern "C" {
1973 pub fn powl(arg1: u128, arg2: u128) -> u128;
1974}
1975extern "C" {
1976 pub fn remainder(arg1: f64, arg2: f64) -> f64;
1977}
1978extern "C" {
1979 pub fn remainderf(arg1: f32, arg2: f32) -> f32;
1980}
1981extern "C" {
1982 pub fn remainderl(arg1: u128, arg2: u128) -> u128;
1983}
1984extern "C" {
1985 pub fn remquo(arg1: f64, arg2: f64, arg3: *mut ::std::os::raw::c_int) -> f64;
1986}
1987extern "C" {
1988 pub fn remquof(arg1: f32, arg2: f32, arg3: *mut ::std::os::raw::c_int) -> f32;
1989}
1990extern "C" {
1991 pub fn remquol(arg1: u128, arg2: u128, arg3: *mut ::std::os::raw::c_int) -> u128;
1992}
1993extern "C" {
1994 pub fn rint(arg1: f64) -> f64;
1995}
1996extern "C" {
1997 pub fn rintf(arg1: f32) -> f32;
1998}
1999extern "C" {
2000 pub fn rintl(arg1: u128) -> u128;
2001}
2002extern "C" {
2003 pub fn round(arg1: f64) -> f64;
2004}
2005extern "C" {
2006 pub fn roundf(arg1: f32) -> f32;
2007}
2008extern "C" {
2009 pub fn roundl(arg1: u128) -> u128;
2010}
2011extern "C" {
2012 pub fn scalbln(arg1: f64, arg2: ::std::os::raw::c_long) -> f64;
2013}
2014extern "C" {
2015 pub fn scalblnf(arg1: f32, arg2: ::std::os::raw::c_long) -> f32;
2016}
2017extern "C" {
2018 pub fn scalblnl(arg1: u128, arg2: ::std::os::raw::c_long) -> u128;
2019}
2020extern "C" {
2021 pub fn scalbn(arg1: f64, arg2: ::std::os::raw::c_int) -> f64;
2022}
2023extern "C" {
2024 pub fn scalbnf(arg1: f32, arg2: ::std::os::raw::c_int) -> f32;
2025}
2026extern "C" {
2027 pub fn scalbnl(arg1: u128, arg2: ::std::os::raw::c_int) -> u128;
2028}
2029extern "C" {
2030 pub fn sin(arg1: f64) -> f64;
2031}
2032extern "C" {
2033 pub fn sinf(arg1: f32) -> f32;
2034}
2035extern "C" {
2036 pub fn sinl(arg1: u128) -> u128;
2037}
2038extern "C" {
2039 pub fn sinh(arg1: f64) -> f64;
2040}
2041extern "C" {
2042 pub fn sinhf(arg1: f32) -> f32;
2043}
2044extern "C" {
2045 pub fn sinhl(arg1: u128) -> u128;
2046}
2047extern "C" {
2048 pub fn sqrt(arg1: f64) -> f64;
2049}
2050extern "C" {
2051 pub fn sqrtf(arg1: f32) -> f32;
2052}
2053extern "C" {
2054 pub fn sqrtl(arg1: u128) -> u128;
2055}
2056extern "C" {
2057 pub fn tan(arg1: f64) -> f64;
2058}
2059extern "C" {
2060 pub fn tanf(arg1: f32) -> f32;
2061}
2062extern "C" {
2063 pub fn tanl(arg1: u128) -> u128;
2064}
2065extern "C" {
2066 pub fn tanh(arg1: f64) -> f64;
2067}
2068extern "C" {
2069 pub fn tanhf(arg1: f32) -> f32;
2070}
2071extern "C" {
2072 pub fn tanhl(arg1: u128) -> u128;
2073}
2074extern "C" {
2075 pub fn tgamma(arg1: f64) -> f64;
2076}
2077extern "C" {
2078 pub fn tgammaf(arg1: f32) -> f32;
2079}
2080extern "C" {
2081 pub fn tgammal(arg1: u128) -> u128;
2082}
2083extern "C" {
2084 pub fn trunc(arg1: f64) -> f64;
2085}
2086extern "C" {
2087 pub fn truncf(arg1: f32) -> f32;
2088}
2089extern "C" {
2090 pub fn truncl(arg1: u128) -> u128;
2091}
2092extern "C" {
2093 pub static mut signgam: ::std::os::raw::c_int;
2094}
2095extern "C" {
2096 pub fn j0(arg1: f64) -> f64;
2097}
2098extern "C" {
2099 pub fn j1(arg1: f64) -> f64;
2100}
2101extern "C" {
2102 pub fn jn(arg1: ::std::os::raw::c_int, arg2: f64) -> f64;
2103}
2104extern "C" {
2105 pub fn y0(arg1: f64) -> f64;
2106}
2107extern "C" {
2108 pub fn y1(arg1: f64) -> f64;
2109}
2110extern "C" {
2111 pub fn yn(arg1: ::std::os::raw::c_int, arg2: f64) -> f64;
2112}
2113extern "C" {
2114 pub fn drem(arg1: f64, arg2: f64) -> f64;
2115}
2116extern "C" {
2117 pub fn dremf(arg1: f32, arg2: f32) -> f32;
2118}
2119extern "C" {
2120 pub fn finite(arg1: f64) -> ::std::os::raw::c_int;
2121}
2122extern "C" {
2123 pub fn finitef(arg1: f32) -> ::std::os::raw::c_int;
2124}
2125extern "C" {
2126 pub fn scalb(arg1: f64, arg2: f64) -> f64;
2127}
2128extern "C" {
2129 pub fn scalbf(arg1: f32, arg2: f32) -> f32;
2130}
2131extern "C" {
2132 pub fn significand(arg1: f64) -> f64;
2133}
2134extern "C" {
2135 pub fn significandf(arg1: f32) -> f32;
2136}
2137extern "C" {
2138 pub fn lgamma_r(arg1: f64, arg2: *mut ::std::os::raw::c_int) -> f64;
2139}
2140extern "C" {
2141 pub fn lgammaf_r(arg1: f32, arg2: *mut ::std::os::raw::c_int) -> f32;
2142}
2143extern "C" {
2144 pub fn j0f(arg1: f32) -> f32;
2145}
2146extern "C" {
2147 pub fn j1f(arg1: f32) -> f32;
2148}
2149extern "C" {
2150 pub fn jnf(arg1: ::std::os::raw::c_int, arg2: f32) -> f32;
2151}
2152extern "C" {
2153 pub fn y0f(arg1: f32) -> f32;
2154}
2155extern "C" {
2156 pub fn y1f(arg1: f32) -> f32;
2157}
2158extern "C" {
2159 pub fn ynf(arg1: ::std::os::raw::c_int, arg2: f32) -> f32;
2160}
2161pub type off_t = ::std::os::raw::c_longlong;
2162#[repr(C)]
2163#[derive(Debug, Copy, Clone)]
2164pub struct _IO_FILE {
2165 _unused: [u8; 0],
2166}
2167pub type FILE = _IO_FILE;
2168pub type va_list = __builtin_va_list;
2169pub type __isoc_va_list = __builtin_va_list;
2170#[repr(C)]
2171#[derive(Copy, Clone)]
2172pub union _G_fpos64_t {
2173 pub __opaque: [::std::os::raw::c_char; 16usize],
2174 pub __lldata: ::std::os::raw::c_longlong,
2175 pub __align: f64,
2176}
2177impl Default for _G_fpos64_t {
2178 fn default() -> Self {
2179 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2180 unsafe {
2181 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2182 s.assume_init()
2183 }
2184 }
2185}
2186pub type fpos_t = _G_fpos64_t;
2187extern "C" {
2188 pub static stdin: *mut FILE;
2189}
2190extern "C" {
2191 pub static stdout: *mut FILE;
2192}
2193extern "C" {
2194 pub static stderr: *mut FILE;
2195}
2196extern "C" {
2197 pub fn fopen(
2198 arg1: *const ::std::os::raw::c_char,
2199 arg2: *const ::std::os::raw::c_char,
2200 ) -> *mut FILE;
2201}
2202extern "C" {
2203 pub fn freopen(
2204 arg1: *const ::std::os::raw::c_char,
2205 arg2: *const ::std::os::raw::c_char,
2206 arg3: *mut FILE,
2207 ) -> *mut FILE;
2208}
2209extern "C" {
2210 pub fn fclose(arg1: *mut FILE) -> ::std::os::raw::c_int;
2211}
2212extern "C" {
2213 pub fn remove(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2214}
2215extern "C" {
2216 pub fn rename(
2217 arg1: *const ::std::os::raw::c_char,
2218 arg2: *const ::std::os::raw::c_char,
2219 ) -> ::std::os::raw::c_int;
2220}
2221extern "C" {
2222 pub fn feof(arg1: *mut FILE) -> ::std::os::raw::c_int;
2223}
2224extern "C" {
2225 pub fn ferror(arg1: *mut FILE) -> ::std::os::raw::c_int;
2226}
2227extern "C" {
2228 pub fn fflush(arg1: *mut FILE) -> ::std::os::raw::c_int;
2229}
2230extern "C" {
2231 pub fn clearerr(arg1: *mut FILE);
2232}
2233extern "C" {
2234 pub fn fseek(
2235 arg1: *mut FILE,
2236 arg2: ::std::os::raw::c_long,
2237 arg3: ::std::os::raw::c_int,
2238 ) -> ::std::os::raw::c_int;
2239}
2240extern "C" {
2241 pub fn ftell(arg1: *mut FILE) -> ::std::os::raw::c_long;
2242}
2243extern "C" {
2244 pub fn rewind(arg1: *mut FILE);
2245}
2246extern "C" {
2247 pub fn fgetpos(arg1: *mut FILE, arg2: *mut fpos_t) -> ::std::os::raw::c_int;
2248}
2249extern "C" {
2250 pub fn fsetpos(arg1: *mut FILE, arg2: *const fpos_t) -> ::std::os::raw::c_int;
2251}
2252extern "C" {
2253 pub fn fread(
2254 arg1: *mut ::std::os::raw::c_void,
2255 arg2: ::std::os::raw::c_ulong,
2256 arg3: ::std::os::raw::c_ulong,
2257 arg4: *mut FILE,
2258 ) -> ::std::os::raw::c_ulong;
2259}
2260extern "C" {
2261 pub fn fwrite(
2262 arg1: *const ::std::os::raw::c_void,
2263 arg2: ::std::os::raw::c_ulong,
2264 arg3: ::std::os::raw::c_ulong,
2265 arg4: *mut FILE,
2266 ) -> ::std::os::raw::c_ulong;
2267}
2268extern "C" {
2269 pub fn fgetc(arg1: *mut FILE) -> ::std::os::raw::c_int;
2270}
2271extern "C" {
2272 pub fn getc(arg1: *mut FILE) -> ::std::os::raw::c_int;
2273}
2274extern "C" {
2275 pub fn getchar() -> ::std::os::raw::c_int;
2276}
2277extern "C" {
2278 pub fn ungetc(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
2279}
2280extern "C" {
2281 pub fn fputc(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
2282}
2283extern "C" {
2284 pub fn putc(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
2285}
2286extern "C" {
2287 pub fn putchar(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
2288}
2289extern "C" {
2290 pub fn fgets(
2291 arg1: *mut ::std::os::raw::c_char,
2292 arg2: ::std::os::raw::c_int,
2293 arg3: *mut FILE,
2294 ) -> *mut ::std::os::raw::c_char;
2295}
2296extern "C" {
2297 pub fn fputs(arg1: *const ::std::os::raw::c_char, arg2: *mut FILE) -> ::std::os::raw::c_int;
2298}
2299extern "C" {
2300 pub fn puts(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2301}
2302extern "C" {
2303 pub fn printf(arg1: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
2304}
2305extern "C" {
2306 pub fn fprintf(
2307 arg1: *mut FILE,
2308 arg2: *const ::std::os::raw::c_char,
2309 ...
2310 ) -> ::std::os::raw::c_int;
2311}
2312extern "C" {
2313 pub fn sprintf(
2314 arg1: *mut ::std::os::raw::c_char,
2315 arg2: *const ::std::os::raw::c_char,
2316 ...
2317 ) -> ::std::os::raw::c_int;
2318}
2319extern "C" {
2320 pub fn snprintf(
2321 arg1: *mut ::std::os::raw::c_char,
2322 arg2: ::std::os::raw::c_ulong,
2323 arg3: *const ::std::os::raw::c_char,
2324 ...
2325 ) -> ::std::os::raw::c_int;
2326}
2327extern "C" {
2328 pub fn vprintf(
2329 arg1: *const ::std::os::raw::c_char,
2330 arg2: __builtin_va_list,
2331 ) -> ::std::os::raw::c_int;
2332}
2333extern "C" {
2334 pub fn vfprintf(
2335 arg1: *mut FILE,
2336 arg2: *const ::std::os::raw::c_char,
2337 arg3: __builtin_va_list,
2338 ) -> ::std::os::raw::c_int;
2339}
2340extern "C" {
2341 pub fn vsprintf(
2342 arg1: *mut ::std::os::raw::c_char,
2343 arg2: *const ::std::os::raw::c_char,
2344 arg3: __builtin_va_list,
2345 ) -> ::std::os::raw::c_int;
2346}
2347extern "C" {
2348 pub fn vsnprintf(
2349 arg1: *mut ::std::os::raw::c_char,
2350 arg2: ::std::os::raw::c_ulong,
2351 arg3: *const ::std::os::raw::c_char,
2352 arg4: __builtin_va_list,
2353 ) -> ::std::os::raw::c_int;
2354}
2355extern "C" {
2356 pub fn scanf(arg1: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
2357}
2358extern "C" {
2359 pub fn fscanf(
2360 arg1: *mut FILE,
2361 arg2: *const ::std::os::raw::c_char,
2362 ...
2363 ) -> ::std::os::raw::c_int;
2364}
2365extern "C" {
2366 pub fn sscanf(
2367 arg1: *const ::std::os::raw::c_char,
2368 arg2: *const ::std::os::raw::c_char,
2369 ...
2370 ) -> ::std::os::raw::c_int;
2371}
2372extern "C" {
2373 pub fn vscanf(
2374 arg1: *const ::std::os::raw::c_char,
2375 arg2: __builtin_va_list,
2376 ) -> ::std::os::raw::c_int;
2377}
2378extern "C" {
2379 pub fn vfscanf(
2380 arg1: *mut FILE,
2381 arg2: *const ::std::os::raw::c_char,
2382 arg3: __builtin_va_list,
2383 ) -> ::std::os::raw::c_int;
2384}
2385extern "C" {
2386 pub fn vsscanf(
2387 arg1: *const ::std::os::raw::c_char,
2388 arg2: *const ::std::os::raw::c_char,
2389 arg3: __builtin_va_list,
2390 ) -> ::std::os::raw::c_int;
2391}
2392extern "C" {
2393 pub fn perror(arg1: *const ::std::os::raw::c_char);
2394}
2395extern "C" {
2396 pub fn setvbuf(
2397 arg1: *mut FILE,
2398 arg2: *mut ::std::os::raw::c_char,
2399 arg3: ::std::os::raw::c_int,
2400 arg4: usize,
2401 ) -> ::std::os::raw::c_int;
2402}
2403extern "C" {
2404 pub fn setbuf(arg1: *mut FILE, arg2: *mut ::std::os::raw::c_char);
2405}
2406extern "C" {
2407 pub fn tmpnam(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2408}
2409extern "C" {
2410 pub fn tmpfile() -> *mut FILE;
2411}
2412extern "C" {
2413 pub fn fmemopen(
2414 arg1: *mut ::std::os::raw::c_void,
2415 arg2: usize,
2416 arg3: *const ::std::os::raw::c_char,
2417 ) -> *mut FILE;
2418}
2419extern "C" {
2420 pub fn open_memstream(arg1: *mut *mut ::std::os::raw::c_char, arg2: *mut usize) -> *mut FILE;
2421}
2422extern "C" {
2423 pub fn fdopen(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char) -> *mut FILE;
2424}
2425extern "C" {
2426 pub fn fileno(arg1: *mut FILE) -> ::std::os::raw::c_int;
2427}
2428extern "C" {
2429 pub fn fseeko(
2430 arg1: *mut FILE,
2431 arg2: off_t,
2432 arg3: ::std::os::raw::c_int,
2433 ) -> ::std::os::raw::c_int;
2434}
2435extern "C" {
2436 pub fn ftello(arg1: *mut FILE) -> off_t;
2437}
2438extern "C" {
2439 pub fn dprintf(
2440 arg1: ::std::os::raw::c_int,
2441 arg2: *const ::std::os::raw::c_char,
2442 ...
2443 ) -> ::std::os::raw::c_int;
2444}
2445extern "C" {
2446 pub fn vdprintf(
2447 arg1: ::std::os::raw::c_int,
2448 arg2: *const ::std::os::raw::c_char,
2449 arg3: __isoc_va_list,
2450 ) -> ::std::os::raw::c_int;
2451}
2452extern "C" {
2453 pub fn getc_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
2454}
2455extern "C" {
2456 pub fn getchar_unlocked() -> ::std::os::raw::c_int;
2457}
2458extern "C" {
2459 pub fn putc_unlocked(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
2460}
2461extern "C" {
2462 pub fn putchar_unlocked(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
2463}
2464extern "C" {
2465 pub fn getdelim(
2466 arg1: *mut *mut ::std::os::raw::c_char,
2467 arg2: *mut usize,
2468 arg3: ::std::os::raw::c_int,
2469 arg4: *mut FILE,
2470 ) -> isize;
2471}
2472extern "C" {
2473 pub fn getline(
2474 arg1: *mut *mut ::std::os::raw::c_char,
2475 arg2: *mut usize,
2476 arg3: *mut FILE,
2477 ) -> isize;
2478}
2479extern "C" {
2480 pub fn renameat(
2481 arg1: ::std::os::raw::c_int,
2482 arg2: *const ::std::os::raw::c_char,
2483 arg3: ::std::os::raw::c_int,
2484 arg4: *const ::std::os::raw::c_char,
2485 ) -> ::std::os::raw::c_int;
2486}
2487extern "C" {
2488 pub fn ctermid(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2489}
2490extern "C" {
2491 pub fn cuserid(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2492}
2493extern "C" {
2494 pub fn setlinebuf(arg1: *mut FILE);
2495}
2496extern "C" {
2497 pub fn setbuffer(arg1: *mut FILE, arg2: *mut ::std::os::raw::c_char, arg3: usize);
2498}
2499extern "C" {
2500 pub fn fgetc_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
2501}
2502extern "C" {
2503 pub fn fputc_unlocked(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
2504}
2505extern "C" {
2506 pub fn fflush_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
2507}
2508extern "C" {
2509 pub fn fread_unlocked(
2510 arg1: *mut ::std::os::raw::c_void,
2511 arg2: usize,
2512 arg3: usize,
2513 arg4: *mut FILE,
2514 ) -> usize;
2515}
2516extern "C" {
2517 pub fn fwrite_unlocked(
2518 arg1: *const ::std::os::raw::c_void,
2519 arg2: usize,
2520 arg3: usize,
2521 arg4: *mut FILE,
2522 ) -> usize;
2523}
2524extern "C" {
2525 pub fn clearerr_unlocked(arg1: *mut FILE);
2526}
2527extern "C" {
2528 pub fn feof_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
2529}
2530extern "C" {
2531 pub fn ferror_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
2532}
2533extern "C" {
2534 pub fn fileno_unlocked(arg1: *mut FILE) -> ::std::os::raw::c_int;
2535}
2536extern "C" {
2537 pub fn getw(arg1: *mut FILE) -> ::std::os::raw::c_int;
2538}
2539extern "C" {
2540 pub fn putw(arg1: ::std::os::raw::c_int, arg2: *mut FILE) -> ::std::os::raw::c_int;
2541}
2542extern "C" {
2543 pub fn fgetln(arg1: *mut FILE, arg2: *mut usize) -> *mut ::std::os::raw::c_char;
2544}
2545extern "C" {
2546 pub fn asprintf(
2547 arg1: *mut *mut ::std::os::raw::c_char,
2548 arg2: *const ::std::os::raw::c_char,
2549 ...
2550 ) -> ::std::os::raw::c_int;
2551}
2552extern "C" {
2553 pub fn vasprintf(
2554 arg1: *mut *mut ::std::os::raw::c_char,
2555 arg2: *const ::std::os::raw::c_char,
2556 arg3: __isoc_va_list,
2557 ) -> ::std::os::raw::c_int;
2558}
2559extern "C" {
2560 #[must_use]
2561 pub fn malloc(__size: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
2562}
2563extern "C" {
2564 pub fn free(__ptr: *mut ::std::os::raw::c_void);
2565}
2566extern "C" {
2567 #[must_use]
2568 pub fn calloc(
2569 __nmemb: ::std::os::raw::c_ulong,
2570 __size: ::std::os::raw::c_ulong,
2571 ) -> *mut ::std::os::raw::c_void;
2572}
2573extern "C" {
2574 #[must_use]
2575 pub fn realloc(
2576 __ptr: *mut ::std::os::raw::c_void,
2577 __size: ::std::os::raw::c_ulong,
2578 ) -> *mut ::std::os::raw::c_void;
2579}
2580extern "C" {
2581 #[must_use]
2582 pub fn reallocarray(
2583 __ptr: *mut ::std::os::raw::c_void,
2584 __nmemb: usize,
2585 __size: usize,
2586 ) -> *mut ::std::os::raw::c_void;
2587}
2588extern "C" {
2589 pub fn abort() -> !;
2590}
2591extern "C" {
2592 pub fn qsort(
2593 arg1: *mut ::std::os::raw::c_void,
2594 arg2: usize,
2595 arg3: usize,
2596 arg4: ::std::option::Option<
2597 unsafe extern "C" fn(
2598 arg1: *const ::std::os::raw::c_void,
2599 arg2: *const ::std::os::raw::c_void,
2600 ) -> ::std::os::raw::c_int,
2601 >,
2602 );
2603}
2604extern "C" {
2605 pub fn _Exit(arg1: ::std::os::raw::c_int) -> !;
2606}
2607extern "C" {
2608 pub fn atoi(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2609}
2610extern "C" {
2611 pub fn atol(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
2612}
2613extern "C" {
2614 pub fn atoll(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_longlong;
2615}
2616extern "C" {
2617 pub fn atof(arg1: *const ::std::os::raw::c_char) -> f64;
2618}
2619extern "C" {
2620 pub fn strtof(
2621 arg1: *const ::std::os::raw::c_char,
2622 arg2: *mut *mut ::std::os::raw::c_char,
2623 ) -> f32;
2624}
2625extern "C" {
2626 pub fn strtod(
2627 arg1: *const ::std::os::raw::c_char,
2628 arg2: *mut *mut ::std::os::raw::c_char,
2629 ) -> f64;
2630}
2631extern "C" {
2632 pub fn strtold(
2633 arg1: *const ::std::os::raw::c_char,
2634 arg2: *mut *mut ::std::os::raw::c_char,
2635 ) -> u128;
2636}
2637extern "C" {
2638 pub fn strtol(
2639 arg1: *const ::std::os::raw::c_char,
2640 arg2: *mut *mut ::std::os::raw::c_char,
2641 arg3: ::std::os::raw::c_int,
2642 ) -> ::std::os::raw::c_long;
2643}
2644extern "C" {
2645 pub fn strtoul(
2646 arg1: *const ::std::os::raw::c_char,
2647 arg2: *mut *mut ::std::os::raw::c_char,
2648 arg3: ::std::os::raw::c_int,
2649 ) -> ::std::os::raw::c_ulong;
2650}
2651extern "C" {
2652 pub fn strtoll(
2653 arg1: *const ::std::os::raw::c_char,
2654 arg2: *mut *mut ::std::os::raw::c_char,
2655 arg3: ::std::os::raw::c_int,
2656 ) -> ::std::os::raw::c_longlong;
2657}
2658extern "C" {
2659 pub fn strtoull(
2660 arg1: *const ::std::os::raw::c_char,
2661 arg2: *mut *mut ::std::os::raw::c_char,
2662 arg3: ::std::os::raw::c_int,
2663 ) -> ::std::os::raw::c_ulonglong;
2664}
2665extern "C" {
2666 pub fn rand() -> ::std::os::raw::c_int;
2667}
2668extern "C" {
2669 pub fn srand(arg1: ::std::os::raw::c_uint);
2670}
2671extern "C" {
2672 pub fn aligned_alloc(
2673 arg1: ::std::os::raw::c_ulong,
2674 arg2: ::std::os::raw::c_ulong,
2675 ) -> *mut ::std::os::raw::c_void;
2676}
2677extern "C" {
2678 pub fn atexit(arg1: ::std::option::Option<unsafe extern "C" fn()>) -> ::std::os::raw::c_int;
2679}
2680extern "C" {
2681 pub fn exit(arg1: ::std::os::raw::c_int) -> !;
2682}
2683extern "C" {
2684 pub fn at_quick_exit(
2685 arg1: ::std::option::Option<unsafe extern "C" fn()>,
2686 ) -> ::std::os::raw::c_int;
2687}
2688extern "C" {
2689 pub fn quick_exit(arg1: ::std::os::raw::c_int) -> !;
2690}
2691extern "C" {
2692 pub fn getenv(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2693}
2694extern "C" {
2695 pub fn system(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2696}
2697extern "C" {
2698 pub fn bsearch(
2699 arg1: *const ::std::os::raw::c_void,
2700 arg2: *const ::std::os::raw::c_void,
2701 arg3: usize,
2702 arg4: usize,
2703 arg5: ::std::option::Option<
2704 unsafe extern "C" fn(
2705 arg1: *const ::std::os::raw::c_void,
2706 arg2: *const ::std::os::raw::c_void,
2707 ) -> ::std::os::raw::c_int,
2708 >,
2709 ) -> *mut ::std::os::raw::c_void;
2710}
2711extern "C" {
2712 pub fn abs(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
2713}
2714extern "C" {
2715 pub fn labs(arg1: ::std::os::raw::c_long) -> ::std::os::raw::c_long;
2716}
2717extern "C" {
2718 pub fn llabs(arg1: ::std::os::raw::c_longlong) -> ::std::os::raw::c_longlong;
2719}
2720#[repr(C)]
2721#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2722pub struct div_t {
2723 pub quot: ::std::os::raw::c_int,
2724 pub rem: ::std::os::raw::c_int,
2725}
2726#[repr(C)]
2727#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2728pub struct ldiv_t {
2729 pub quot: ::std::os::raw::c_long,
2730 pub rem: ::std::os::raw::c_long,
2731}
2732#[repr(C)]
2733#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
2734pub struct lldiv_t {
2735 pub quot: ::std::os::raw::c_longlong,
2736 pub rem: ::std::os::raw::c_longlong,
2737}
2738extern "C" {
2739 pub fn div(arg1: ::std::os::raw::c_int, arg2: ::std::os::raw::c_int) -> div_t;
2740}
2741extern "C" {
2742 pub fn ldiv(arg1: ::std::os::raw::c_long, arg2: ::std::os::raw::c_long) -> ldiv_t;
2743}
2744extern "C" {
2745 pub fn lldiv(arg1: ::std::os::raw::c_longlong, arg2: ::std::os::raw::c_longlong) -> lldiv_t;
2746}
2747extern "C" {
2748 pub fn mblen(arg1: *const ::std::os::raw::c_char, arg2: usize) -> ::std::os::raw::c_int;
2749}
2750extern "C" {
2751 pub fn mbtowc(
2752 arg1: *mut wchar_t,
2753 arg2: *const ::std::os::raw::c_char,
2754 arg3: usize,
2755 ) -> ::std::os::raw::c_int;
2756}
2757extern "C" {
2758 pub fn wctomb(arg1: *mut ::std::os::raw::c_char, arg2: wchar_t) -> ::std::os::raw::c_int;
2759}
2760extern "C" {
2761 pub fn mbstowcs(arg1: *mut wchar_t, arg2: *const ::std::os::raw::c_char, arg3: usize) -> usize;
2762}
2763extern "C" {
2764 pub fn wcstombs(arg1: *mut ::std::os::raw::c_char, arg2: *const wchar_t, arg3: usize) -> usize;
2765}
2766extern "C" {
2767 pub fn __ctype_get_mb_cur_max() -> usize;
2768}
2769extern "C" {
2770 pub fn posix_memalign(
2771 arg1: *mut *mut ::std::os::raw::c_void,
2772 arg2: usize,
2773 arg3: usize,
2774 ) -> ::std::os::raw::c_int;
2775}
2776extern "C" {
2777 pub fn setenv(
2778 arg1: *const ::std::os::raw::c_char,
2779 arg2: *const ::std::os::raw::c_char,
2780 arg3: ::std::os::raw::c_int,
2781 ) -> ::std::os::raw::c_int;
2782}
2783extern "C" {
2784 pub fn unsetenv(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2785}
2786extern "C" {
2787 pub fn getsubopt(
2788 arg1: *mut *mut ::std::os::raw::c_char,
2789 arg2: *const *mut ::std::os::raw::c_char,
2790 arg3: *mut *mut ::std::os::raw::c_char,
2791 ) -> ::std::os::raw::c_int;
2792}
2793extern "C" {
2794 pub fn rand_r(arg1: *mut ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
2795}
2796extern "C" {
2797 pub fn random() -> ::std::os::raw::c_long;
2798}
2799extern "C" {
2800 pub fn srandom(arg1: ::std::os::raw::c_uint);
2801}
2802extern "C" {
2803 pub fn initstate(
2804 arg1: ::std::os::raw::c_uint,
2805 arg2: *mut ::std::os::raw::c_char,
2806 arg3: usize,
2807 ) -> *mut ::std::os::raw::c_char;
2808}
2809extern "C" {
2810 pub fn setstate(arg1: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2811}
2812extern "C" {
2813 pub fn putenv(arg1: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
2814}
2815extern "C" {
2816 pub fn l64a(arg1: ::std::os::raw::c_long) -> *mut ::std::os::raw::c_char;
2817}
2818extern "C" {
2819 pub fn a64l(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_long;
2820}
2821extern "C" {
2822 pub fn setkey(arg1: *const ::std::os::raw::c_char);
2823}
2824extern "C" {
2825 pub fn drand48() -> f64;
2826}
2827extern "C" {
2828 pub fn erand48(arg1: *mut ::std::os::raw::c_ushort) -> f64;
2829}
2830extern "C" {
2831 pub fn lrand48() -> ::std::os::raw::c_long;
2832}
2833extern "C" {
2834 pub fn nrand48(arg1: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
2835}
2836extern "C" {
2837 pub fn mrand48() -> ::std::os::raw::c_long;
2838}
2839extern "C" {
2840 pub fn jrand48(arg1: *mut ::std::os::raw::c_ushort) -> ::std::os::raw::c_long;
2841}
2842extern "C" {
2843 pub fn srand48(arg1: ::std::os::raw::c_long);
2844}
2845extern "C" {
2846 pub fn seed48(arg1: *mut ::std::os::raw::c_ushort) -> *mut ::std::os::raw::c_ushort;
2847}
2848extern "C" {
2849 pub fn lcong48(arg1: *mut ::std::os::raw::c_ushort);
2850}
2851extern "C" {
2852 pub fn alloca(arg1: ::std::os::raw::c_ulong) -> *mut ::std::os::raw::c_void;
2853}
2854extern "C" {
2855 pub fn clearenv() -> ::std::os::raw::c_int;
2856}
2857extern "C" {
2858 pub fn arc4random() -> u32;
2859}
2860extern "C" {
2861 pub fn arc4random_buf(arg1: *mut ::std::os::raw::c_void, arg2: usize);
2862}
2863extern "C" {
2864 pub fn arc4random_uniform(arg1: u32) -> u32;
2865}
2866extern "C" {
2867 pub fn memcpy(
2868 __dst: *mut ::std::os::raw::c_void,
2869 __src: *const ::std::os::raw::c_void,
2870 __n: ::std::os::raw::c_ulong,
2871 ) -> *mut ::std::os::raw::c_void;
2872}
2873extern "C" {
2874 pub fn memmove(
2875 __dst: *mut ::std::os::raw::c_void,
2876 __src: *const ::std::os::raw::c_void,
2877 __n: ::std::os::raw::c_ulong,
2878 ) -> *mut ::std::os::raw::c_void;
2879}
2880extern "C" {
2881 pub fn memset(
2882 __dst: *mut ::std::os::raw::c_void,
2883 __c: ::std::os::raw::c_int,
2884 __n: ::std::os::raw::c_ulong,
2885 ) -> *mut ::std::os::raw::c_void;
2886}
2887extern "C" {
2888 pub fn strlen(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulong;
2889}
2890extern "C" {
2891 pub fn strdup(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
2892}
2893extern "C" {
2894 pub fn strcmp(
2895 arg1: *const ::std::os::raw::c_char,
2896 arg2: *const ::std::os::raw::c_char,
2897 ) -> ::std::os::raw::c_int;
2898}
2899extern "C" {
2900 pub fn memchr(
2901 arg1: *const ::std::os::raw::c_void,
2902 arg2: ::std::os::raw::c_int,
2903 arg3: ::std::os::raw::c_ulong,
2904 ) -> *mut ::std::os::raw::c_void;
2905}
2906#[repr(C)]
2907#[derive(Debug, Copy, Clone)]
2908pub struct __locale_struct {
2909 _unused: [u8; 0],
2910}
2911pub type locale_t = *mut __locale_struct;
2912extern "C" {
2913 pub fn memcmp(
2914 arg1: *const ::std::os::raw::c_void,
2915 arg2: *const ::std::os::raw::c_void,
2916 arg3: ::std::os::raw::c_ulong,
2917 ) -> ::std::os::raw::c_int;
2918}
2919extern "C" {
2920 pub fn strcpy(
2921 arg1: *mut ::std::os::raw::c_char,
2922 arg2: *const ::std::os::raw::c_char,
2923 ) -> *mut ::std::os::raw::c_char;
2924}
2925extern "C" {
2926 pub fn strncpy(
2927 arg1: *mut ::std::os::raw::c_char,
2928 arg2: *const ::std::os::raw::c_char,
2929 arg3: ::std::os::raw::c_ulong,
2930 ) -> *mut ::std::os::raw::c_char;
2931}
2932extern "C" {
2933 pub fn strcat(
2934 arg1: *mut ::std::os::raw::c_char,
2935 arg2: *const ::std::os::raw::c_char,
2936 ) -> *mut ::std::os::raw::c_char;
2937}
2938extern "C" {
2939 pub fn strncat(
2940 arg1: *mut ::std::os::raw::c_char,
2941 arg2: *const ::std::os::raw::c_char,
2942 arg3: ::std::os::raw::c_ulong,
2943 ) -> *mut ::std::os::raw::c_char;
2944}
2945extern "C" {
2946 pub fn strncmp(
2947 arg1: *const ::std::os::raw::c_char,
2948 arg2: *const ::std::os::raw::c_char,
2949 arg3: ::std::os::raw::c_ulong,
2950 ) -> ::std::os::raw::c_int;
2951}
2952extern "C" {
2953 pub fn strcoll(
2954 arg1: *const ::std::os::raw::c_char,
2955 arg2: *const ::std::os::raw::c_char,
2956 ) -> ::std::os::raw::c_int;
2957}
2958extern "C" {
2959 pub fn strxfrm(
2960 arg1: *mut ::std::os::raw::c_char,
2961 arg2: *const ::std::os::raw::c_char,
2962 arg3: ::std::os::raw::c_ulong,
2963 ) -> ::std::os::raw::c_ulong;
2964}
2965extern "C" {
2966 pub fn strchr(
2967 arg1: *const ::std::os::raw::c_char,
2968 arg2: ::std::os::raw::c_int,
2969 ) -> *mut ::std::os::raw::c_char;
2970}
2971extern "C" {
2972 pub fn strrchr(
2973 arg1: *const ::std::os::raw::c_char,
2974 arg2: ::std::os::raw::c_int,
2975 ) -> *mut ::std::os::raw::c_char;
2976}
2977extern "C" {
2978 pub fn strcspn(
2979 arg1: *const ::std::os::raw::c_char,
2980 arg2: *const ::std::os::raw::c_char,
2981 ) -> ::std::os::raw::c_ulong;
2982}
2983extern "C" {
2984 pub fn strspn(
2985 arg1: *const ::std::os::raw::c_char,
2986 arg2: *const ::std::os::raw::c_char,
2987 ) -> ::std::os::raw::c_ulong;
2988}
2989extern "C" {
2990 pub fn strpbrk(
2991 arg1: *const ::std::os::raw::c_char,
2992 arg2: *const ::std::os::raw::c_char,
2993 ) -> *mut ::std::os::raw::c_char;
2994}
2995extern "C" {
2996 pub fn strstr(
2997 arg1: *const ::std::os::raw::c_char,
2998 arg2: *const ::std::os::raw::c_char,
2999 ) -> *mut ::std::os::raw::c_char;
3000}
3001extern "C" {
3002 pub fn strtok(
3003 arg1: *mut ::std::os::raw::c_char,
3004 arg2: *const ::std::os::raw::c_char,
3005 ) -> *mut ::std::os::raw::c_char;
3006}
3007extern "C" {
3008 pub fn strerror(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
3009}
3010extern "C" {
3011 pub fn bcmp(
3012 arg1: *const ::std::os::raw::c_void,
3013 arg2: *const ::std::os::raw::c_void,
3014 arg3: ::std::os::raw::c_ulong,
3015 ) -> ::std::os::raw::c_int;
3016}
3017extern "C" {
3018 pub fn bcopy(
3019 arg1: *const ::std::os::raw::c_void,
3020 arg2: *mut ::std::os::raw::c_void,
3021 arg3: usize,
3022 );
3023}
3024extern "C" {
3025 pub fn bzero(arg1: *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_ulong);
3026}
3027extern "C" {
3028 pub fn index(
3029 arg1: *const ::std::os::raw::c_char,
3030 arg2: ::std::os::raw::c_int,
3031 ) -> *mut ::std::os::raw::c_char;
3032}
3033extern "C" {
3034 pub fn rindex(
3035 arg1: *const ::std::os::raw::c_char,
3036 arg2: ::std::os::raw::c_int,
3037 ) -> *mut ::std::os::raw::c_char;
3038}
3039extern "C" {
3040 pub fn ffs(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
3041}
3042extern "C" {
3043 pub fn ffsl(arg1: ::std::os::raw::c_long) -> ::std::os::raw::c_int;
3044}
3045extern "C" {
3046 pub fn ffsll(arg1: ::std::os::raw::c_longlong) -> ::std::os::raw::c_int;
3047}
3048extern "C" {
3049 pub fn strcasecmp(
3050 arg1: *const ::std::os::raw::c_char,
3051 arg2: *const ::std::os::raw::c_char,
3052 ) -> ::std::os::raw::c_int;
3053}
3054extern "C" {
3055 pub fn strncasecmp(
3056 arg1: *const ::std::os::raw::c_char,
3057 arg2: *const ::std::os::raw::c_char,
3058 arg3: ::std::os::raw::c_ulong,
3059 ) -> ::std::os::raw::c_int;
3060}
3061extern "C" {
3062 pub fn strcasecmp_l(
3063 arg1: *const ::std::os::raw::c_char,
3064 arg2: *const ::std::os::raw::c_char,
3065 arg3: locale_t,
3066 ) -> ::std::os::raw::c_int;
3067}
3068extern "C" {
3069 pub fn strncasecmp_l(
3070 arg1: *const ::std::os::raw::c_char,
3071 arg2: *const ::std::os::raw::c_char,
3072 arg3: usize,
3073 arg4: locale_t,
3074 ) -> ::std::os::raw::c_int;
3075}
3076extern "C" {
3077 pub fn strtok_r(
3078 arg1: *mut ::std::os::raw::c_char,
3079 arg2: *const ::std::os::raw::c_char,
3080 arg3: *mut *mut ::std::os::raw::c_char,
3081 ) -> *mut ::std::os::raw::c_char;
3082}
3083extern "C" {
3084 pub fn strerror_r(
3085 arg1: ::std::os::raw::c_int,
3086 arg2: *mut ::std::os::raw::c_char,
3087 arg3: usize,
3088 ) -> ::std::os::raw::c_int;
3089}
3090extern "C" {
3091 pub fn stpcpy(
3092 arg1: *mut ::std::os::raw::c_char,
3093 arg2: *const ::std::os::raw::c_char,
3094 ) -> *mut ::std::os::raw::c_char;
3095}
3096extern "C" {
3097 pub fn stpncpy(
3098 arg1: *mut ::std::os::raw::c_char,
3099 arg2: *const ::std::os::raw::c_char,
3100 arg3: ::std::os::raw::c_ulong,
3101 ) -> *mut ::std::os::raw::c_char;
3102}
3103extern "C" {
3104 pub fn strnlen(arg1: *const ::std::os::raw::c_char, arg2: usize) -> usize;
3105}
3106extern "C" {
3107 pub fn strndup(
3108 arg1: *const ::std::os::raw::c_char,
3109 arg2: ::std::os::raw::c_ulong,
3110 ) -> *mut ::std::os::raw::c_char;
3111}
3112extern "C" {
3113 pub fn strsignal(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
3114}
3115extern "C" {
3116 pub fn strerror_l(arg1: ::std::os::raw::c_int, arg2: locale_t) -> *mut ::std::os::raw::c_char;
3117}
3118extern "C" {
3119 pub fn strcoll_l(
3120 arg1: *const ::std::os::raw::c_char,
3121 arg2: *const ::std::os::raw::c_char,
3122 arg3: locale_t,
3123 ) -> ::std::os::raw::c_int;
3124}
3125extern "C" {
3126 pub fn strxfrm_l(
3127 arg1: *mut ::std::os::raw::c_char,
3128 arg2: *const ::std::os::raw::c_char,
3129 arg3: usize,
3130 arg4: locale_t,
3131 ) -> usize;
3132}
3133extern "C" {
3134 pub fn memccpy(
3135 arg1: *mut ::std::os::raw::c_void,
3136 arg2: *const ::std::os::raw::c_void,
3137 arg3: ::std::os::raw::c_int,
3138 arg4: ::std::os::raw::c_ulong,
3139 ) -> *mut ::std::os::raw::c_void;
3140}
3141extern "C" {
3142 pub fn strsep(
3143 arg1: *mut *mut ::std::os::raw::c_char,
3144 arg2: *const ::std::os::raw::c_char,
3145 ) -> *mut ::std::os::raw::c_char;
3146}
3147extern "C" {
3148 pub fn strlcat(
3149 arg1: *mut ::std::os::raw::c_char,
3150 arg2: *const ::std::os::raw::c_char,
3151 arg3: ::std::os::raw::c_ulong,
3152 ) -> ::std::os::raw::c_ulong;
3153}
3154extern "C" {
3155 pub fn strlcpy(
3156 arg1: *mut ::std::os::raw::c_char,
3157 arg2: *const ::std::os::raw::c_char,
3158 arg3: ::std::os::raw::c_ulong,
3159 ) -> ::std::os::raw::c_ulong;
3160}
3161extern "C" {
3162 pub fn explicit_bzero(arg1: *mut ::std::os::raw::c_void, arg2: usize);
3163}
3164extern "C" {
3165 #[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"]
3166 pub fn av_strerror(
3167 errnum: ::std::os::raw::c_int,
3168 errbuf: *mut ::std::os::raw::c_char,
3169 errbuf_size: usize,
3170 ) -> ::std::os::raw::c_int;
3171}
3172extern "C" {
3173 #[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()"]
3174 pub fn av_malloc(size: usize) -> *mut ::std::os::raw::c_void;
3175}
3176extern "C" {
3177 #[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()"]
3178 pub fn av_mallocz(size: usize) -> *mut ::std::os::raw::c_void;
3179}
3180extern "C" {
3181 #[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()"]
3182 pub fn av_malloc_array(nmemb: usize, size: usize) -> *mut ::std::os::raw::c_void;
3183}
3184extern "C" {
3185 #[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()"]
3186 pub fn av_calloc(nmemb: usize, size: usize) -> *mut ::std::os::raw::c_void;
3187}
3188extern "C" {
3189 #[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()"]
3190 pub fn av_realloc(ptr: *mut ::std::os::raw::c_void, size: usize)
3191 -> *mut ::std::os::raw::c_void;
3192}
3193extern "C" {
3194 #[must_use]
3195 #[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."]
3196 pub fn av_reallocp(ptr: *mut ::std::os::raw::c_void, size: usize) -> ::std::os::raw::c_int;
3197}
3198extern "C" {
3199 #[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."]
3200 pub fn av_realloc_f(
3201 ptr: *mut ::std::os::raw::c_void,
3202 nelem: usize,
3203 elsize: usize,
3204 ) -> *mut ::std::os::raw::c_void;
3205}
3206extern "C" {
3207 #[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()"]
3208 pub fn av_realloc_array(
3209 ptr: *mut ::std::os::raw::c_void,
3210 nmemb: usize,
3211 size: usize,
3212 ) -> *mut ::std::os::raw::c_void;
3213}
3214extern "C" {
3215 #[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."]
3216 pub fn av_reallocp_array(
3217 ptr: *mut ::std::os::raw::c_void,
3218 nmemb: usize,
3219 size: usize,
3220 ) -> ::std::os::raw::c_int;
3221}
3222extern "C" {
3223 #[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()"]
3224 pub fn av_fast_realloc(
3225 ptr: *mut ::std::os::raw::c_void,
3226 size: *mut ::std::os::raw::c_uint,
3227 min_size: usize,
3228 ) -> *mut ::std::os::raw::c_void;
3229}
3230extern "C" {
3231 #[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()"]
3232 pub fn av_fast_malloc(
3233 ptr: *mut ::std::os::raw::c_void,
3234 size: *mut ::std::os::raw::c_uint,
3235 min_size: usize,
3236 );
3237}
3238extern "C" {
3239 #[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()"]
3240 pub fn av_fast_mallocz(
3241 ptr: *mut ::std::os::raw::c_void,
3242 size: *mut ::std::os::raw::c_uint,
3243 min_size: usize,
3244 );
3245}
3246extern "C" {
3247 #[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()"]
3248 pub fn av_free(ptr: *mut ::std::os::raw::c_void);
3249}
3250extern "C" {
3251 #[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()"]
3252 pub fn av_freep(ptr: *mut ::std::os::raw::c_void);
3253}
3254extern "C" {
3255 #[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()"]
3256 pub fn av_strdup(s: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
3257}
3258extern "C" {
3259 #[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"]
3260 pub fn av_strndup(s: *const ::std::os::raw::c_char, len: usize) -> *mut ::std::os::raw::c_char;
3261}
3262extern "C" {
3263 #[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"]
3264 pub fn av_memdup(p: *const ::std::os::raw::c_void, size: usize) -> *mut ::std::os::raw::c_void;
3265}
3266extern "C" {
3267 #[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`."]
3268 pub fn av_memcpy_backptr(dst: *mut u8, back: ::std::os::raw::c_int, cnt: ::std::os::raw::c_int);
3269}
3270extern "C" {
3271 #[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()"]
3272 pub fn av_dynarray_add(
3273 tab_ptr: *mut ::std::os::raw::c_void,
3274 nb_ptr: *mut ::std::os::raw::c_int,
3275 elem: *mut ::std::os::raw::c_void,
3276 );
3277}
3278extern "C" {
3279 #[must_use]
3280 #[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()"]
3281 pub fn av_dynarray_add_nofree(
3282 tab_ptr: *mut ::std::os::raw::c_void,
3283 nb_ptr: *mut ::std::os::raw::c_int,
3284 elem: *mut ::std::os::raw::c_void,
3285 ) -> ::std::os::raw::c_int;
3286}
3287extern "C" {
3288 #[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()"]
3289 pub fn av_dynarray2_add(
3290 tab_ptr: *mut *mut ::std::os::raw::c_void,
3291 nb_ptr: *mut ::std::os::raw::c_int,
3292 elem_size: usize,
3293 elem_data: *const u8,
3294 ) -> *mut ::std::os::raw::c_void;
3295}
3296extern "C" {
3297 #[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"]
3298 pub fn av_size_mult(a: usize, b: usize, r: *mut usize) -> ::std::os::raw::c_int;
3299}
3300extern "C" {
3301 #[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."]
3302 pub fn av_max_alloc(max: usize);
3303}
3304extern "C" {
3305 pub fn av_log2(v: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
3306}
3307extern "C" {
3308 pub fn av_log2_16bit(v: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
3309}
3310#[doc = " Rational number (pair of numerator and denominator)."]
3311#[repr(C)]
3312#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3313pub struct AVRational {
3314 #[doc = "< Numerator"]
3315 pub num: ::std::os::raw::c_int,
3316 #[doc = "< Denominator"]
3317 pub den: ::std::os::raw::c_int,
3318}
3319extern "C" {
3320 #[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"]
3321 pub fn av_reduce(
3322 dst_num: *mut ::std::os::raw::c_int,
3323 dst_den: *mut ::std::os::raw::c_int,
3324 num: i64,
3325 den: i64,
3326 max: i64,
3327 ) -> ::std::os::raw::c_int;
3328}
3329extern "C" {
3330 #[doc = " Multiply two rationals.\n @param b First rational\n @param c Second rational\n @return b*c"]
3331 pub fn av_mul_q(b: AVRational, c: AVRational) -> AVRational;
3332}
3333extern "C" {
3334 #[doc = " Divide one rational by another.\n @param b First rational\n @param c Second rational\n @return b/c"]
3335 pub fn av_div_q(b: AVRational, c: AVRational) -> AVRational;
3336}
3337extern "C" {
3338 #[doc = " Add two rationals.\n @param b First rational\n @param c Second rational\n @return b+c"]
3339 pub fn av_add_q(b: AVRational, c: AVRational) -> AVRational;
3340}
3341extern "C" {
3342 #[doc = " Subtract one rational from another.\n @param b First rational\n @param c Second rational\n @return b-c"]
3343 pub fn av_sub_q(b: AVRational, c: AVRational) -> AVRational;
3344}
3345extern "C" {
3346 #[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()"]
3347 pub fn av_d2q(d: f64, max: ::std::os::raw::c_int) -> AVRational;
3348}
3349extern "C" {
3350 #[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"]
3351 pub fn av_nearer_q(q: AVRational, q1: AVRational, q2: AVRational) -> ::std::os::raw::c_int;
3352}
3353extern "C" {
3354 #[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"]
3355 pub fn av_find_nearest_q_idx(q: AVRational, q_list: *const AVRational)
3356 -> ::std::os::raw::c_int;
3357}
3358extern "C" {
3359 #[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."]
3360 pub fn av_q2intfloat(q: AVRational) -> u32;
3361}
3362extern "C" {
3363 #[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."]
3364 pub fn av_gcd_q(
3365 a: AVRational,
3366 b: AVRational,
3367 max_den: ::std::os::raw::c_int,
3368 def: AVRational,
3369 ) -> AVRational;
3370}
3371#[repr(C)]
3372#[derive(Copy, Clone)]
3373pub union av_intfloat32 {
3374 pub i: u32,
3375 pub f: f32,
3376}
3377impl Default for av_intfloat32 {
3378 fn default() -> Self {
3379 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3380 unsafe {
3381 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3382 s.assume_init()
3383 }
3384 }
3385}
3386#[repr(C)]
3387#[derive(Copy, Clone)]
3388pub union av_intfloat64 {
3389 pub i: u64,
3390 pub f: f64,
3391}
3392impl Default for av_intfloat64 {
3393 fn default() -> Self {
3394 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3395 unsafe {
3396 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3397 s.assume_init()
3398 }
3399 }
3400}
3401#[doc = "< Round toward zero."]
3402pub const AVRounding_AV_ROUND_ZERO: AVRounding = 0;
3403#[doc = "< Round away from zero."]
3404pub const AVRounding_AV_ROUND_INF: AVRounding = 1;
3405#[doc = "< Round toward -infinity."]
3406pub const AVRounding_AV_ROUND_DOWN: AVRounding = 2;
3407#[doc = "< Round toward +infinity."]
3408pub const AVRounding_AV_ROUND_UP: AVRounding = 3;
3409#[doc = "< Round to nearest and halfway cases away from zero."]
3410pub const AVRounding_AV_ROUND_NEAR_INF: AVRounding = 5;
3411#[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"]
3412pub const AVRounding_AV_ROUND_PASS_MINMAX: AVRounding = 8192;
3413#[doc = " Rounding methods."]
3414pub type AVRounding = ::std::os::raw::c_uint;
3415extern "C" {
3416 #[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."]
3417 pub fn av_gcd(a: i64, b: i64) -> i64;
3418}
3419extern "C" {
3420 #[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()"]
3421 pub fn av_rescale(a: i64, b: i64, c: i64) -> i64;
3422}
3423extern "C" {
3424 #[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()"]
3425 pub fn av_rescale_rnd(a: i64, b: i64, c: i64, rnd: AVRounding) -> i64;
3426}
3427extern "C" {
3428 #[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()"]
3429 pub fn av_rescale_q(a: i64, bq: AVRational, cq: AVRational) -> i64;
3430}
3431extern "C" {
3432 #[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()"]
3433 pub fn av_rescale_q_rnd(a: i64, bq: AVRational, cq: AVRational, rnd: AVRounding) -> i64;
3434}
3435extern "C" {
3436 #[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."]
3437 pub fn av_compare_ts(
3438 ts_a: i64,
3439 tb_a: AVRational,
3440 ts_b: i64,
3441 tb_b: AVRational,
3442 ) -> ::std::os::raw::c_int;
3443}
3444extern "C" {
3445 #[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`"]
3446 pub fn av_compare_mod(a: u64, b: u64, mod_: u64) -> i64;
3447}
3448extern "C" {
3449 #[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."]
3450 pub fn av_rescale_delta(
3451 in_tb: AVRational,
3452 in_ts: i64,
3453 fs_tb: AVRational,
3454 duration: ::std::os::raw::c_int,
3455 last: *mut i64,
3456 out_tb: AVRational,
3457 ) -> i64;
3458}
3459extern "C" {
3460 #[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`"]
3461 pub fn av_add_stable(ts_tb: AVRational, ts: i64, inc_tb: AVRational, inc: i64) -> i64;
3462}
3463extern "C" {
3464 #[doc = " 0th order modified bessel function of the first kind."]
3465 pub fn av_bessel_i0(x: f64) -> f64;
3466}
3467pub type __gnuc_va_list = __builtin_va_list;
3468pub const AVClassCategory_AV_CLASS_CATEGORY_NA: AVClassCategory = 0;
3469pub const AVClassCategory_AV_CLASS_CATEGORY_INPUT: AVClassCategory = 1;
3470pub const AVClassCategory_AV_CLASS_CATEGORY_OUTPUT: AVClassCategory = 2;
3471pub const AVClassCategory_AV_CLASS_CATEGORY_MUXER: AVClassCategory = 3;
3472pub const AVClassCategory_AV_CLASS_CATEGORY_DEMUXER: AVClassCategory = 4;
3473pub const AVClassCategory_AV_CLASS_CATEGORY_ENCODER: AVClassCategory = 5;
3474pub const AVClassCategory_AV_CLASS_CATEGORY_DECODER: AVClassCategory = 6;
3475pub const AVClassCategory_AV_CLASS_CATEGORY_FILTER: AVClassCategory = 7;
3476pub const AVClassCategory_AV_CLASS_CATEGORY_BITSTREAM_FILTER: AVClassCategory = 8;
3477pub const AVClassCategory_AV_CLASS_CATEGORY_SWSCALER: AVClassCategory = 9;
3478pub const AVClassCategory_AV_CLASS_CATEGORY_SWRESAMPLER: AVClassCategory = 10;
3479pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT: AVClassCategory = 40;
3480pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT: AVClassCategory = 41;
3481pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT: AVClassCategory = 42;
3482pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT: AVClassCategory = 43;
3483pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_OUTPUT: AVClassCategory = 44;
3484pub const AVClassCategory_AV_CLASS_CATEGORY_DEVICE_INPUT: AVClassCategory = 45;
3485#[doc = "< not part of ABI/API"]
3486pub const AVClassCategory_AV_CLASS_CATEGORY_NB: AVClassCategory = 46;
3487pub type AVClassCategory = ::std::os::raw::c_uint;
3488#[repr(C)]
3489#[derive(Debug, Copy, Clone)]
3490pub struct AVOptionRanges {
3491 _unused: [u8; 0],
3492}
3493#[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.)."]
3494#[repr(C)]
3495#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
3496pub struct AVClass {
3497 #[doc = " The name of the class; usually it is the same name as the\n context structure type to which the AVClass is associated."]
3498 pub class_name: *const ::std::os::raw::c_char,
3499 #[doc = " A pointer to a function which returns the name of a context\n instance ctx associated with the class."]
3500 pub item_name: ::std::option::Option<
3501 unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void) -> *const ::std::os::raw::c_char,
3502 >,
3503 #[doc = " a pointer to the first option specified in the class if any or NULL\n\n @see av_set_default_options()"]
3504 pub option: *mut AVOption,
3505 #[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."]
3506 pub version: ::std::os::raw::c_int,
3507 #[doc = " Offset in the structure where log_level_offset is stored.\n 0 means there is no such variable"]
3508 pub log_level_offset_offset: ::std::os::raw::c_int,
3509 #[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."]
3510 pub parent_log_context_offset: ::std::os::raw::c_int,
3511 #[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)"]
3512 pub category: AVClassCategory,
3513 #[doc = " Callback to return the category.\n available since version (51 << 16 | 59 << 8 | 100)"]
3514 pub get_category: ::std::option::Option<
3515 unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void) -> AVClassCategory,
3516 >,
3517 #[doc = " Callback to return the supported/allowed ranges.\n available since version (52.12)"]
3518 pub query_ranges: ::std::option::Option<
3519 unsafe extern "C" fn(
3520 arg1: *mut *mut AVOptionRanges,
3521 obj: *mut ::std::os::raw::c_void,
3522 key: *const ::std::os::raw::c_char,
3523 flags: ::std::os::raw::c_int,
3524 ) -> ::std::os::raw::c_int,
3525 >,
3526 #[doc = " Return next AVOptions-enabled child or NULL"]
3527 pub child_next: ::std::option::Option<
3528 unsafe extern "C" fn(
3529 obj: *mut ::std::os::raw::c_void,
3530 prev: *mut ::std::os::raw::c_void,
3531 ) -> *mut ::std::os::raw::c_void,
3532 >,
3533 #[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."]
3534 pub child_class_iterate: ::std::option::Option<
3535 unsafe extern "C" fn(iter: *mut *mut ::std::os::raw::c_void) -> *const AVClass,
3536 >,
3537}
3538impl Default for AVClass {
3539 fn default() -> Self {
3540 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3541 unsafe {
3542 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3543 s.assume_init()
3544 }
3545 }
3546}
3547extern "C" {
3548 #[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."]
3549 pub fn av_log(
3550 avcl: *mut ::std::os::raw::c_void,
3551 level: ::std::os::raw::c_int,
3552 fmt: *const ::std::os::raw::c_char,
3553 ...
3554 );
3555}
3556extern "C" {
3557 #[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."]
3558 pub fn av_log_once(
3559 avcl: *mut ::std::os::raw::c_void,
3560 initial_level: ::std::os::raw::c_int,
3561 subsequent_level: ::std::os::raw::c_int,
3562 state: *mut ::std::os::raw::c_int,
3563 fmt: *const ::std::os::raw::c_char,
3564 ...
3565 );
3566}
3567extern "C" {
3568 #[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."]
3569 pub fn av_vlog(
3570 avcl: *mut ::std::os::raw::c_void,
3571 level: ::std::os::raw::c_int,
3572 fmt: *const ::std::os::raw::c_char,
3573 vl: va_list,
3574 );
3575}
3576extern "C" {
3577 #[doc = " Get the current log level\n\n @see lavu_log_constants\n\n @return Current log level"]
3578 pub fn av_log_get_level() -> ::std::os::raw::c_int;
3579}
3580extern "C" {
3581 #[doc = " Set the log level\n\n @see lavu_log_constants\n\n @param level Logging level"]
3582 pub fn av_log_set_level(level: ::std::os::raw::c_int);
3583}
3584extern "C" {
3585 #[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."]
3586 pub fn av_log_set_callback(
3587 callback: ::std::option::Option<
3588 unsafe extern "C" fn(
3589 arg1: *mut ::std::os::raw::c_void,
3590 arg2: ::std::os::raw::c_int,
3591 arg3: *const ::std::os::raw::c_char,
3592 arg4: va_list,
3593 ),
3594 >,
3595 );
3596}
3597extern "C" {
3598 #[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."]
3599 pub fn av_log_default_callback(
3600 avcl: *mut ::std::os::raw::c_void,
3601 level: ::std::os::raw::c_int,
3602 fmt: *const ::std::os::raw::c_char,
3603 vl: va_list,
3604 );
3605}
3606extern "C" {
3607 #[doc = " Return the context name\n\n @param ctx The AVClass context\n\n @return The AVClass class_name"]
3608 pub fn av_default_item_name(ctx: *mut ::std::os::raw::c_void) -> *const ::std::os::raw::c_char;
3609}
3610extern "C" {
3611 pub fn av_default_get_category(ptr: *mut ::std::os::raw::c_void) -> AVClassCategory;
3612}
3613extern "C" {
3614 #[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"]
3615 pub fn av_log_format_line(
3616 ptr: *mut ::std::os::raw::c_void,
3617 level: ::std::os::raw::c_int,
3618 fmt: *const ::std::os::raw::c_char,
3619 vl: va_list,
3620 line: *mut ::std::os::raw::c_char,
3621 line_size: ::std::os::raw::c_int,
3622 print_prefix: *mut ::std::os::raw::c_int,
3623 );
3624}
3625extern "C" {
3626 #[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."]
3627 pub fn av_log_format_line2(
3628 ptr: *mut ::std::os::raw::c_void,
3629 level: ::std::os::raw::c_int,
3630 fmt: *const ::std::os::raw::c_char,
3631 vl: va_list,
3632 line: *mut ::std::os::raw::c_char,
3633 line_size: ::std::os::raw::c_int,
3634 print_prefix: *mut ::std::os::raw::c_int,
3635 ) -> ::std::os::raw::c_int;
3636}
3637extern "C" {
3638 pub fn av_log_set_flags(arg: ::std::os::raw::c_int);
3639}
3640extern "C" {
3641 pub fn av_log_get_flags() -> ::std::os::raw::c_int;
3642}
3643pub const AVPixelFormat_AV_PIX_FMT_NONE: AVPixelFormat = -1;
3644#[doc = "< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)"]
3645pub const AVPixelFormat_AV_PIX_FMT_YUV420P: AVPixelFormat = 0;
3646#[doc = "< packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr"]
3647pub const AVPixelFormat_AV_PIX_FMT_YUYV422: AVPixelFormat = 1;
3648#[doc = "< packed RGB 8:8:8, 24bpp, RGBRGB..."]
3649pub const AVPixelFormat_AV_PIX_FMT_RGB24: AVPixelFormat = 2;
3650#[doc = "< packed RGB 8:8:8, 24bpp, BGRBGR..."]
3651pub const AVPixelFormat_AV_PIX_FMT_BGR24: AVPixelFormat = 3;
3652#[doc = "< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)"]
3653pub const AVPixelFormat_AV_PIX_FMT_YUV422P: AVPixelFormat = 4;
3654#[doc = "< planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)"]
3655pub const AVPixelFormat_AV_PIX_FMT_YUV444P: AVPixelFormat = 5;
3656#[doc = "< planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)"]
3657pub const AVPixelFormat_AV_PIX_FMT_YUV410P: AVPixelFormat = 6;
3658#[doc = "< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)"]
3659pub const AVPixelFormat_AV_PIX_FMT_YUV411P: AVPixelFormat = 7;
3660#[doc = "< Y , 8bpp"]
3661pub const AVPixelFormat_AV_PIX_FMT_GRAY8: AVPixelFormat = 8;
3662#[doc = "< Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb"]
3663pub const AVPixelFormat_AV_PIX_FMT_MONOWHITE: AVPixelFormat = 9;
3664#[doc = "< Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb"]
3665pub const AVPixelFormat_AV_PIX_FMT_MONOBLACK: AVPixelFormat = 10;
3666#[doc = "< 8 bits with AV_PIX_FMT_RGB32 palette"]
3667pub const AVPixelFormat_AV_PIX_FMT_PAL8: AVPixelFormat = 11;
3668#[doc = "< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting color_range"]
3669pub const AVPixelFormat_AV_PIX_FMT_YUVJ420P: AVPixelFormat = 12;
3670#[doc = "< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting color_range"]
3671pub const AVPixelFormat_AV_PIX_FMT_YUVJ422P: AVPixelFormat = 13;
3672#[doc = "< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting color_range"]
3673pub const AVPixelFormat_AV_PIX_FMT_YUVJ444P: AVPixelFormat = 14;
3674#[doc = "< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1"]
3675pub const AVPixelFormat_AV_PIX_FMT_UYVY422: AVPixelFormat = 15;
3676#[doc = "< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3"]
3677pub const AVPixelFormat_AV_PIX_FMT_UYYVYY411: AVPixelFormat = 16;
3678#[doc = "< packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)"]
3679pub const AVPixelFormat_AV_PIX_FMT_BGR8: AVPixelFormat = 17;
3680#[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"]
3681pub const AVPixelFormat_AV_PIX_FMT_BGR4: AVPixelFormat = 18;
3682#[doc = "< packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)"]
3683pub const AVPixelFormat_AV_PIX_FMT_BGR4_BYTE: AVPixelFormat = 19;
3684#[doc = "< packed RGB 3:3:2, 8bpp, (msb)3R 3G 2B(lsb)"]
3685pub const AVPixelFormat_AV_PIX_FMT_RGB8: AVPixelFormat = 20;
3686#[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"]
3687pub const AVPixelFormat_AV_PIX_FMT_RGB4: AVPixelFormat = 21;
3688#[doc = "< packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)"]
3689pub const AVPixelFormat_AV_PIX_FMT_RGB4_BYTE: AVPixelFormat = 22;
3690#[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)"]
3691pub const AVPixelFormat_AV_PIX_FMT_NV12: AVPixelFormat = 23;
3692#[doc = "< as above, but U and V bytes are swapped"]
3693pub const AVPixelFormat_AV_PIX_FMT_NV21: AVPixelFormat = 24;
3694#[doc = "< packed ARGB 8:8:8:8, 32bpp, ARGBARGB..."]
3695pub const AVPixelFormat_AV_PIX_FMT_ARGB: AVPixelFormat = 25;
3696#[doc = "< packed RGBA 8:8:8:8, 32bpp, RGBARGBA..."]
3697pub const AVPixelFormat_AV_PIX_FMT_RGBA: AVPixelFormat = 26;
3698#[doc = "< packed ABGR 8:8:8:8, 32bpp, ABGRABGR..."]
3699pub const AVPixelFormat_AV_PIX_FMT_ABGR: AVPixelFormat = 27;
3700#[doc = "< packed BGRA 8:8:8:8, 32bpp, BGRABGRA..."]
3701pub const AVPixelFormat_AV_PIX_FMT_BGRA: AVPixelFormat = 28;
3702#[doc = "< Y , 16bpp, big-endian"]
3703pub const AVPixelFormat_AV_PIX_FMT_GRAY16BE: AVPixelFormat = 29;
3704#[doc = "< Y , 16bpp, little-endian"]
3705pub const AVPixelFormat_AV_PIX_FMT_GRAY16LE: AVPixelFormat = 30;
3706#[doc = "< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)"]
3707pub const AVPixelFormat_AV_PIX_FMT_YUV440P: AVPixelFormat = 31;
3708#[doc = "< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range"]
3709pub const AVPixelFormat_AV_PIX_FMT_YUVJ440P: AVPixelFormat = 32;
3710#[doc = "< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)"]
3711pub const AVPixelFormat_AV_PIX_FMT_YUVA420P: AVPixelFormat = 33;
3712#[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"]
3713pub const AVPixelFormat_AV_PIX_FMT_RGB48BE: AVPixelFormat = 34;
3714#[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"]
3715pub const AVPixelFormat_AV_PIX_FMT_RGB48LE: AVPixelFormat = 35;
3716#[doc = "< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian"]
3717pub const AVPixelFormat_AV_PIX_FMT_RGB565BE: AVPixelFormat = 36;
3718#[doc = "< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian"]
3719pub const AVPixelFormat_AV_PIX_FMT_RGB565LE: AVPixelFormat = 37;
3720#[doc = "< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined"]
3721pub const AVPixelFormat_AV_PIX_FMT_RGB555BE: AVPixelFormat = 38;
3722#[doc = "< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined"]
3723pub const AVPixelFormat_AV_PIX_FMT_RGB555LE: AVPixelFormat = 39;
3724#[doc = "< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian"]
3725pub const AVPixelFormat_AV_PIX_FMT_BGR565BE: AVPixelFormat = 40;
3726#[doc = "< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian"]
3727pub const AVPixelFormat_AV_PIX_FMT_BGR565LE: AVPixelFormat = 41;
3728#[doc = "< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined"]
3729pub const AVPixelFormat_AV_PIX_FMT_BGR555BE: AVPixelFormat = 42;
3730#[doc = "< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined"]
3731pub const AVPixelFormat_AV_PIX_FMT_BGR555LE: AVPixelFormat = 43;
3732#[doc = " Hardware acceleration through VA-API, data[3] contains a\n VASurfaceID."]
3733pub const AVPixelFormat_AV_PIX_FMT_VAAPI: AVPixelFormat = 44;
3734#[doc = "< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian"]
3735pub const AVPixelFormat_AV_PIX_FMT_YUV420P16LE: AVPixelFormat = 45;
3736#[doc = "< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian"]
3737pub const AVPixelFormat_AV_PIX_FMT_YUV420P16BE: AVPixelFormat = 46;
3738#[doc = "< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3739pub const AVPixelFormat_AV_PIX_FMT_YUV422P16LE: AVPixelFormat = 47;
3740#[doc = "< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3741pub const AVPixelFormat_AV_PIX_FMT_YUV422P16BE: AVPixelFormat = 48;
3742#[doc = "< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian"]
3743pub const AVPixelFormat_AV_PIX_FMT_YUV444P16LE: AVPixelFormat = 49;
3744#[doc = "< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian"]
3745pub const AVPixelFormat_AV_PIX_FMT_YUV444P16BE: AVPixelFormat = 50;
3746#[doc = "< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer"]
3747pub const AVPixelFormat_AV_PIX_FMT_DXVA2_VLD: AVPixelFormat = 51;
3748#[doc = "< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined"]
3749pub const AVPixelFormat_AV_PIX_FMT_RGB444LE: AVPixelFormat = 52;
3750#[doc = "< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined"]
3751pub const AVPixelFormat_AV_PIX_FMT_RGB444BE: AVPixelFormat = 53;
3752#[doc = "< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined"]
3753pub const AVPixelFormat_AV_PIX_FMT_BGR444LE: AVPixelFormat = 54;
3754#[doc = "< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined"]
3755pub const AVPixelFormat_AV_PIX_FMT_BGR444BE: AVPixelFormat = 55;
3756#[doc = "< 8 bits gray, 8 bits alpha"]
3757pub const AVPixelFormat_AV_PIX_FMT_YA8: AVPixelFormat = 56;
3758#[doc = "< alias for AV_PIX_FMT_YA8"]
3759pub const AVPixelFormat_AV_PIX_FMT_Y400A: AVPixelFormat = 56;
3760#[doc = "< alias for AV_PIX_FMT_YA8"]
3761pub const AVPixelFormat_AV_PIX_FMT_GRAY8A: AVPixelFormat = 56;
3762#[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"]
3763pub const AVPixelFormat_AV_PIX_FMT_BGR48BE: AVPixelFormat = 57;
3764#[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"]
3765pub const AVPixelFormat_AV_PIX_FMT_BGR48LE: AVPixelFormat = 58;
3766#[doc = "< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian"]
3767pub const AVPixelFormat_AV_PIX_FMT_YUV420P9BE: AVPixelFormat = 59;
3768#[doc = "< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian"]
3769pub const AVPixelFormat_AV_PIX_FMT_YUV420P9LE: AVPixelFormat = 60;
3770#[doc = "< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian"]
3771pub const AVPixelFormat_AV_PIX_FMT_YUV420P10BE: AVPixelFormat = 61;
3772#[doc = "< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian"]
3773pub const AVPixelFormat_AV_PIX_FMT_YUV420P10LE: AVPixelFormat = 62;
3774#[doc = "< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3775pub const AVPixelFormat_AV_PIX_FMT_YUV422P10BE: AVPixelFormat = 63;
3776#[doc = "< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3777pub const AVPixelFormat_AV_PIX_FMT_YUV422P10LE: AVPixelFormat = 64;
3778#[doc = "< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian"]
3779pub const AVPixelFormat_AV_PIX_FMT_YUV444P9BE: AVPixelFormat = 65;
3780#[doc = "< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian"]
3781pub const AVPixelFormat_AV_PIX_FMT_YUV444P9LE: AVPixelFormat = 66;
3782#[doc = "< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian"]
3783pub const AVPixelFormat_AV_PIX_FMT_YUV444P10BE: AVPixelFormat = 67;
3784#[doc = "< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian"]
3785pub const AVPixelFormat_AV_PIX_FMT_YUV444P10LE: AVPixelFormat = 68;
3786#[doc = "< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3787pub const AVPixelFormat_AV_PIX_FMT_YUV422P9BE: AVPixelFormat = 69;
3788#[doc = "< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3789pub const AVPixelFormat_AV_PIX_FMT_YUV422P9LE: AVPixelFormat = 70;
3790#[doc = "< planar GBR 4:4:4 24bpp"]
3791pub const AVPixelFormat_AV_PIX_FMT_GBRP: AVPixelFormat = 71;
3792pub const AVPixelFormat_AV_PIX_FMT_GBR24P: AVPixelFormat = 71;
3793#[doc = "< planar GBR 4:4:4 27bpp, big-endian"]
3794pub const AVPixelFormat_AV_PIX_FMT_GBRP9BE: AVPixelFormat = 72;
3795#[doc = "< planar GBR 4:4:4 27bpp, little-endian"]
3796pub const AVPixelFormat_AV_PIX_FMT_GBRP9LE: AVPixelFormat = 73;
3797#[doc = "< planar GBR 4:4:4 30bpp, big-endian"]
3798pub const AVPixelFormat_AV_PIX_FMT_GBRP10BE: AVPixelFormat = 74;
3799#[doc = "< planar GBR 4:4:4 30bpp, little-endian"]
3800pub const AVPixelFormat_AV_PIX_FMT_GBRP10LE: AVPixelFormat = 75;
3801#[doc = "< planar GBR 4:4:4 48bpp, big-endian"]
3802pub const AVPixelFormat_AV_PIX_FMT_GBRP16BE: AVPixelFormat = 76;
3803#[doc = "< planar GBR 4:4:4 48bpp, little-endian"]
3804pub const AVPixelFormat_AV_PIX_FMT_GBRP16LE: AVPixelFormat = 77;
3805#[doc = "< planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)"]
3806pub const AVPixelFormat_AV_PIX_FMT_YUVA422P: AVPixelFormat = 78;
3807#[doc = "< planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)"]
3808pub const AVPixelFormat_AV_PIX_FMT_YUVA444P: AVPixelFormat = 79;
3809#[doc = "< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian"]
3810pub const AVPixelFormat_AV_PIX_FMT_YUVA420P9BE: AVPixelFormat = 80;
3811#[doc = "< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian"]
3812pub const AVPixelFormat_AV_PIX_FMT_YUVA420P9LE: AVPixelFormat = 81;
3813#[doc = "< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian"]
3814pub const AVPixelFormat_AV_PIX_FMT_YUVA422P9BE: AVPixelFormat = 82;
3815#[doc = "< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian"]
3816pub const AVPixelFormat_AV_PIX_FMT_YUVA422P9LE: AVPixelFormat = 83;
3817#[doc = "< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian"]
3818pub const AVPixelFormat_AV_PIX_FMT_YUVA444P9BE: AVPixelFormat = 84;
3819#[doc = "< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian"]
3820pub const AVPixelFormat_AV_PIX_FMT_YUVA444P9LE: AVPixelFormat = 85;
3821#[doc = "< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)"]
3822pub const AVPixelFormat_AV_PIX_FMT_YUVA420P10BE: AVPixelFormat = 86;
3823#[doc = "< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)"]
3824pub const AVPixelFormat_AV_PIX_FMT_YUVA420P10LE: AVPixelFormat = 87;
3825#[doc = "< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)"]
3826pub const AVPixelFormat_AV_PIX_FMT_YUVA422P10BE: AVPixelFormat = 88;
3827#[doc = "< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)"]
3828pub const AVPixelFormat_AV_PIX_FMT_YUVA422P10LE: AVPixelFormat = 89;
3829#[doc = "< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)"]
3830pub const AVPixelFormat_AV_PIX_FMT_YUVA444P10BE: AVPixelFormat = 90;
3831#[doc = "< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)"]
3832pub const AVPixelFormat_AV_PIX_FMT_YUVA444P10LE: AVPixelFormat = 91;
3833#[doc = "< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)"]
3834pub const AVPixelFormat_AV_PIX_FMT_YUVA420P16BE: AVPixelFormat = 92;
3835#[doc = "< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)"]
3836pub const AVPixelFormat_AV_PIX_FMT_YUVA420P16LE: AVPixelFormat = 93;
3837#[doc = "< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)"]
3838pub const AVPixelFormat_AV_PIX_FMT_YUVA422P16BE: AVPixelFormat = 94;
3839#[doc = "< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)"]
3840pub const AVPixelFormat_AV_PIX_FMT_YUVA422P16LE: AVPixelFormat = 95;
3841#[doc = "< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)"]
3842pub const AVPixelFormat_AV_PIX_FMT_YUVA444P16BE: AVPixelFormat = 96;
3843#[doc = "< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)"]
3844pub const AVPixelFormat_AV_PIX_FMT_YUVA444P16LE: AVPixelFormat = 97;
3845#[doc = "< HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface"]
3846pub const AVPixelFormat_AV_PIX_FMT_VDPAU: AVPixelFormat = 98;
3847#[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"]
3848pub const AVPixelFormat_AV_PIX_FMT_XYZ12LE: AVPixelFormat = 99;
3849#[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"]
3850pub const AVPixelFormat_AV_PIX_FMT_XYZ12BE: AVPixelFormat = 100;
3851#[doc = "< interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)"]
3852pub const AVPixelFormat_AV_PIX_FMT_NV16: AVPixelFormat = 101;
3853#[doc = "< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3854pub const AVPixelFormat_AV_PIX_FMT_NV20LE: AVPixelFormat = 102;
3855#[doc = "< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3856pub const AVPixelFormat_AV_PIX_FMT_NV20BE: AVPixelFormat = 103;
3857#[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"]
3858pub const AVPixelFormat_AV_PIX_FMT_RGBA64BE: AVPixelFormat = 104;
3859#[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"]
3860pub const AVPixelFormat_AV_PIX_FMT_RGBA64LE: AVPixelFormat = 105;
3861#[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"]
3862pub const AVPixelFormat_AV_PIX_FMT_BGRA64BE: AVPixelFormat = 106;
3863#[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"]
3864pub const AVPixelFormat_AV_PIX_FMT_BGRA64LE: AVPixelFormat = 107;
3865#[doc = "< packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb"]
3866pub const AVPixelFormat_AV_PIX_FMT_YVYU422: AVPixelFormat = 108;
3867#[doc = "< 16 bits gray, 16 bits alpha (big-endian)"]
3868pub const AVPixelFormat_AV_PIX_FMT_YA16BE: AVPixelFormat = 109;
3869#[doc = "< 16 bits gray, 16 bits alpha (little-endian)"]
3870pub const AVPixelFormat_AV_PIX_FMT_YA16LE: AVPixelFormat = 110;
3871#[doc = "< planar GBRA 4:4:4:4 32bpp"]
3872pub const AVPixelFormat_AV_PIX_FMT_GBRAP: AVPixelFormat = 111;
3873#[doc = "< planar GBRA 4:4:4:4 64bpp, big-endian"]
3874pub const AVPixelFormat_AV_PIX_FMT_GBRAP16BE: AVPixelFormat = 112;
3875#[doc = "< planar GBRA 4:4:4:4 64bpp, little-endian"]
3876pub const AVPixelFormat_AV_PIX_FMT_GBRAP16LE: AVPixelFormat = 113;
3877#[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."]
3878pub const AVPixelFormat_AV_PIX_FMT_QSV: AVPixelFormat = 114;
3879#[doc = " HW acceleration though MMAL, data[3] contains a pointer to the\n MMAL_BUFFER_HEADER_T structure."]
3880pub const AVPixelFormat_AV_PIX_FMT_MMAL: AVPixelFormat = 115;
3881#[doc = "< HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView pointer"]
3882pub const AVPixelFormat_AV_PIX_FMT_D3D11VA_VLD: AVPixelFormat = 116;
3883#[doc = " HW acceleration through CUDA. data[i] contain CUdeviceptr pointers\n exactly as for system memory frames."]
3884pub const AVPixelFormat_AV_PIX_FMT_CUDA: AVPixelFormat = 117;
3885#[doc = "< packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined"]
3886pub const AVPixelFormat_AV_PIX_FMT_0RGB: AVPixelFormat = 118;
3887#[doc = "< packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined"]
3888pub const AVPixelFormat_AV_PIX_FMT_RGB0: AVPixelFormat = 119;
3889#[doc = "< packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined"]
3890pub const AVPixelFormat_AV_PIX_FMT_0BGR: AVPixelFormat = 120;
3891#[doc = "< packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined"]
3892pub const AVPixelFormat_AV_PIX_FMT_BGR0: AVPixelFormat = 121;
3893#[doc = "< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian"]
3894pub const AVPixelFormat_AV_PIX_FMT_YUV420P12BE: AVPixelFormat = 122;
3895#[doc = "< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian"]
3896pub const AVPixelFormat_AV_PIX_FMT_YUV420P12LE: AVPixelFormat = 123;
3897#[doc = "< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian"]
3898pub const AVPixelFormat_AV_PIX_FMT_YUV420P14BE: AVPixelFormat = 124;
3899#[doc = "< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian"]
3900pub const AVPixelFormat_AV_PIX_FMT_YUV420P14LE: AVPixelFormat = 125;
3901#[doc = "< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3902pub const AVPixelFormat_AV_PIX_FMT_YUV422P12BE: AVPixelFormat = 126;
3903#[doc = "< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3904pub const AVPixelFormat_AV_PIX_FMT_YUV422P12LE: AVPixelFormat = 127;
3905#[doc = "< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian"]
3906pub const AVPixelFormat_AV_PIX_FMT_YUV422P14BE: AVPixelFormat = 128;
3907#[doc = "< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian"]
3908pub const AVPixelFormat_AV_PIX_FMT_YUV422P14LE: AVPixelFormat = 129;
3909#[doc = "< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian"]
3910pub const AVPixelFormat_AV_PIX_FMT_YUV444P12BE: AVPixelFormat = 130;
3911#[doc = "< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian"]
3912pub const AVPixelFormat_AV_PIX_FMT_YUV444P12LE: AVPixelFormat = 131;
3913#[doc = "< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian"]
3914pub const AVPixelFormat_AV_PIX_FMT_YUV444P14BE: AVPixelFormat = 132;
3915#[doc = "< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian"]
3916pub const AVPixelFormat_AV_PIX_FMT_YUV444P14LE: AVPixelFormat = 133;
3917#[doc = "< planar GBR 4:4:4 36bpp, big-endian"]
3918pub const AVPixelFormat_AV_PIX_FMT_GBRP12BE: AVPixelFormat = 134;
3919#[doc = "< planar GBR 4:4:4 36bpp, little-endian"]
3920pub const AVPixelFormat_AV_PIX_FMT_GBRP12LE: AVPixelFormat = 135;
3921#[doc = "< planar GBR 4:4:4 42bpp, big-endian"]
3922pub const AVPixelFormat_AV_PIX_FMT_GBRP14BE: AVPixelFormat = 136;
3923#[doc = "< planar GBR 4:4:4 42bpp, little-endian"]
3924pub const AVPixelFormat_AV_PIX_FMT_GBRP14LE: AVPixelFormat = 137;
3925#[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"]
3926pub const AVPixelFormat_AV_PIX_FMT_YUVJ411P: AVPixelFormat = 138;
3927#[doc = "< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples"]
3928pub const AVPixelFormat_AV_PIX_FMT_BAYER_BGGR8: AVPixelFormat = 139;
3929#[doc = "< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples"]
3930pub const AVPixelFormat_AV_PIX_FMT_BAYER_RGGB8: AVPixelFormat = 140;
3931#[doc = "< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples"]
3932pub const AVPixelFormat_AV_PIX_FMT_BAYER_GBRG8: AVPixelFormat = 141;
3933#[doc = "< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples"]
3934pub const AVPixelFormat_AV_PIX_FMT_BAYER_GRBG8: AVPixelFormat = 142;
3935#[doc = "< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian"]
3936pub const AVPixelFormat_AV_PIX_FMT_BAYER_BGGR16LE: AVPixelFormat = 143;
3937#[doc = "< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian"]
3938pub const AVPixelFormat_AV_PIX_FMT_BAYER_BGGR16BE: AVPixelFormat = 144;
3939#[doc = "< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian"]
3940pub const AVPixelFormat_AV_PIX_FMT_BAYER_RGGB16LE: AVPixelFormat = 145;
3941#[doc = "< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian"]
3942pub const AVPixelFormat_AV_PIX_FMT_BAYER_RGGB16BE: AVPixelFormat = 146;
3943#[doc = "< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian"]
3944pub const AVPixelFormat_AV_PIX_FMT_BAYER_GBRG16LE: AVPixelFormat = 147;
3945#[doc = "< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian"]
3946pub const AVPixelFormat_AV_PIX_FMT_BAYER_GBRG16BE: AVPixelFormat = 148;
3947#[doc = "< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian"]
3948pub const AVPixelFormat_AV_PIX_FMT_BAYER_GRBG16LE: AVPixelFormat = 149;
3949#[doc = "< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian"]
3950pub const AVPixelFormat_AV_PIX_FMT_BAYER_GRBG16BE: AVPixelFormat = 150;
3951#[doc = "< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian"]
3952pub const AVPixelFormat_AV_PIX_FMT_YUV440P10LE: AVPixelFormat = 151;
3953#[doc = "< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian"]
3954pub const AVPixelFormat_AV_PIX_FMT_YUV440P10BE: AVPixelFormat = 152;
3955#[doc = "< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian"]
3956pub const AVPixelFormat_AV_PIX_FMT_YUV440P12LE: AVPixelFormat = 153;
3957#[doc = "< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian"]
3958pub const AVPixelFormat_AV_PIX_FMT_YUV440P12BE: AVPixelFormat = 154;
3959#[doc = "< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian"]
3960pub const AVPixelFormat_AV_PIX_FMT_AYUV64LE: AVPixelFormat = 155;
3961#[doc = "< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), big-endian"]
3962pub const AVPixelFormat_AV_PIX_FMT_AYUV64BE: AVPixelFormat = 156;
3963#[doc = "< hardware decoding through Videotoolbox"]
3964pub const AVPixelFormat_AV_PIX_FMT_VIDEOTOOLBOX: AVPixelFormat = 157;
3965#[doc = "< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, little-endian"]
3966pub const AVPixelFormat_AV_PIX_FMT_P010LE: AVPixelFormat = 158;
3967#[doc = "< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, big-endian"]
3968pub const AVPixelFormat_AV_PIX_FMT_P010BE: AVPixelFormat = 159;
3969#[doc = "< planar GBR 4:4:4:4 48bpp, big-endian"]
3970pub const AVPixelFormat_AV_PIX_FMT_GBRAP12BE: AVPixelFormat = 160;
3971#[doc = "< planar GBR 4:4:4:4 48bpp, little-endian"]
3972pub const AVPixelFormat_AV_PIX_FMT_GBRAP12LE: AVPixelFormat = 161;
3973#[doc = "< planar GBR 4:4:4:4 40bpp, big-endian"]
3974pub const AVPixelFormat_AV_PIX_FMT_GBRAP10BE: AVPixelFormat = 162;
3975#[doc = "< planar GBR 4:4:4:4 40bpp, little-endian"]
3976pub const AVPixelFormat_AV_PIX_FMT_GBRAP10LE: AVPixelFormat = 163;
3977#[doc = "< hardware decoding through MediaCodec"]
3978pub const AVPixelFormat_AV_PIX_FMT_MEDIACODEC: AVPixelFormat = 164;
3979#[doc = "< Y , 12bpp, big-endian"]
3980pub const AVPixelFormat_AV_PIX_FMT_GRAY12BE: AVPixelFormat = 165;
3981#[doc = "< Y , 12bpp, little-endian"]
3982pub const AVPixelFormat_AV_PIX_FMT_GRAY12LE: AVPixelFormat = 166;
3983#[doc = "< Y , 10bpp, big-endian"]
3984pub const AVPixelFormat_AV_PIX_FMT_GRAY10BE: AVPixelFormat = 167;
3985#[doc = "< Y , 10bpp, little-endian"]
3986pub const AVPixelFormat_AV_PIX_FMT_GRAY10LE: AVPixelFormat = 168;
3987#[doc = "< like NV12, with 16bpp per component, little-endian"]
3988pub const AVPixelFormat_AV_PIX_FMT_P016LE: AVPixelFormat = 169;
3989#[doc = "< like NV12, with 16bpp per component, big-endian"]
3990pub const AVPixelFormat_AV_PIX_FMT_P016BE: AVPixelFormat = 170;
3991#[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)."]
3992pub const AVPixelFormat_AV_PIX_FMT_D3D11: AVPixelFormat = 171;
3993#[doc = "< Y , 9bpp, big-endian"]
3994pub const AVPixelFormat_AV_PIX_FMT_GRAY9BE: AVPixelFormat = 172;
3995#[doc = "< Y , 9bpp, little-endian"]
3996pub const AVPixelFormat_AV_PIX_FMT_GRAY9LE: AVPixelFormat = 173;
3997#[doc = "< IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian"]
3998pub const AVPixelFormat_AV_PIX_FMT_GBRPF32BE: AVPixelFormat = 174;
3999#[doc = "< IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian"]
4000pub const AVPixelFormat_AV_PIX_FMT_GBRPF32LE: AVPixelFormat = 175;
4001#[doc = "< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian"]
4002pub const AVPixelFormat_AV_PIX_FMT_GBRAPF32BE: AVPixelFormat = 176;
4003#[doc = "< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian"]
4004pub const AVPixelFormat_AV_PIX_FMT_GBRAPF32LE: AVPixelFormat = 177;
4005#[doc = " DRM-managed buffers exposed through PRIME buffer sharing.\n\n data[0] points to an AVDRMFrameDescriptor."]
4006pub const AVPixelFormat_AV_PIX_FMT_DRM_PRIME: AVPixelFormat = 178;
4007#[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."]
4008pub const AVPixelFormat_AV_PIX_FMT_OPENCL: AVPixelFormat = 179;
4009#[doc = "< Y , 14bpp, big-endian"]
4010pub const AVPixelFormat_AV_PIX_FMT_GRAY14BE: AVPixelFormat = 180;
4011#[doc = "< Y , 14bpp, little-endian"]
4012pub const AVPixelFormat_AV_PIX_FMT_GRAY14LE: AVPixelFormat = 181;
4013#[doc = "< IEEE-754 single precision Y, 32bpp, big-endian"]
4014pub const AVPixelFormat_AV_PIX_FMT_GRAYF32BE: AVPixelFormat = 182;
4015#[doc = "< IEEE-754 single precision Y, 32bpp, little-endian"]
4016pub const AVPixelFormat_AV_PIX_FMT_GRAYF32LE: AVPixelFormat = 183;
4017#[doc = "< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian"]
4018pub const AVPixelFormat_AV_PIX_FMT_YUVA422P12BE: AVPixelFormat = 184;
4019#[doc = "< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian"]
4020pub const AVPixelFormat_AV_PIX_FMT_YUVA422P12LE: AVPixelFormat = 185;
4021#[doc = "< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian"]
4022pub const AVPixelFormat_AV_PIX_FMT_YUVA444P12BE: AVPixelFormat = 186;
4023#[doc = "< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian"]
4024pub const AVPixelFormat_AV_PIX_FMT_YUVA444P12LE: AVPixelFormat = 187;
4025#[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)"]
4026pub const AVPixelFormat_AV_PIX_FMT_NV24: AVPixelFormat = 188;
4027#[doc = "< as above, but U and V bytes are swapped"]
4028pub const AVPixelFormat_AV_PIX_FMT_NV42: AVPixelFormat = 189;
4029#[doc = " Vulkan hardware images.\n\n data[0] points to an AVVkFrame"]
4030pub const AVPixelFormat_AV_PIX_FMT_VULKAN: AVPixelFormat = 190;
4031#[doc = "< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, big-endian"]
4032pub const AVPixelFormat_AV_PIX_FMT_Y210BE: AVPixelFormat = 191;
4033#[doc = "< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian"]
4034pub const AVPixelFormat_AV_PIX_FMT_Y210LE: AVPixelFormat = 192;
4035#[doc = "< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined"]
4036pub const AVPixelFormat_AV_PIX_FMT_X2RGB10LE: AVPixelFormat = 193;
4037#[doc = "< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), big-endian, X=unused/undefined"]
4038pub const AVPixelFormat_AV_PIX_FMT_X2RGB10BE: AVPixelFormat = 194;
4039#[doc = "< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined"]
4040pub const AVPixelFormat_AV_PIX_FMT_X2BGR10LE: AVPixelFormat = 195;
4041#[doc = "< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), big-endian, X=unused/undefined"]
4042pub const AVPixelFormat_AV_PIX_FMT_X2BGR10BE: AVPixelFormat = 196;
4043#[doc = "< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, big-endian"]
4044pub const AVPixelFormat_AV_PIX_FMT_P210BE: AVPixelFormat = 197;
4045#[doc = "< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, little-endian"]
4046pub const AVPixelFormat_AV_PIX_FMT_P210LE: AVPixelFormat = 198;
4047#[doc = "< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, big-endian"]
4048pub const AVPixelFormat_AV_PIX_FMT_P410BE: AVPixelFormat = 199;
4049#[doc = "< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, little-endian"]
4050pub const AVPixelFormat_AV_PIX_FMT_P410LE: AVPixelFormat = 200;
4051#[doc = "< interleaved chroma YUV 4:2:2, 32bpp, big-endian"]
4052pub const AVPixelFormat_AV_PIX_FMT_P216BE: AVPixelFormat = 201;
4053#[doc = "< interleaved chroma YUV 4:2:2, 32bpp, little-endian"]
4054pub const AVPixelFormat_AV_PIX_FMT_P216LE: AVPixelFormat = 202;
4055#[doc = "< interleaved chroma YUV 4:4:4, 48bpp, big-endian"]
4056pub const AVPixelFormat_AV_PIX_FMT_P416BE: AVPixelFormat = 203;
4057#[doc = "< interleaved chroma YUV 4:4:4, 48bpp, little-endian"]
4058pub const AVPixelFormat_AV_PIX_FMT_P416LE: AVPixelFormat = 204;
4059#[doc = "< packed VUYA 4:4:4, 32bpp, VUYAVUYA..."]
4060pub const AVPixelFormat_AV_PIX_FMT_VUYA: AVPixelFormat = 205;
4061#[doc = "< IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., big-endian"]
4062pub const AVPixelFormat_AV_PIX_FMT_RGBAF16BE: AVPixelFormat = 206;
4063#[doc = "< IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., little-endian"]
4064pub const AVPixelFormat_AV_PIX_FMT_RGBAF16LE: AVPixelFormat = 207;
4065#[doc = "< packed VUYX 4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined"]
4066pub const AVPixelFormat_AV_PIX_FMT_VUYX: AVPixelFormat = 208;
4067#[doc = "< like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, little-endian"]
4068pub const AVPixelFormat_AV_PIX_FMT_P012LE: AVPixelFormat = 209;
4069#[doc = "< like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, big-endian"]
4070pub const AVPixelFormat_AV_PIX_FMT_P012BE: AVPixelFormat = 210;
4071#[doc = "< packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, big-endian"]
4072pub const AVPixelFormat_AV_PIX_FMT_Y212BE: AVPixelFormat = 211;
4073#[doc = "< packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, little-endian"]
4074pub const AVPixelFormat_AV_PIX_FMT_Y212LE: AVPixelFormat = 212;
4075#[doc = "< packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), big-endian, variant of Y410 where alpha channel is left undefined"]
4076pub const AVPixelFormat_AV_PIX_FMT_XV30BE: AVPixelFormat = 213;
4077#[doc = "< packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), little-endian, variant of Y410 where alpha channel is left undefined"]
4078pub const AVPixelFormat_AV_PIX_FMT_XV30LE: AVPixelFormat = 214;
4079#[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"]
4080pub const AVPixelFormat_AV_PIX_FMT_XV36BE: AVPixelFormat = 215;
4081#[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"]
4082pub const AVPixelFormat_AV_PIX_FMT_XV36LE: AVPixelFormat = 216;
4083#[doc = "< IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., big-endian"]
4084pub const AVPixelFormat_AV_PIX_FMT_RGBF32BE: AVPixelFormat = 217;
4085#[doc = "< IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., little-endian"]
4086pub const AVPixelFormat_AV_PIX_FMT_RGBF32LE: AVPixelFormat = 218;
4087#[doc = "< IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., big-endian"]
4088pub const AVPixelFormat_AV_PIX_FMT_RGBAF32BE: AVPixelFormat = 219;
4089#[doc = "< IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., little-endian"]
4090pub const AVPixelFormat_AV_PIX_FMT_RGBAF32LE: AVPixelFormat = 220;
4091#[doc = "< interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, big-endian"]
4092pub const AVPixelFormat_AV_PIX_FMT_P212BE: AVPixelFormat = 221;
4093#[doc = "< interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, little-endian"]
4094pub const AVPixelFormat_AV_PIX_FMT_P212LE: AVPixelFormat = 222;
4095#[doc = "< interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, big-endian"]
4096pub const AVPixelFormat_AV_PIX_FMT_P412BE: AVPixelFormat = 223;
4097#[doc = "< interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, little-endian"]
4098pub const AVPixelFormat_AV_PIX_FMT_P412LE: AVPixelFormat = 224;
4099#[doc = "< planar GBR 4:4:4:4 56bpp, big-endian"]
4100pub const AVPixelFormat_AV_PIX_FMT_GBRAP14BE: AVPixelFormat = 225;
4101#[doc = "< planar GBR 4:4:4:4 56bpp, little-endian"]
4102pub const AVPixelFormat_AV_PIX_FMT_GBRAP14LE: AVPixelFormat = 226;
4103#[doc = " Hardware surfaces for Direct3D 12.\n\n data[0] points to an AVD3D12VAFrame"]
4104pub const AVPixelFormat_AV_PIX_FMT_D3D12: AVPixelFormat = 227;
4105#[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"]
4106pub const AVPixelFormat_AV_PIX_FMT_NB: AVPixelFormat = 228;
4107#[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."]
4108pub type AVPixelFormat = ::std::os::raw::c_int;
4109pub const AVColorPrimaries_AVCOL_PRI_RESERVED0: AVColorPrimaries = 0;
4110#[doc = "< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B"]
4111pub const AVColorPrimaries_AVCOL_PRI_BT709: AVColorPrimaries = 1;
4112pub const AVColorPrimaries_AVCOL_PRI_UNSPECIFIED: AVColorPrimaries = 2;
4113pub const AVColorPrimaries_AVCOL_PRI_RESERVED: AVColorPrimaries = 3;
4114#[doc = "< also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)"]
4115pub const AVColorPrimaries_AVCOL_PRI_BT470M: AVColorPrimaries = 4;
4116#[doc = "< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM"]
4117pub const AVColorPrimaries_AVCOL_PRI_BT470BG: AVColorPrimaries = 5;
4118#[doc = "< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC"]
4119pub const AVColorPrimaries_AVCOL_PRI_SMPTE170M: AVColorPrimaries = 6;
4120#[doc = "< identical to above, also called \"SMPTE C\" even though it uses D65"]
4121pub const AVColorPrimaries_AVCOL_PRI_SMPTE240M: AVColorPrimaries = 7;
4122#[doc = "< colour filters using Illuminant C"]
4123pub const AVColorPrimaries_AVCOL_PRI_FILM: AVColorPrimaries = 8;
4124#[doc = "< ITU-R BT2020"]
4125pub const AVColorPrimaries_AVCOL_PRI_BT2020: AVColorPrimaries = 9;
4126#[doc = "< SMPTE ST 428-1 (CIE 1931 XYZ)"]
4127pub const AVColorPrimaries_AVCOL_PRI_SMPTE428: AVColorPrimaries = 10;
4128pub const AVColorPrimaries_AVCOL_PRI_SMPTEST428_1: AVColorPrimaries = 10;
4129#[doc = "< SMPTE ST 431-2 (2011) / DCI P3"]
4130pub const AVColorPrimaries_AVCOL_PRI_SMPTE431: AVColorPrimaries = 11;
4131#[doc = "< SMPTE ST 432-1 (2010) / P3 D65 / Display P3"]
4132pub const AVColorPrimaries_AVCOL_PRI_SMPTE432: AVColorPrimaries = 12;
4133#[doc = "< EBU Tech. 3213-E (nothing there) / one of JEDEC P22 group phosphors"]
4134pub const AVColorPrimaries_AVCOL_PRI_EBU3213: AVColorPrimaries = 22;
4135pub const AVColorPrimaries_AVCOL_PRI_JEDEC_P22: AVColorPrimaries = 22;
4136#[doc = "< Not part of ABI"]
4137pub const AVColorPrimaries_AVCOL_PRI_NB: AVColorPrimaries = 23;
4138#[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."]
4139pub type AVColorPrimaries = ::std::os::raw::c_uint;
4140pub const AVColorTransferCharacteristic_AVCOL_TRC_RESERVED0: AVColorTransferCharacteristic = 0;
4141#[doc = "< also ITU-R BT1361"]
4142pub const AVColorTransferCharacteristic_AVCOL_TRC_BT709: AVColorTransferCharacteristic = 1;
4143pub const AVColorTransferCharacteristic_AVCOL_TRC_UNSPECIFIED: AVColorTransferCharacteristic = 2;
4144pub const AVColorTransferCharacteristic_AVCOL_TRC_RESERVED: AVColorTransferCharacteristic = 3;
4145#[doc = "< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM"]
4146pub const AVColorTransferCharacteristic_AVCOL_TRC_GAMMA22: AVColorTransferCharacteristic = 4;
4147#[doc = "< also ITU-R BT470BG"]
4148pub const AVColorTransferCharacteristic_AVCOL_TRC_GAMMA28: AVColorTransferCharacteristic = 5;
4149#[doc = "< also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC"]
4150pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTE170M: AVColorTransferCharacteristic = 6;
4151pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTE240M: AVColorTransferCharacteristic = 7;
4152#[doc = "< \"Linear transfer characteristics\""]
4153pub const AVColorTransferCharacteristic_AVCOL_TRC_LINEAR: AVColorTransferCharacteristic = 8;
4154#[doc = "< \"Logarithmic transfer characteristic (100:1 range)\""]
4155pub const AVColorTransferCharacteristic_AVCOL_TRC_LOG: AVColorTransferCharacteristic = 9;
4156#[doc = "< \"Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)\""]
4157pub const AVColorTransferCharacteristic_AVCOL_TRC_LOG_SQRT: AVColorTransferCharacteristic = 10;
4158#[doc = "< IEC 61966-2-4"]
4159pub const AVColorTransferCharacteristic_AVCOL_TRC_IEC61966_2_4: AVColorTransferCharacteristic = 11;
4160#[doc = "< ITU-R BT1361 Extended Colour Gamut"]
4161pub const AVColorTransferCharacteristic_AVCOL_TRC_BT1361_ECG: AVColorTransferCharacteristic = 12;
4162#[doc = "< IEC 61966-2-1 (sRGB or sYCC)"]
4163pub const AVColorTransferCharacteristic_AVCOL_TRC_IEC61966_2_1: AVColorTransferCharacteristic = 13;
4164#[doc = "< ITU-R BT2020 for 10-bit system"]
4165pub const AVColorTransferCharacteristic_AVCOL_TRC_BT2020_10: AVColorTransferCharacteristic = 14;
4166#[doc = "< ITU-R BT2020 for 12-bit system"]
4167pub const AVColorTransferCharacteristic_AVCOL_TRC_BT2020_12: AVColorTransferCharacteristic = 15;
4168#[doc = "< SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems"]
4169pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTE2084: AVColorTransferCharacteristic = 16;
4170pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTEST2084: AVColorTransferCharacteristic = 16;
4171#[doc = "< SMPTE ST 428-1"]
4172pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTE428: AVColorTransferCharacteristic = 17;
4173pub const AVColorTransferCharacteristic_AVCOL_TRC_SMPTEST428_1: AVColorTransferCharacteristic = 17;
4174#[doc = "< ARIB STD-B67, known as \"Hybrid log-gamma\""]
4175pub const AVColorTransferCharacteristic_AVCOL_TRC_ARIB_STD_B67: AVColorTransferCharacteristic = 18;
4176#[doc = "< Not part of ABI"]
4177pub const AVColorTransferCharacteristic_AVCOL_TRC_NB: AVColorTransferCharacteristic = 19;
4178#[doc = " Color Transfer Characteristic.\n These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.2."]
4179pub type AVColorTransferCharacteristic = ::std::os::raw::c_uint;
4180#[doc = "< order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1"]
4181pub const AVColorSpace_AVCOL_SPC_RGB: AVColorSpace = 0;
4182#[doc = "< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B"]
4183pub const AVColorSpace_AVCOL_SPC_BT709: AVColorSpace = 1;
4184pub const AVColorSpace_AVCOL_SPC_UNSPECIFIED: AVColorSpace = 2;
4185#[doc = "< reserved for future use by ITU-T and ISO/IEC just like 15-255 are"]
4186pub const AVColorSpace_AVCOL_SPC_RESERVED: AVColorSpace = 3;
4187#[doc = "< FCC Title 47 Code of Federal Regulations 73.682 (a)(20)"]
4188pub const AVColorSpace_AVCOL_SPC_FCC: AVColorSpace = 4;
4189#[doc = "< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601"]
4190pub const AVColorSpace_AVCOL_SPC_BT470BG: AVColorSpace = 5;
4191#[doc = "< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above"]
4192pub const AVColorSpace_AVCOL_SPC_SMPTE170M: AVColorSpace = 6;
4193#[doc = "< derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries"]
4194pub const AVColorSpace_AVCOL_SPC_SMPTE240M: AVColorSpace = 7;
4195#[doc = "< used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16"]
4196pub const AVColorSpace_AVCOL_SPC_YCGCO: AVColorSpace = 8;
4197pub const AVColorSpace_AVCOL_SPC_YCOCG: AVColorSpace = 8;
4198#[doc = "< ITU-R BT2020 non-constant luminance system"]
4199pub const AVColorSpace_AVCOL_SPC_BT2020_NCL: AVColorSpace = 9;
4200#[doc = "< ITU-R BT2020 constant luminance system"]
4201pub const AVColorSpace_AVCOL_SPC_BT2020_CL: AVColorSpace = 10;
4202#[doc = "< SMPTE 2085, Y'D'zD'x"]
4203pub const AVColorSpace_AVCOL_SPC_SMPTE2085: AVColorSpace = 11;
4204#[doc = "< Chromaticity-derived non-constant luminance system"]
4205pub const AVColorSpace_AVCOL_SPC_CHROMA_DERIVED_NCL: AVColorSpace = 12;
4206#[doc = "< Chromaticity-derived constant luminance system"]
4207pub const AVColorSpace_AVCOL_SPC_CHROMA_DERIVED_CL: AVColorSpace = 13;
4208#[doc = "< ITU-R BT.2100-0, ICtCp"]
4209pub const AVColorSpace_AVCOL_SPC_ICTCP: AVColorSpace = 14;
4210#[doc = "< SMPTE ST 2128, IPT-C2"]
4211pub const AVColorSpace_AVCOL_SPC_IPT_C2: AVColorSpace = 15;
4212#[doc = "< YCgCo-R, even addition of bits"]
4213pub const AVColorSpace_AVCOL_SPC_YCGCO_RE: AVColorSpace = 16;
4214#[doc = "< YCgCo-R, odd addition of bits"]
4215pub const AVColorSpace_AVCOL_SPC_YCGCO_RO: AVColorSpace = 17;
4216#[doc = "< Not part of ABI"]
4217pub const AVColorSpace_AVCOL_SPC_NB: AVColorSpace = 18;
4218#[doc = " YUV colorspace type.\n These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.3."]
4219pub type AVColorSpace = ::std::os::raw::c_uint;
4220pub const AVColorRange_AVCOL_RANGE_UNSPECIFIED: AVColorRange = 0;
4221#[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"]
4222pub const AVColorRange_AVCOL_RANGE_MPEG: AVColorRange = 1;
4223#[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"]
4224pub const AVColorRange_AVCOL_RANGE_JPEG: AVColorRange = 2;
4225#[doc = "< Not part of ABI"]
4226pub const AVColorRange_AVCOL_RANGE_NB: AVColorRange = 3;
4227#[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)."]
4228pub type AVColorRange = ::std::os::raw::c_uint;
4229pub const AVChromaLocation_AVCHROMA_LOC_UNSPECIFIED: AVChromaLocation = 0;
4230#[doc = "< MPEG-2/4 4:2:0, H.264 default for 4:2:0"]
4231pub const AVChromaLocation_AVCHROMA_LOC_LEFT: AVChromaLocation = 1;
4232#[doc = "< MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0"]
4233pub const AVChromaLocation_AVCHROMA_LOC_CENTER: AVChromaLocation = 2;
4234#[doc = "< ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2"]
4235pub const AVChromaLocation_AVCHROMA_LOC_TOPLEFT: AVChromaLocation = 3;
4236pub const AVChromaLocation_AVCHROMA_LOC_TOP: AVChromaLocation = 4;
4237pub const AVChromaLocation_AVCHROMA_LOC_BOTTOMLEFT: AVChromaLocation = 5;
4238pub const AVChromaLocation_AVCHROMA_LOC_BOTTOM: AVChromaLocation = 6;
4239#[doc = "< Not part of ABI"]
4240pub const AVChromaLocation_AVCHROMA_LOC_NB: AVChromaLocation = 7;
4241#[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"]
4242pub type AVChromaLocation = ::std::os::raw::c_uint;
4243extern "C" {
4244 #[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"]
4245 pub fn av_int_list_length_for_size(
4246 elsize: ::std::os::raw::c_uint,
4247 list: *const ::std::os::raw::c_void,
4248 term: u64,
4249 ) -> ::std::os::raw::c_uint;
4250}
4251extern "C" {
4252 #[doc = " Return the fractional representation of the internal time base."]
4253 pub fn av_get_time_base_q() -> AVRational;
4254}
4255extern "C" {
4256 #[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"]
4257 pub fn av_fourcc_make_string(
4258 buf: *mut ::std::os::raw::c_char,
4259 fourcc: u32,
4260 ) -> *mut ::std::os::raw::c_char;
4261}
4262#[repr(C)]
4263#[derive(Debug, Copy, Clone)]
4264pub struct AVBuffer {
4265 _unused: [u8; 0],
4266}
4267#[doc = " A reference to a data buffer.\n\n The size of this struct is not a part of the public ABI and it is not meant\n to be allocated directly."]
4268#[repr(C)]
4269#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4270pub struct AVBufferRef {
4271 pub buffer: *mut AVBuffer,
4272 #[doc = " The data buffer. It is considered writable if and only if\n this is the only reference to the buffer, in which case\n av_buffer_is_writable() returns 1."]
4273 pub data: *mut u8,
4274 #[doc = " Size of data in bytes."]
4275 pub size: usize,
4276}
4277impl Default for AVBufferRef {
4278 fn default() -> Self {
4279 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4280 unsafe {
4281 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4282 s.assume_init()
4283 }
4284 }
4285}
4286extern "C" {
4287 #[doc = " Allocate an AVBuffer of the given size using av_malloc().\n\n @return an AVBufferRef of given size or NULL when out of memory"]
4288 pub fn av_buffer_alloc(size: usize) -> *mut AVBufferRef;
4289}
4290extern "C" {
4291 #[doc = " Same as av_buffer_alloc(), except the returned buffer will be initialized\n to zero."]
4292 pub fn av_buffer_allocz(size: usize) -> *mut AVBufferRef;
4293}
4294extern "C" {
4295 #[doc = " Create an AVBuffer from an existing array.\n\n If this function is successful, data is owned by the AVBuffer. The caller may\n only access data through the returned AVBufferRef and references derived from\n it.\n If this function fails, data is left untouched.\n @param data data array\n @param size size of data in bytes\n @param free a callback for freeing this buffer's data\n @param opaque parameter to be got for processing or passed to free\n @param flags a combination of AV_BUFFER_FLAG_*\n\n @return an AVBufferRef referring to data on success, NULL on failure."]
4296 pub fn av_buffer_create(
4297 data: *mut u8,
4298 size: usize,
4299 free: ::std::option::Option<
4300 unsafe extern "C" fn(opaque: *mut ::std::os::raw::c_void, data: *mut u8),
4301 >,
4302 opaque: *mut ::std::os::raw::c_void,
4303 flags: ::std::os::raw::c_int,
4304 ) -> *mut AVBufferRef;
4305}
4306extern "C" {
4307 #[doc = " Default free callback, which calls av_free() on the buffer data.\n This function is meant to be passed to av_buffer_create(), not called\n directly."]
4308 pub fn av_buffer_default_free(opaque: *mut ::std::os::raw::c_void, data: *mut u8);
4309}
4310extern "C" {
4311 #[doc = " Create a new reference to an AVBuffer.\n\n @return a new AVBufferRef referring to the same AVBuffer as buf or NULL on\n failure."]
4312 pub fn av_buffer_ref(buf: *const AVBufferRef) -> *mut AVBufferRef;
4313}
4314extern "C" {
4315 #[doc = " Free a given reference and automatically free the buffer if there are no more\n references to it.\n\n @param buf the reference to be freed. The pointer is set to NULL on return."]
4316 pub fn av_buffer_unref(buf: *mut *mut AVBufferRef);
4317}
4318extern "C" {
4319 #[doc = " @return 1 if the caller may write to the data referred to by buf (which is\n true if and only if buf is the only reference to the underlying AVBuffer).\n Return 0 otherwise.\n A positive answer is valid until av_buffer_ref() is called on buf."]
4320 pub fn av_buffer_is_writable(buf: *const AVBufferRef) -> ::std::os::raw::c_int;
4321}
4322extern "C" {
4323 #[doc = " @return the opaque parameter set by av_buffer_create."]
4324 pub fn av_buffer_get_opaque(buf: *const AVBufferRef) -> *mut ::std::os::raw::c_void;
4325}
4326extern "C" {
4327 pub fn av_buffer_get_ref_count(buf: *const AVBufferRef) -> ::std::os::raw::c_int;
4328}
4329extern "C" {
4330 #[doc = " Create a writable reference from a given buffer reference, avoiding data copy\n if possible.\n\n @param buf buffer reference to make writable. On success, buf is either left\n untouched, or it is unreferenced and a new writable AVBufferRef is\n written in its place. On failure, buf is left untouched.\n @return 0 on success, a negative AVERROR on failure."]
4331 pub fn av_buffer_make_writable(buf: *mut *mut AVBufferRef) -> ::std::os::raw::c_int;
4332}
4333extern "C" {
4334 #[doc = " Reallocate a given buffer.\n\n @param buf a buffer reference to reallocate. On success, buf will be\n unreferenced and a new reference with the required size will be\n written in its place. On failure buf will be left untouched. *buf\n may be NULL, then a new buffer is allocated.\n @param size required new buffer size.\n @return 0 on success, a negative AVERROR on failure.\n\n @note the buffer is actually reallocated with av_realloc() only if it was\n initially allocated through av_buffer_realloc(NULL) and there is only one\n reference to it (i.e. the one passed to this function). In all other cases\n a new buffer is allocated and the data is copied."]
4335 pub fn av_buffer_realloc(buf: *mut *mut AVBufferRef, size: usize) -> ::std::os::raw::c_int;
4336}
4337extern "C" {
4338 #[doc = " Ensure dst refers to the same data as src.\n\n When *dst is already equivalent to src, do nothing. Otherwise unreference dst\n and replace it with a new reference to src.\n\n @param dst Pointer to either a valid buffer reference or NULL. On success,\n this will point to a buffer reference equivalent to src. On\n failure, dst will be left untouched.\n @param src A buffer reference to replace dst with. May be NULL, then this\n function is equivalent to av_buffer_unref(dst).\n @return 0 on success\n AVERROR(ENOMEM) on memory allocation failure."]
4339 pub fn av_buffer_replace(
4340 dst: *mut *mut AVBufferRef,
4341 src: *const AVBufferRef,
4342 ) -> ::std::os::raw::c_int;
4343}
4344#[repr(C)]
4345#[derive(Debug, Copy, Clone)]
4346pub struct AVBufferPool {
4347 _unused: [u8; 0],
4348}
4349extern "C" {
4350 #[doc = " Allocate and initialize a buffer pool.\n\n @param size size of each buffer in this pool\n @param alloc a function that will be used to allocate new buffers when the\n pool is empty. May be NULL, then the default allocator will be used\n (av_buffer_alloc()).\n @return newly created buffer pool on success, NULL on error."]
4351 pub fn av_buffer_pool_init(
4352 size: usize,
4353 alloc: ::std::option::Option<unsafe extern "C" fn(size: usize) -> *mut AVBufferRef>,
4354 ) -> *mut AVBufferPool;
4355}
4356extern "C" {
4357 #[doc = " Allocate and initialize a buffer pool with a more complex allocator.\n\n @param size size of each buffer in this pool\n @param opaque arbitrary user data used by the allocator\n @param alloc a function that will be used to allocate new buffers when the\n pool is empty. May be NULL, then the default allocator will be\n used (av_buffer_alloc()).\n @param pool_free a function that will be called immediately before the pool\n is freed. I.e. after av_buffer_pool_uninit() is called\n by the caller and all the frames are returned to the pool\n and freed. It is intended to uninitialize the user opaque\n data. May be NULL.\n @return newly created buffer pool on success, NULL on error."]
4358 pub fn av_buffer_pool_init2(
4359 size: usize,
4360 opaque: *mut ::std::os::raw::c_void,
4361 alloc: ::std::option::Option<
4362 unsafe extern "C" fn(
4363 opaque: *mut ::std::os::raw::c_void,
4364 size: usize,
4365 ) -> *mut AVBufferRef,
4366 >,
4367 pool_free: ::std::option::Option<unsafe extern "C" fn(opaque: *mut ::std::os::raw::c_void)>,
4368 ) -> *mut AVBufferPool;
4369}
4370extern "C" {
4371 #[doc = " Mark the pool as being available for freeing. It will actually be freed only\n once all the allocated buffers associated with the pool are released. Thus it\n is safe to call this function while some of the allocated buffers are still\n in use.\n\n @param pool pointer to the pool to be freed. It will be set to NULL."]
4372 pub fn av_buffer_pool_uninit(pool: *mut *mut AVBufferPool);
4373}
4374extern "C" {
4375 #[doc = " Allocate a new AVBuffer, reusing an old buffer from the pool when available.\n This function may be called simultaneously from multiple threads.\n\n @return a reference to the new buffer on success, NULL on error."]
4376 pub fn av_buffer_pool_get(pool: *mut AVBufferPool) -> *mut AVBufferRef;
4377}
4378extern "C" {
4379 #[doc = " Query the original opaque parameter of an allocated buffer in the pool.\n\n @param ref a buffer reference to a buffer returned by av_buffer_pool_get.\n @return the opaque parameter set by the buffer allocator function of the\n buffer pool.\n\n @note the opaque parameter of ref is used by the buffer pool implementation,\n therefore you have to use this function to access the original opaque\n parameter of an allocated buffer."]
4380 pub fn av_buffer_pool_buffer_get_opaque(
4381 ref_: *const AVBufferRef,
4382 ) -> *mut ::std::os::raw::c_void;
4383}
4384pub const AVChannel_AV_CHAN_NONE: AVChannel = -1;
4385pub const AVChannel_AV_CHAN_FRONT_LEFT: AVChannel = 0;
4386pub const AVChannel_AV_CHAN_FRONT_RIGHT: AVChannel = 1;
4387pub const AVChannel_AV_CHAN_FRONT_CENTER: AVChannel = 2;
4388pub const AVChannel_AV_CHAN_LOW_FREQUENCY: AVChannel = 3;
4389pub const AVChannel_AV_CHAN_BACK_LEFT: AVChannel = 4;
4390pub const AVChannel_AV_CHAN_BACK_RIGHT: AVChannel = 5;
4391pub const AVChannel_AV_CHAN_FRONT_LEFT_OF_CENTER: AVChannel = 6;
4392pub const AVChannel_AV_CHAN_FRONT_RIGHT_OF_CENTER: AVChannel = 7;
4393pub const AVChannel_AV_CHAN_BACK_CENTER: AVChannel = 8;
4394pub const AVChannel_AV_CHAN_SIDE_LEFT: AVChannel = 9;
4395pub const AVChannel_AV_CHAN_SIDE_RIGHT: AVChannel = 10;
4396pub const AVChannel_AV_CHAN_TOP_CENTER: AVChannel = 11;
4397pub const AVChannel_AV_CHAN_TOP_FRONT_LEFT: AVChannel = 12;
4398pub const AVChannel_AV_CHAN_TOP_FRONT_CENTER: AVChannel = 13;
4399pub const AVChannel_AV_CHAN_TOP_FRONT_RIGHT: AVChannel = 14;
4400pub const AVChannel_AV_CHAN_TOP_BACK_LEFT: AVChannel = 15;
4401pub const AVChannel_AV_CHAN_TOP_BACK_CENTER: AVChannel = 16;
4402pub const AVChannel_AV_CHAN_TOP_BACK_RIGHT: AVChannel = 17;
4403#[doc = " Stereo downmix."]
4404pub const AVChannel_AV_CHAN_STEREO_LEFT: AVChannel = 29;
4405#[doc = " See above."]
4406pub const AVChannel_AV_CHAN_STEREO_RIGHT: AVChannel = 30;
4407#[doc = " See above."]
4408pub const AVChannel_AV_CHAN_WIDE_LEFT: AVChannel = 31;
4409#[doc = " See above."]
4410pub const AVChannel_AV_CHAN_WIDE_RIGHT: AVChannel = 32;
4411#[doc = " See above."]
4412pub const AVChannel_AV_CHAN_SURROUND_DIRECT_LEFT: AVChannel = 33;
4413#[doc = " See above."]
4414pub const AVChannel_AV_CHAN_SURROUND_DIRECT_RIGHT: AVChannel = 34;
4415#[doc = " See above."]
4416pub const AVChannel_AV_CHAN_LOW_FREQUENCY_2: AVChannel = 35;
4417#[doc = " See above."]
4418pub const AVChannel_AV_CHAN_TOP_SIDE_LEFT: AVChannel = 36;
4419#[doc = " See above."]
4420pub const AVChannel_AV_CHAN_TOP_SIDE_RIGHT: AVChannel = 37;
4421#[doc = " See above."]
4422pub const AVChannel_AV_CHAN_BOTTOM_FRONT_CENTER: AVChannel = 38;
4423#[doc = " See above."]
4424pub const AVChannel_AV_CHAN_BOTTOM_FRONT_LEFT: AVChannel = 39;
4425#[doc = " See above."]
4426pub const AVChannel_AV_CHAN_BOTTOM_FRONT_RIGHT: AVChannel = 40;
4427#[doc = " Channel is empty can be safely skipped."]
4428pub const AVChannel_AV_CHAN_UNUSED: AVChannel = 512;
4429#[doc = " Channel contains data, but its position is unknown."]
4430pub const AVChannel_AV_CHAN_UNKNOWN: AVChannel = 768;
4431#[doc = " Range of channels between AV_CHAN_AMBISONIC_BASE and\n AV_CHAN_AMBISONIC_END represent Ambisonic components using the ACN system.\n\n Given a channel id `<i>` between AV_CHAN_AMBISONIC_BASE and\n AV_CHAN_AMBISONIC_END (inclusive), the ACN index of the channel `<n>` is\n `<n> = <i> - AV_CHAN_AMBISONIC_BASE`.\n\n @note these values are only used for AV_CHANNEL_ORDER_CUSTOM channel\n orderings, the AV_CHANNEL_ORDER_AMBISONIC ordering orders the channels\n implicitly by their position in the stream."]
4432pub const AVChannel_AV_CHAN_AMBISONIC_BASE: AVChannel = 1024;
4433#[doc = " Range of channels between AV_CHAN_AMBISONIC_BASE and\n AV_CHAN_AMBISONIC_END represent Ambisonic components using the ACN system.\n\n Given a channel id `<i>` between AV_CHAN_AMBISONIC_BASE and\n AV_CHAN_AMBISONIC_END (inclusive), the ACN index of the channel `<n>` is\n `<n> = <i> - AV_CHAN_AMBISONIC_BASE`.\n\n @note these values are only used for AV_CHANNEL_ORDER_CUSTOM channel\n orderings, the AV_CHANNEL_ORDER_AMBISONIC ordering orders the channels\n implicitly by their position in the stream."]
4434pub const AVChannel_AV_CHAN_AMBISONIC_END: AVChannel = 2047;
4435#[doc = " @defgroup lavu_audio_channels Audio channels\n @ingroup lavu_audio\n\n Audio channel layout utility functions\n\n @{"]
4436pub type AVChannel = ::std::os::raw::c_int;
4437#[doc = " Only the channel count is specified, without any further information\n about the channel order."]
4438pub const AVChannelOrder_AV_CHANNEL_ORDER_UNSPEC: AVChannelOrder = 0;
4439#[doc = " The native channel order, i.e. the channels are in the same order in\n which they are defined in the AVChannel enum. This supports up to 63\n different channels."]
4440pub const AVChannelOrder_AV_CHANNEL_ORDER_NATIVE: AVChannelOrder = 1;
4441#[doc = " The channel order does not correspond to any other predefined order and\n is stored as an explicit map. For example, this could be used to support\n layouts with 64 or more channels, or with empty/skipped (AV_CHAN_UNUSED)\n channels at arbitrary positions."]
4442pub const AVChannelOrder_AV_CHANNEL_ORDER_CUSTOM: AVChannelOrder = 2;
4443#[doc = " The audio is represented as the decomposition of the sound field into\n spherical harmonics. Each channel corresponds to a single expansion\n component. Channels are ordered according to ACN (Ambisonic Channel\n Number).\n\n The channel with the index n in the stream contains the spherical\n harmonic of degree l and order m given by\n @code{.unparsed}\n l = floor(sqrt(n)),\n m = n - l * (l + 1).\n @endcode\n\n Conversely given a spherical harmonic of degree l and order m, the\n corresponding channel index n is given by\n @code{.unparsed}\n n = l * (l + 1) + m.\n @endcode\n\n Normalization is assumed to be SN3D (Schmidt Semi-Normalization)\n as defined in AmbiX format $ 2.1."]
4444pub const AVChannelOrder_AV_CHANNEL_ORDER_AMBISONIC: AVChannelOrder = 3;
4445#[doc = " Number of channel orders, not part of ABI/API"]
4446pub const AVChannelOrder_FF_CHANNEL_ORDER_NB: AVChannelOrder = 4;
4447pub type AVChannelOrder = ::std::os::raw::c_uint;
4448pub const AVMatrixEncoding_AV_MATRIX_ENCODING_NONE: AVMatrixEncoding = 0;
4449pub const AVMatrixEncoding_AV_MATRIX_ENCODING_DOLBY: AVMatrixEncoding = 1;
4450pub const AVMatrixEncoding_AV_MATRIX_ENCODING_DPLII: AVMatrixEncoding = 2;
4451pub const AVMatrixEncoding_AV_MATRIX_ENCODING_DPLIIX: AVMatrixEncoding = 3;
4452pub const AVMatrixEncoding_AV_MATRIX_ENCODING_DPLIIZ: AVMatrixEncoding = 4;
4453pub const AVMatrixEncoding_AV_MATRIX_ENCODING_DOLBYEX: AVMatrixEncoding = 5;
4454pub const AVMatrixEncoding_AV_MATRIX_ENCODING_DOLBYHEADPHONE: AVMatrixEncoding = 6;
4455pub const AVMatrixEncoding_AV_MATRIX_ENCODING_NB: AVMatrixEncoding = 7;
4456pub type AVMatrixEncoding = ::std::os::raw::c_uint;
4457#[doc = " An AVChannelCustom defines a single channel within a custom order layout\n\n Unlike most structures in FFmpeg, sizeof(AVChannelCustom) is a part of the\n public ABI.\n\n No new fields may be added to it without a major version bump."]
4458#[repr(C)]
4459#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4460pub struct AVChannelCustom {
4461 pub id: AVChannel,
4462 pub name: [::std::os::raw::c_char; 16usize],
4463 pub opaque: *mut ::std::os::raw::c_void,
4464}
4465impl Default for AVChannelCustom {
4466 fn default() -> Self {
4467 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4468 unsafe {
4469 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4470 s.assume_init()
4471 }
4472 }
4473}
4474#[doc = " An AVChannelLayout holds information about the channel layout of audio data.\n\n A channel layout here is defined as a set of channels ordered in a specific\n way (unless the channel order is AV_CHANNEL_ORDER_UNSPEC, in which case an\n AVChannelLayout carries only the channel count).\n All orders may be treated as if they were AV_CHANNEL_ORDER_UNSPEC by\n ignoring everything but the channel count, as long as av_channel_layout_check()\n considers they are valid.\n\n Unlike most structures in FFmpeg, sizeof(AVChannelLayout) is a part of the\n public ABI and may be used by the caller. E.g. it may be allocated on stack\n or embedded in caller-defined structs.\n\n AVChannelLayout can be initialized as follows:\n - default initialization with {0}, followed by setting all used fields\n correctly;\n - by assigning one of the predefined AV_CHANNEL_LAYOUT_* initializers;\n - with a constructor function, such as av_channel_layout_default(),\n av_channel_layout_from_mask() or av_channel_layout_from_string().\n\n The channel layout must be unitialized with av_channel_layout_uninit()\n\n Copying an AVChannelLayout via assigning is forbidden,\n av_channel_layout_copy() must be used instead (and its return value should\n be checked)\n\n No new fields may be added to it without a major version bump, except for\n new elements of the union fitting in sizeof(uint64_t)."]
4475#[repr(C)]
4476#[derive(Copy, Clone)]
4477pub struct AVChannelLayout {
4478 #[doc = " Channel order used in this layout.\n This is a mandatory field."]
4479 pub order: AVChannelOrder,
4480 #[doc = " Number of channels in this layout. Mandatory field."]
4481 pub nb_channels: ::std::os::raw::c_int,
4482 pub u: AVChannelLayout__bindgen_ty_1,
4483 #[doc = " For some private data of the user."]
4484 pub opaque: *mut ::std::os::raw::c_void,
4485}
4486#[doc = " Details about which channels are present in this layout.\n For AV_CHANNEL_ORDER_UNSPEC, this field is undefined and must not be\n used."]
4487#[repr(C)]
4488#[derive(Copy, Clone)]
4489pub union AVChannelLayout__bindgen_ty_1 {
4490 #[doc = " This member must be used for AV_CHANNEL_ORDER_NATIVE, and may be used\n for AV_CHANNEL_ORDER_AMBISONIC to signal non-diegetic channels.\n It is a bitmask, where the position of each set bit means that the\n AVChannel with the corresponding value is present.\n\n I.e. when (mask & (1 << AV_CHAN_FOO)) is non-zero, then AV_CHAN_FOO\n is present in the layout. Otherwise it is not present.\n\n @note when a channel layout using a bitmask is constructed or\n modified manually (i.e. not using any of the av_channel_layout_*\n functions), the code doing it must ensure that the number of set bits\n is equal to nb_channels."]
4491 pub mask: u64,
4492 #[doc = " This member must be used when the channel order is\n AV_CHANNEL_ORDER_CUSTOM. It is a nb_channels-sized array, with each\n element signalling the presence of the AVChannel with the\n corresponding value in map[i].id.\n\n I.e. when map[i].id is equal to AV_CHAN_FOO, then AV_CH_FOO is the\n i-th channel in the audio data.\n\n When map[i].id is in the range between AV_CHAN_AMBISONIC_BASE and\n AV_CHAN_AMBISONIC_END (inclusive), the channel contains an ambisonic\n component with ACN index (as defined above)\n n = map[i].id - AV_CHAN_AMBISONIC_BASE.\n\n map[i].name may be filled with a 0-terminated string, in which case\n it will be used for the purpose of identifying the channel with the\n convenience functions below. Otherise it must be zeroed."]
4493 pub map: *mut AVChannelCustom,
4494}
4495impl Default for AVChannelLayout__bindgen_ty_1 {
4496 fn default() -> Self {
4497 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4498 unsafe {
4499 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4500 s.assume_init()
4501 }
4502 }
4503}
4504impl Default for AVChannelLayout {
4505 fn default() -> Self {
4506 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4507 unsafe {
4508 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4509 s.assume_init()
4510 }
4511 }
4512}
4513#[doc = " @}"]
4514#[repr(C)]
4515#[derive(Debug, Copy, Clone)]
4516pub struct AVBPrint {
4517 _unused: [u8; 0],
4518}
4519extern "C" {
4520 #[doc = " Get a human readable string in an abbreviated form describing a given channel.\n This is the inverse function of @ref av_channel_from_string().\n\n @param buf pre-allocated buffer where to put the generated string\n @param buf_size size in bytes of the buffer.\n @param channel the AVChannel whose name to get\n @return amount of bytes needed to hold the output string, or a negative AVERROR\n on failure. If the returned value is bigger than buf_size, then the\n string was truncated."]
4521 pub fn av_channel_name(
4522 buf: *mut ::std::os::raw::c_char,
4523 buf_size: usize,
4524 channel: AVChannel,
4525 ) -> ::std::os::raw::c_int;
4526}
4527extern "C" {
4528 #[doc = " bprint variant of av_channel_name().\n\n @note the string will be appended to the bprint buffer."]
4529 pub fn av_channel_name_bprint(bp: *mut AVBPrint, channel_id: AVChannel);
4530}
4531extern "C" {
4532 #[doc = " Get a human readable string describing a given channel.\n\n @param buf pre-allocated buffer where to put the generated string\n @param buf_size size in bytes of the buffer.\n @param channel the AVChannel whose description to get\n @return amount of bytes needed to hold the output string, or a negative AVERROR\n on failure. If the returned value is bigger than buf_size, then the\n string was truncated."]
4533 pub fn av_channel_description(
4534 buf: *mut ::std::os::raw::c_char,
4535 buf_size: usize,
4536 channel: AVChannel,
4537 ) -> ::std::os::raw::c_int;
4538}
4539extern "C" {
4540 #[doc = " bprint variant of av_channel_description().\n\n @note the string will be appended to the bprint buffer."]
4541 pub fn av_channel_description_bprint(bp: *mut AVBPrint, channel_id: AVChannel);
4542}
4543extern "C" {
4544 #[doc = " This is the inverse function of @ref av_channel_name().\n\n @return the channel with the given name\n AV_CHAN_NONE when name does not identify a known channel"]
4545 pub fn av_channel_from_string(name: *const ::std::os::raw::c_char) -> AVChannel;
4546}
4547extern "C" {
4548 #[doc = " Initialize a custom channel layout with the specified number of channels.\n The channel map will be allocated and the designation of all channels will\n be set to AV_CHAN_UNKNOWN.\n\n This is only a convenience helper function, a custom channel layout can also\n be constructed without using this.\n\n @param channel_layout the layout structure to be initialized\n @param nb_channels the number of channels\n\n @return 0 on success\n AVERROR(EINVAL) if the number of channels <= 0\n AVERROR(ENOMEM) if the channel map could not be allocated"]
4549 pub fn av_channel_layout_custom_init(
4550 channel_layout: *mut AVChannelLayout,
4551 nb_channels: ::std::os::raw::c_int,
4552 ) -> ::std::os::raw::c_int;
4553}
4554extern "C" {
4555 #[doc = " Initialize a native channel layout from a bitmask indicating which channels\n are present.\n\n @param channel_layout the layout structure to be initialized\n @param mask bitmask describing the channel layout\n\n @return 0 on success\n AVERROR(EINVAL) for invalid mask values"]
4556 pub fn av_channel_layout_from_mask(
4557 channel_layout: *mut AVChannelLayout,
4558 mask: u64,
4559 ) -> ::std::os::raw::c_int;
4560}
4561extern "C" {
4562 #[doc = " Initialize a channel layout from a given string description.\n The input string can be represented by:\n - the formal channel layout name (returned by av_channel_layout_describe())\n - single or multiple channel names (returned by av_channel_name(), eg. \"FL\",\n or concatenated with \"+\", each optionally containing a custom name after\n a \"@\", eg. \"FL@Left+FR@Right+LFE\")\n - a decimal or hexadecimal value of a native channel layout (eg. \"4\" or \"0x4\")\n - the number of channels with default layout (eg. \"4c\")\n - the number of unordered channels (eg. \"4C\" or \"4 channels\")\n - the ambisonic order followed by optional non-diegetic channels (eg.\n \"ambisonic 2+stereo\")\n On error, the channel layout will remain uninitialized, but not necessarily\n untouched.\n\n @param channel_layout uninitialized channel layout for the result\n @param str string describing the channel layout\n @return 0 on success parsing the channel layout\n AVERROR(EINVAL) if an invalid channel layout string was provided\n AVERROR(ENOMEM) if there was not enough memory"]
4563 pub fn av_channel_layout_from_string(
4564 channel_layout: *mut AVChannelLayout,
4565 str_: *const ::std::os::raw::c_char,
4566 ) -> ::std::os::raw::c_int;
4567}
4568extern "C" {
4569 #[doc = " Get the default channel layout for a given number of channels.\n\n @param ch_layout the layout structure to be initialized\n @param nb_channels number of channels"]
4570 pub fn av_channel_layout_default(
4571 ch_layout: *mut AVChannelLayout,
4572 nb_channels: ::std::os::raw::c_int,
4573 );
4574}
4575extern "C" {
4576 #[doc = " Iterate over all standard channel layouts.\n\n @param opaque a pointer where libavutil will store the iteration state. Must\n point to NULL to start the iteration.\n\n @return the standard channel layout or NULL when the iteration is\n finished"]
4577 pub fn av_channel_layout_standard(
4578 opaque: *mut *mut ::std::os::raw::c_void,
4579 ) -> *const AVChannelLayout;
4580}
4581extern "C" {
4582 #[doc = " Free any allocated data in the channel layout and reset the channel\n count to 0.\n\n @param channel_layout the layout structure to be uninitialized"]
4583 pub fn av_channel_layout_uninit(channel_layout: *mut AVChannelLayout);
4584}
4585extern "C" {
4586 #[doc = " Make a copy of a channel layout. This differs from just assigning src to dst\n in that it allocates and copies the map for AV_CHANNEL_ORDER_CUSTOM.\n\n @note the destination channel_layout will be always uninitialized before copy.\n\n @param dst destination channel layout\n @param src source channel layout\n @return 0 on success, a negative AVERROR on error."]
4587 pub fn av_channel_layout_copy(
4588 dst: *mut AVChannelLayout,
4589 src: *const AVChannelLayout,
4590 ) -> ::std::os::raw::c_int;
4591}
4592extern "C" {
4593 #[doc = " Get a human-readable string describing the channel layout properties.\n The string will be in the same format that is accepted by\n @ref av_channel_layout_from_string(), allowing to rebuild the same\n channel layout, except for opaque pointers.\n\n @param channel_layout channel layout to be described\n @param buf pre-allocated buffer where to put the generated string\n @param buf_size size in bytes of the buffer.\n @return amount of bytes needed to hold the output string, or a negative AVERROR\n on failure. If the returned value is bigger than buf_size, then the\n string was truncated."]
4594 pub fn av_channel_layout_describe(
4595 channel_layout: *const AVChannelLayout,
4596 buf: *mut ::std::os::raw::c_char,
4597 buf_size: usize,
4598 ) -> ::std::os::raw::c_int;
4599}
4600extern "C" {
4601 #[doc = " bprint variant of av_channel_layout_describe().\n\n @note the string will be appended to the bprint buffer.\n @return 0 on success, or a negative AVERROR value on failure."]
4602 pub fn av_channel_layout_describe_bprint(
4603 channel_layout: *const AVChannelLayout,
4604 bp: *mut AVBPrint,
4605 ) -> ::std::os::raw::c_int;
4606}
4607extern "C" {
4608 #[doc = " Get the channel with the given index in a channel layout.\n\n @param channel_layout input channel layout\n @param idx index of the channel\n @return channel with the index idx in channel_layout on success or\n AV_CHAN_NONE on failure (if idx is not valid or the channel order is\n unspecified)"]
4609 pub fn av_channel_layout_channel_from_index(
4610 channel_layout: *const AVChannelLayout,
4611 idx: ::std::os::raw::c_uint,
4612 ) -> AVChannel;
4613}
4614extern "C" {
4615 #[doc = " Get the index of a given channel in a channel layout. In case multiple\n channels are found, only the first match will be returned.\n\n @param channel_layout input channel layout\n @param channel the channel whose index to obtain\n @return index of channel in channel_layout on success or a negative number if\n channel is not present in channel_layout."]
4616 pub fn av_channel_layout_index_from_channel(
4617 channel_layout: *const AVChannelLayout,
4618 channel: AVChannel,
4619 ) -> ::std::os::raw::c_int;
4620}
4621extern "C" {
4622 #[doc = " Get the index in a channel layout of a channel described by the given string.\n In case multiple channels are found, only the first match will be returned.\n\n This function accepts channel names in the same format as\n @ref av_channel_from_string().\n\n @param channel_layout input channel layout\n @param name string describing the channel whose index to obtain\n @return a channel index described by the given string, or a negative AVERROR\n value."]
4623 pub fn av_channel_layout_index_from_string(
4624 channel_layout: *const AVChannelLayout,
4625 name: *const ::std::os::raw::c_char,
4626 ) -> ::std::os::raw::c_int;
4627}
4628extern "C" {
4629 #[doc = " Get a channel described by the given string.\n\n This function accepts channel names in the same format as\n @ref av_channel_from_string().\n\n @param channel_layout input channel layout\n @param name string describing the channel to obtain\n @return a channel described by the given string in channel_layout on success\n or AV_CHAN_NONE on failure (if the string is not valid or the channel\n order is unspecified)"]
4630 pub fn av_channel_layout_channel_from_string(
4631 channel_layout: *const AVChannelLayout,
4632 name: *const ::std::os::raw::c_char,
4633 ) -> AVChannel;
4634}
4635extern "C" {
4636 #[doc = " Find out what channels from a given set are present in a channel layout,\n without regard for their positions.\n\n @param channel_layout input channel layout\n @param mask a combination of AV_CH_* representing a set of channels\n @return a bitfield representing all the channels from mask that are present\n in channel_layout"]
4637 pub fn av_channel_layout_subset(channel_layout: *const AVChannelLayout, mask: u64) -> u64;
4638}
4639extern "C" {
4640 #[doc = " Check whether a channel layout is valid, i.e. can possibly describe audio\n data.\n\n @param channel_layout input channel layout\n @return 1 if channel_layout is valid, 0 otherwise."]
4641 pub fn av_channel_layout_check(channel_layout: *const AVChannelLayout)
4642 -> ::std::os::raw::c_int;
4643}
4644extern "C" {
4645 #[doc = " Check whether two channel layouts are semantically the same, i.e. the same\n channels are present on the same positions in both.\n\n If one of the channel layouts is AV_CHANNEL_ORDER_UNSPEC, while the other is\n not, they are considered to be unequal. If both are AV_CHANNEL_ORDER_UNSPEC,\n they are considered equal iff the channel counts are the same in both.\n\n @param chl input channel layout\n @param chl1 input channel layout\n @return 0 if chl and chl1 are equal, 1 if they are not equal. A negative\n AVERROR code if one or both are invalid."]
4646 pub fn av_channel_layout_compare(
4647 chl: *const AVChannelLayout,
4648 chl1: *const AVChannelLayout,
4649 ) -> ::std::os::raw::c_int;
4650}
4651extern "C" {
4652 #[doc = " Change the AVChannelOrder of a channel layout.\n\n Change of AVChannelOrder can be either lossless or lossy. In case of a\n lossless conversion all the channel designations and the associated channel\n names (if any) are kept. On a lossy conversion the channel names and channel\n designations might be lost depending on the capabilities of the desired\n AVChannelOrder. Note that some conversions are simply not possible in which\n case this function returns AVERROR(ENOSYS).\n\n The following conversions are supported:\n\n Any -> Custom : Always possible, always lossless.\n Any -> Unspecified: Always possible, lossless if channel designations\n are all unknown and channel names are not used, lossy otherwise.\n Custom -> Ambisonic : Possible if it contains ambisonic channels with\n optional non-diegetic channels in the end. Lossy if the channels have\n custom names, lossless otherwise.\n Custom -> Native : Possible if it contains native channels in native\n order. Lossy if the channels have custom names, lossless otherwise.\n\n On error this function keeps the original channel layout untouched.\n\n @param channel_layout channel layout which will be changed\n @param order the desired channel layout order\n @param flags a combination of AV_CHANNEL_LAYOUT_RETYPE_FLAG_* constants\n @return 0 if the conversion was successful and lossless or if the channel\n layout was already in the desired order\n >0 if the conversion was successful but lossy\n AVERROR(ENOSYS) if the conversion was not possible (or would be\n lossy and AV_CHANNEL_LAYOUT_RETYPE_FLAG_LOSSLESS was specified)\n AVERROR(EINVAL), AVERROR(ENOMEM) on error"]
4653 pub fn av_channel_layout_retype(
4654 channel_layout: *mut AVChannelLayout,
4655 order: AVChannelOrder,
4656 flags: ::std::os::raw::c_int,
4657 ) -> ::std::os::raw::c_int;
4658}
4659#[doc = " @}"]
4660#[repr(C)]
4661#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4662pub struct AVDictionaryEntry {
4663 pub key: *mut ::std::os::raw::c_char,
4664 pub value: *mut ::std::os::raw::c_char,
4665}
4666impl Default for AVDictionaryEntry {
4667 fn default() -> Self {
4668 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4669 unsafe {
4670 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4671 s.assume_init()
4672 }
4673 }
4674}
4675#[repr(C)]
4676#[derive(Debug, Copy, Clone)]
4677pub struct AVDictionary {
4678 _unused: [u8; 0],
4679}
4680extern "C" {
4681 #[doc = " Get a dictionary entry with matching key.\n\n The returned entry key or value must not be changed, or it will\n cause undefined behavior.\n\n @param prev Set to the previous matching element to find the next.\n If set to NULL the first matching element is returned.\n @param key Matching key\n @param flags A collection of AV_DICT_* flags controlling how the\n entry is retrieved\n\n @return Found entry or NULL in case no matching entry was found in the dictionary"]
4682 pub fn av_dict_get(
4683 m: *const AVDictionary,
4684 key: *const ::std::os::raw::c_char,
4685 prev: *const AVDictionaryEntry,
4686 flags: ::std::os::raw::c_int,
4687 ) -> *mut AVDictionaryEntry;
4688}
4689extern "C" {
4690 #[doc = " Iterate over a dictionary\n\n Iterates through all entries in the dictionary.\n\n @warning The returned AVDictionaryEntry key/value must not be changed.\n\n @warning As av_dict_set() invalidates all previous entries returned\n by this function, it must not be called while iterating over the dict.\n\n Typical usage:\n @code\n const AVDictionaryEntry *e = NULL;\n while ((e = av_dict_iterate(m, e))) {\n // ...\n }\n @endcode\n\n @param m The dictionary to iterate over\n @param prev Pointer to the previous AVDictionaryEntry, NULL initially\n\n @retval AVDictionaryEntry* The next element in the dictionary\n @retval NULL No more elements in the dictionary"]
4691 pub fn av_dict_iterate(
4692 m: *const AVDictionary,
4693 prev: *const AVDictionaryEntry,
4694 ) -> *const AVDictionaryEntry;
4695}
4696extern "C" {
4697 #[doc = " Get number of entries in dictionary.\n\n @param m dictionary\n @return number of entries in dictionary"]
4698 pub fn av_dict_count(m: *const AVDictionary) -> ::std::os::raw::c_int;
4699}
4700extern "C" {
4701 #[doc = " Set the given entry in *pm, overwriting an existing entry.\n\n Note: If AV_DICT_DONT_STRDUP_KEY or AV_DICT_DONT_STRDUP_VAL is set,\n these arguments will be freed on error.\n\n @warning Adding a new entry to a dictionary invalidates all existing entries\n previously returned with av_dict_get() or av_dict_iterate().\n\n @param pm Pointer to a pointer to a dictionary struct. If *pm is NULL\n a dictionary struct is allocated and put in *pm.\n @param key Entry key to add to *pm (will either be av_strduped or added as a new key depending on flags)\n @param value Entry value to add to *pm (will be av_strduped or added as a new key depending on flags).\n Passing a NULL value will cause an existing entry to be deleted.\n\n @return >= 0 on success otherwise an error code <0"]
4702 pub fn av_dict_set(
4703 pm: *mut *mut AVDictionary,
4704 key: *const ::std::os::raw::c_char,
4705 value: *const ::std::os::raw::c_char,
4706 flags: ::std::os::raw::c_int,
4707 ) -> ::std::os::raw::c_int;
4708}
4709extern "C" {
4710 #[doc = " Convenience wrapper for av_dict_set() that converts the value to a string\n and stores it.\n\n Note: If ::AV_DICT_DONT_STRDUP_KEY is set, key will be freed on error."]
4711 pub fn av_dict_set_int(
4712 pm: *mut *mut AVDictionary,
4713 key: *const ::std::os::raw::c_char,
4714 value: i64,
4715 flags: ::std::os::raw::c_int,
4716 ) -> ::std::os::raw::c_int;
4717}
4718extern "C" {
4719 #[doc = " Parse the key/value pairs list and add the parsed entries to a dictionary.\n\n In case of failure, all the successfully set entries are stored in\n *pm. You may need to manually free the created dictionary.\n\n @param key_val_sep A 0-terminated list of characters used to separate\n key from value\n @param pairs_sep A 0-terminated list of characters used to separate\n two pairs from each other\n @param flags Flags to use when adding to the dictionary.\n ::AV_DICT_DONT_STRDUP_KEY and ::AV_DICT_DONT_STRDUP_VAL\n are ignored since the key/value tokens will always\n be duplicated.\n\n @return 0 on success, negative AVERROR code on failure"]
4720 pub fn av_dict_parse_string(
4721 pm: *mut *mut AVDictionary,
4722 str_: *const ::std::os::raw::c_char,
4723 key_val_sep: *const ::std::os::raw::c_char,
4724 pairs_sep: *const ::std::os::raw::c_char,
4725 flags: ::std::os::raw::c_int,
4726 ) -> ::std::os::raw::c_int;
4727}
4728extern "C" {
4729 #[doc = " Copy entries from one AVDictionary struct into another.\n\n @note Metadata is read using the ::AV_DICT_IGNORE_SUFFIX flag\n\n @param dst Pointer to a pointer to a AVDictionary struct to copy into. If *dst is NULL,\n this function will allocate a struct for you and put it in *dst\n @param src Pointer to the source AVDictionary struct to copy items from.\n @param flags Flags to use when setting entries in *dst\n\n @return 0 on success, negative AVERROR code on failure. If dst was allocated\n by this function, callers should free the associated memory."]
4730 pub fn av_dict_copy(
4731 dst: *mut *mut AVDictionary,
4732 src: *const AVDictionary,
4733 flags: ::std::os::raw::c_int,
4734 ) -> ::std::os::raw::c_int;
4735}
4736extern "C" {
4737 #[doc = " Free all the memory allocated for an AVDictionary struct\n and all keys and values."]
4738 pub fn av_dict_free(m: *mut *mut AVDictionary);
4739}
4740extern "C" {
4741 #[doc = " Get dictionary entries as a string.\n\n Create a string containing dictionary's entries.\n Such string may be passed back to av_dict_parse_string().\n @note String is escaped with backslashes ('\\').\n\n @warning Separators cannot be neither '\\\\' nor '\\0'. They also cannot be the same.\n\n @param[in] m The dictionary\n @param[out] buffer Pointer to buffer that will be allocated with string containg entries.\n Buffer must be freed by the caller when is no longer needed.\n @param[in] key_val_sep Character used to separate key from value\n @param[in] pairs_sep Character used to separate two pairs from each other\n\n @return >= 0 on success, negative on error"]
4742 pub fn av_dict_get_string(
4743 m: *const AVDictionary,
4744 buffer: *mut *mut ::std::os::raw::c_char,
4745 key_val_sep: ::std::os::raw::c_char,
4746 pairs_sep: ::std::os::raw::c_char,
4747 ) -> ::std::os::raw::c_int;
4748}
4749#[doc = " The data is the AVPanScan struct defined in libavcodec."]
4750pub const AVFrameSideDataType_AV_FRAME_DATA_PANSCAN: AVFrameSideDataType = 0;
4751#[doc = " ATSC A53 Part 4 Closed Captions.\n A53 CC bitstream is stored as uint8_t in AVFrameSideData.data.\n The number of bytes of CC data is AVFrameSideData.size."]
4752pub const AVFrameSideDataType_AV_FRAME_DATA_A53_CC: AVFrameSideDataType = 1;
4753#[doc = " Stereoscopic 3d metadata.\n The data is the AVStereo3D struct defined in libavutil/stereo3d.h."]
4754pub const AVFrameSideDataType_AV_FRAME_DATA_STEREO3D: AVFrameSideDataType = 2;
4755#[doc = " The data is the AVMatrixEncoding enum defined in libavutil/channel_layout.h."]
4756pub const AVFrameSideDataType_AV_FRAME_DATA_MATRIXENCODING: AVFrameSideDataType = 3;
4757#[doc = " Metadata relevant to a downmix procedure.\n The data is the AVDownmixInfo struct defined in libavutil/downmix_info.h."]
4758pub const AVFrameSideDataType_AV_FRAME_DATA_DOWNMIX_INFO: AVFrameSideDataType = 4;
4759#[doc = " ReplayGain information in the form of the AVReplayGain struct."]
4760pub const AVFrameSideDataType_AV_FRAME_DATA_REPLAYGAIN: AVFrameSideDataType = 5;
4761#[doc = " This side data contains a 3x3 transformation matrix describing an affine\n transformation that needs to be applied to the frame for correct\n presentation.\n\n See libavutil/display.h for a detailed description of the data."]
4762pub const AVFrameSideDataType_AV_FRAME_DATA_DISPLAYMATRIX: AVFrameSideDataType = 6;
4763#[doc = " Active Format Description data consisting of a single byte as specified\n in ETSI TS 101 154 using AVActiveFormatDescription enum."]
4764pub const AVFrameSideDataType_AV_FRAME_DATA_AFD: AVFrameSideDataType = 7;
4765#[doc = " Motion vectors exported by some codecs (on demand through the export_mvs\n flag set in the libavcodec AVCodecContext flags2 option).\n The data is the AVMotionVector struct defined in\n libavutil/motion_vector.h."]
4766pub const AVFrameSideDataType_AV_FRAME_DATA_MOTION_VECTORS: AVFrameSideDataType = 8;
4767#[doc = " Recommmends skipping the specified number of samples. This is exported\n only if the \"skip_manual\" AVOption is set in libavcodec.\n This has the same format as AV_PKT_DATA_SKIP_SAMPLES.\n @code\n u32le number of samples to skip from start of this packet\n u32le number of samples to skip from end of this packet\n u8 reason for start skip\n u8 reason for end skip (0=padding silence, 1=convergence)\n @endcode"]
4768pub const AVFrameSideDataType_AV_FRAME_DATA_SKIP_SAMPLES: AVFrameSideDataType = 9;
4769#[doc = " This side data must be associated with an audio frame and corresponds to\n enum AVAudioServiceType defined in avcodec.h."]
4770pub const AVFrameSideDataType_AV_FRAME_DATA_AUDIO_SERVICE_TYPE: AVFrameSideDataType = 10;
4771#[doc = " Mastering display metadata associated with a video frame. The payload is\n an AVMasteringDisplayMetadata type and contains information about the\n mastering display color volume."]
4772pub const AVFrameSideDataType_AV_FRAME_DATA_MASTERING_DISPLAY_METADATA: AVFrameSideDataType = 11;
4773#[doc = " The GOP timecode in 25 bit timecode format. Data format is 64-bit integer.\n This is set on the first frame of a GOP that has a temporal reference of 0."]
4774pub const AVFrameSideDataType_AV_FRAME_DATA_GOP_TIMECODE: AVFrameSideDataType = 12;
4775#[doc = " The data represents the AVSphericalMapping structure defined in\n libavutil/spherical.h."]
4776pub const AVFrameSideDataType_AV_FRAME_DATA_SPHERICAL: AVFrameSideDataType = 13;
4777#[doc = " Content light level (based on CTA-861.3). This payload contains data in\n the form of the AVContentLightMetadata struct."]
4778pub const AVFrameSideDataType_AV_FRAME_DATA_CONTENT_LIGHT_LEVEL: AVFrameSideDataType = 14;
4779#[doc = " The data contains an ICC profile as an opaque octet buffer following the\n format described by ISO 15076-1 with an optional name defined in the\n metadata key entry \"name\"."]
4780pub const AVFrameSideDataType_AV_FRAME_DATA_ICC_PROFILE: AVFrameSideDataType = 15;
4781#[doc = " Timecode which conforms to SMPTE ST 12-1. The data is an array of 4 uint32_t\n where the first uint32_t describes how many (1-3) of the other timecodes are used.\n The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()\n function in libavutil/timecode.h."]
4782pub const AVFrameSideDataType_AV_FRAME_DATA_S12M_TIMECODE: AVFrameSideDataType = 16;
4783#[doc = " HDR dynamic metadata associated with a video frame. The payload is\n an AVDynamicHDRPlus type and contains information for color\n volume transform - application 4 of SMPTE 2094-40:2016 standard."]
4784pub const AVFrameSideDataType_AV_FRAME_DATA_DYNAMIC_HDR_PLUS: AVFrameSideDataType = 17;
4785#[doc = " Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of\n array element is implied by AVFrameSideData.size / AVRegionOfInterest.self_size."]
4786pub const AVFrameSideDataType_AV_FRAME_DATA_REGIONS_OF_INTEREST: AVFrameSideDataType = 18;
4787#[doc = " Encoding parameters for a video frame, as described by AVVideoEncParams."]
4788pub const AVFrameSideDataType_AV_FRAME_DATA_VIDEO_ENC_PARAMS: AVFrameSideDataType = 19;
4789#[doc = " User data unregistered metadata associated with a video frame.\n This is the H.26[45] UDU SEI message, and shouldn't be used for any other purpose\n The data is stored as uint8_t in AVFrameSideData.data which is 16 bytes of\n uuid_iso_iec_11578 followed by AVFrameSideData.size - 16 bytes of user_data_payload_byte."]
4790pub const AVFrameSideDataType_AV_FRAME_DATA_SEI_UNREGISTERED: AVFrameSideDataType = 20;
4791#[doc = " Film grain parameters for a frame, described by AVFilmGrainParams.\n Must be present for every frame which should have film grain applied.\n\n May be present multiple times, for example when there are multiple\n alternative parameter sets for different video signal characteristics.\n The user should select the most appropriate set for the application."]
4792pub const AVFrameSideDataType_AV_FRAME_DATA_FILM_GRAIN_PARAMS: AVFrameSideDataType = 21;
4793#[doc = " Bounding boxes for object detection and classification,\n as described by AVDetectionBBoxHeader."]
4794pub const AVFrameSideDataType_AV_FRAME_DATA_DETECTION_BBOXES: AVFrameSideDataType = 22;
4795#[doc = " Dolby Vision RPU raw data, suitable for passing to x265\n or other libraries. Array of uint8_t, with NAL emulation\n bytes intact."]
4796pub const AVFrameSideDataType_AV_FRAME_DATA_DOVI_RPU_BUFFER: AVFrameSideDataType = 23;
4797#[doc = " Parsed Dolby Vision metadata, suitable for passing to a software\n implementation. The payload is the AVDOVIMetadata struct defined in\n libavutil/dovi_meta.h."]
4798pub const AVFrameSideDataType_AV_FRAME_DATA_DOVI_METADATA: AVFrameSideDataType = 24;
4799#[doc = " HDR Vivid dynamic metadata associated with a video frame. The payload is\n an AVDynamicHDRVivid type and contains information for color\n volume transform - CUVA 005.1-2021."]
4800pub const AVFrameSideDataType_AV_FRAME_DATA_DYNAMIC_HDR_VIVID: AVFrameSideDataType = 25;
4801#[doc = " Ambient viewing environment metadata, as defined by H.274."]
4802pub const AVFrameSideDataType_AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT: AVFrameSideDataType = 26;
4803#[doc = " Provide encoder-specific hinting information about changed/unchanged\n portions of a frame. It can be used to pass information about which\n macroblocks can be skipped because they didn't change from the\n corresponding ones in the previous frame. This could be useful for\n applications which know this information in advance to speed up\n encoding."]
4804pub const AVFrameSideDataType_AV_FRAME_DATA_VIDEO_HINT: AVFrameSideDataType = 27;
4805#[doc = " @defgroup lavu_frame AVFrame\n @ingroup lavu_data\n\n @{\n AVFrame is an abstraction for reference-counted raw multimedia data."]
4806pub type AVFrameSideDataType = ::std::os::raw::c_uint;
4807pub const AVActiveFormatDescription_AV_AFD_SAME: AVActiveFormatDescription = 8;
4808pub const AVActiveFormatDescription_AV_AFD_4_3: AVActiveFormatDescription = 9;
4809pub const AVActiveFormatDescription_AV_AFD_16_9: AVActiveFormatDescription = 10;
4810pub const AVActiveFormatDescription_AV_AFD_14_9: AVActiveFormatDescription = 11;
4811pub const AVActiveFormatDescription_AV_AFD_4_3_SP_14_9: AVActiveFormatDescription = 13;
4812pub const AVActiveFormatDescription_AV_AFD_16_9_SP_14_9: AVActiveFormatDescription = 14;
4813pub const AVActiveFormatDescription_AV_AFD_SP_4_3: AVActiveFormatDescription = 15;
4814pub type AVActiveFormatDescription = ::std::os::raw::c_uint;
4815#[doc = " Structure to hold side data for an AVFrame.\n\n sizeof(AVFrameSideData) is not a part of the public ABI, so new fields may be added\n to the end with a minor bump."]
4816#[repr(C)]
4817#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4818pub struct AVFrameSideData {
4819 pub type_: AVFrameSideDataType,
4820 pub data: *mut u8,
4821 pub size: usize,
4822 pub metadata: *mut AVDictionary,
4823 pub buf: *mut AVBufferRef,
4824}
4825impl Default for AVFrameSideData {
4826 fn default() -> Self {
4827 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4828 unsafe {
4829 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4830 s.assume_init()
4831 }
4832 }
4833}
4834#[doc = " The side data type can be used in stream-global structures.\n Side data types without this property are only meaningful on per-frame\n basis."]
4835pub const AVSideDataProps_AV_SIDE_DATA_PROP_GLOBAL: AVSideDataProps = 1;
4836#[doc = " Multiple instances of this side data type can be meaningfully present in\n a single side data array."]
4837pub const AVSideDataProps_AV_SIDE_DATA_PROP_MULTI: AVSideDataProps = 2;
4838pub type AVSideDataProps = ::std::os::raw::c_uint;
4839#[doc = " This struct describes the properties of a side data type. Its instance\n corresponding to a given type can be obtained from av_frame_side_data_desc()."]
4840#[repr(C)]
4841#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4842pub struct AVSideDataDescriptor {
4843 #[doc = " Human-readable side data description."]
4844 pub name: *const ::std::os::raw::c_char,
4845 #[doc = " Side data property flags, a combination of AVSideDataProps values."]
4846 pub props: ::std::os::raw::c_uint,
4847}
4848impl Default for AVSideDataDescriptor {
4849 fn default() -> Self {
4850 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4851 unsafe {
4852 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4853 s.assume_init()
4854 }
4855 }
4856}
4857#[doc = " Structure describing a single Region Of Interest.\n\n When multiple regions are defined in a single side-data block, they\n should be ordered from most to least important - some encoders are only\n capable of supporting a limited number of distinct regions, so will have\n to truncate the list.\n\n When overlapping regions are defined, the first region containing a given\n area of the frame applies."]
4858#[repr(C)]
4859#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
4860pub struct AVRegionOfInterest {
4861 #[doc = " Must be set to the size of this data structure (that is,\n sizeof(AVRegionOfInterest))."]
4862 pub self_size: u32,
4863 #[doc = " Distance in pixels from the top edge of the frame to the top and\n bottom edges and from the left edge of the frame to the left and\n right edges of the rectangle defining this region of interest.\n\n The constraints on a region are encoder dependent, so the region\n actually affected may be slightly larger for alignment or other\n reasons."]
4864 pub top: ::std::os::raw::c_int,
4865 pub bottom: ::std::os::raw::c_int,
4866 pub left: ::std::os::raw::c_int,
4867 pub right: ::std::os::raw::c_int,
4868 #[doc = " Quantisation offset.\n\n Must be in the range -1 to +1. A value of zero indicates no quality\n change. A negative value asks for better quality (less quantisation),\n while a positive value asks for worse quality (greater quantisation).\n\n The range is calibrated so that the extreme values indicate the\n largest possible offset - if the rest of the frame is encoded with the\n worst possible quality, an offset of -1 indicates that this region\n should be encoded with the best possible quality anyway. Intermediate\n values are then interpolated in some codec-dependent way.\n\n For example, in 10-bit H.264 the quantisation parameter varies between\n -12 and 51. A typical qoffset value of -1/10 therefore indicates that\n this region should be encoded with a QP around one-tenth of the full\n range better than the rest of the frame. So, if most of the frame\n were to be encoded with a QP of around 30, this region would get a QP\n of around 24 (an offset of approximately -1/10 * (51 - -12) = -6.3).\n An extreme value of -1 would indicate that this region should be\n encoded with the best possible quality regardless of the treatment of\n the rest of the frame - that is, should be encoded at a QP of -12."]
4869 pub qoffset: AVRational,
4870}
4871#[doc = " This structure describes decoded (raw) audio or video data.\n\n AVFrame must be allocated using av_frame_alloc(). Note that this only\n allocates the AVFrame itself, the buffers for the data must be managed\n through other means (see below).\n AVFrame must be freed with av_frame_free().\n\n AVFrame is typically allocated once and then reused multiple times to hold\n different data (e.g. a single AVFrame to hold frames received from a\n decoder). In such a case, av_frame_unref() will free any references held by\n the frame and reset it to its original clean state before it\n is reused again.\n\n The data described by an AVFrame is usually reference counted through the\n AVBuffer API. The underlying buffer references are stored in AVFrame.buf /\n AVFrame.extended_buf. An AVFrame is considered to be reference counted if at\n least one reference is set, i.e. if AVFrame.buf[0] != NULL. In such a case,\n every single data plane must be contained in one of the buffers in\n AVFrame.buf or AVFrame.extended_buf.\n There may be a single buffer for all the data, or one separate buffer for\n each plane, or anything in between.\n\n sizeof(AVFrame) is not a part of the public ABI, so new fields may be added\n to the end with a minor bump.\n\n Fields can be accessed through AVOptions, the name string used, matches the\n C structure field name for fields accessible through AVOptions."]
4872#[repr(C)]
4873#[derive(Copy, Clone)]
4874pub struct AVFrame {
4875 #[doc = " pointer to the picture/channel planes.\n This might be different from the first allocated byte. For video,\n it could even point to the end of the image data.\n\n All pointers in data and extended_data must point into one of the\n AVBufferRef in buf or extended_buf.\n\n Some decoders access areas outside 0,0 - width,height, please\n see avcodec_align_dimensions2(). Some filters and swscale can read\n up to 16 bytes beyond the planes, if these filters are to be used,\n then 16 extra bytes must be allocated.\n\n NOTE: Pointers not needed by the format MUST be set to NULL.\n\n @attention In case of video, the data[] pointers can point to the\n end of image data in order to reverse line order, when used in\n combination with negative values in the linesize[] array."]
4876 pub data: [*mut u8; 8usize],
4877 #[doc = " For video, a positive or negative value, which is typically indicating\n the size in bytes of each picture line, but it can also be:\n - the negative byte size of lines for vertical flipping\n (with data[n] pointing to the end of the data\n - a positive or negative multiple of the byte size as for accessing\n even and odd fields of a frame (possibly flipped)\n\n For audio, only linesize[0] may be set. For planar audio, each channel\n plane must be the same size.\n\n For video the linesizes should be multiples of the CPUs alignment\n preference, this is 16 or 32 for modern desktop CPUs.\n Some code requires such alignment other code can be slower without\n correct alignment, for yet other it makes no difference.\n\n @note The linesize may be larger than the size of usable data -- there\n may be extra padding present for performance reasons.\n\n @attention In case of video, line size values can be negative to achieve\n a vertically inverted iteration over image lines."]
4878 pub linesize: [::std::os::raw::c_int; 8usize],
4879 #[doc = " pointers to the data planes/channels.\n\n For video, this should simply point to data[].\n\n For planar audio, each channel has a separate data pointer, and\n linesize[0] contains the size of each channel buffer.\n For packed audio, there is just one data pointer, and linesize[0]\n contains the total size of the buffer for all channels.\n\n Note: Both data and extended_data should always be set in a valid frame,\n but for planar audio with more channels that can fit in data,\n extended_data must be used in order to access all channels."]
4880 pub extended_data: *mut *mut u8,
4881 #[doc = " @name Video dimensions\n Video frames only. The coded dimensions (in pixels) of the video frame,\n i.e. the size of the rectangle that contains some well-defined values.\n\n @note The part of the frame intended for display/presentation is further\n restricted by the @ref cropping \"Cropping rectangle\".\n @{"]
4882 pub width: ::std::os::raw::c_int,
4883 #[doc = " @name Video dimensions\n Video frames only. The coded dimensions (in pixels) of the video frame,\n i.e. the size of the rectangle that contains some well-defined values.\n\n @note The part of the frame intended for display/presentation is further\n restricted by the @ref cropping \"Cropping rectangle\".\n @{"]
4884 pub height: ::std::os::raw::c_int,
4885 #[doc = " number of audio samples (per channel) described by this frame"]
4886 pub nb_samples: ::std::os::raw::c_int,
4887 #[doc = " format of the frame, -1 if unknown or unset\n Values correspond to enum AVPixelFormat for video frames,\n enum AVSampleFormat for audio)"]
4888 pub format: ::std::os::raw::c_int,
4889 #[doc = " 1 -> keyframe, 0-> not\n\n @deprecated Use AV_FRAME_FLAG_KEY instead"]
4890 pub key_frame: ::std::os::raw::c_int,
4891 #[doc = " Picture type of the frame."]
4892 pub pict_type: AVPictureType,
4893 #[doc = " Sample aspect ratio for the video frame, 0/1 if unknown/unspecified."]
4894 pub sample_aspect_ratio: AVRational,
4895 #[doc = " Presentation timestamp in time_base units (time when frame should be shown to user)."]
4896 pub pts: i64,
4897 #[doc = " DTS copied from the AVPacket that triggered returning this frame. (if frame threading isn't used)\n This is also the Presentation time of this AVFrame calculated from\n only AVPacket.dts values without pts values."]
4898 pub pkt_dts: i64,
4899 #[doc = " Time base for the timestamps in this frame.\n In the future, this field may be set on frames output by decoders or\n filters, but its value will be by default ignored on input to encoders\n or filters."]
4900 pub time_base: AVRational,
4901 #[doc = " quality (between 1 (good) and FF_LAMBDA_MAX (bad))"]
4902 pub quality: ::std::os::raw::c_int,
4903 #[doc = " Frame owner's private data.\n\n This field may be set by the code that allocates/owns the frame data.\n It is then not touched by any library functions, except:\n - it is copied to other references by av_frame_copy_props() (and hence by\n av_frame_ref());\n - it is set to NULL when the frame is cleared by av_frame_unref()\n - on the caller's explicit request. E.g. libavcodec encoders/decoders\n will copy this field to/from @ref AVPacket \"AVPackets\" if the caller sets\n @ref AV_CODEC_FLAG_COPY_OPAQUE.\n\n @see opaque_ref the reference-counted analogue"]
4904 pub opaque: *mut ::std::os::raw::c_void,
4905 #[doc = " Number of fields in this frame which should be repeated, i.e. the total\n duration of this frame should be repeat_pict + 2 normal field durations.\n\n For interlaced frames this field may be set to 1, which signals that this\n frame should be presented as 3 fields: beginning with the first field (as\n determined by AV_FRAME_FLAG_TOP_FIELD_FIRST being set or not), followed\n by the second field, and then the first field again.\n\n For progressive frames this field may be set to a multiple of 2, which\n signals that this frame's duration should be (repeat_pict + 2) / 2\n normal frame durations.\n\n @note This field is computed from MPEG2 repeat_first_field flag and its\n associated flags, H.264 pic_struct from picture timing SEI, and\n their analogues in other codecs. Typically it should only be used when\n higher-layer timing information is not available."]
4906 pub repeat_pict: ::std::os::raw::c_int,
4907 #[doc = " The content of the picture is interlaced.\n\n @deprecated Use AV_FRAME_FLAG_INTERLACED instead"]
4908 pub interlaced_frame: ::std::os::raw::c_int,
4909 #[doc = " If the content is interlaced, is top field displayed first.\n\n @deprecated Use AV_FRAME_FLAG_TOP_FIELD_FIRST instead"]
4910 pub top_field_first: ::std::os::raw::c_int,
4911 #[doc = " Tell user application that palette has changed from previous frame."]
4912 pub palette_has_changed: ::std::os::raw::c_int,
4913 #[doc = " Sample rate of the audio data."]
4914 pub sample_rate: ::std::os::raw::c_int,
4915 #[doc = " AVBuffer references backing the data for this frame. All the pointers in\n data and extended_data must point inside one of the buffers in buf or\n extended_buf. This array must be filled contiguously -- if buf[i] is\n non-NULL then buf[j] must also be non-NULL for all j < i.\n\n There may be at most one AVBuffer per data plane, so for video this array\n always contains all the references. For planar audio with more than\n AV_NUM_DATA_POINTERS channels, there may be more buffers than can fit in\n this array. Then the extra AVBufferRef pointers are stored in the\n extended_buf array."]
4916 pub buf: [*mut AVBufferRef; 8usize],
4917 #[doc = " For planar audio which requires more than AV_NUM_DATA_POINTERS\n AVBufferRef pointers, this array will hold all the references which\n cannot fit into AVFrame.buf.\n\n Note that this is different from AVFrame.extended_data, which always\n contains all the pointers. This array only contains the extra pointers,\n which cannot fit into AVFrame.buf.\n\n This array is always allocated using av_malloc() by whoever constructs\n the frame. It is freed in av_frame_unref()."]
4918 pub extended_buf: *mut *mut AVBufferRef,
4919 #[doc = " Number of elements in extended_buf."]
4920 pub nb_extended_buf: ::std::os::raw::c_int,
4921 pub side_data: *mut *mut AVFrameSideData,
4922 pub nb_side_data: ::std::os::raw::c_int,
4923 #[doc = " Frame flags, a combination of @ref lavu_frame_flags"]
4924 pub flags: ::std::os::raw::c_int,
4925 #[doc = " MPEG vs JPEG YUV range.\n - encoding: Set by user\n - decoding: Set by libavcodec"]
4926 pub color_range: AVColorRange,
4927 pub color_primaries: AVColorPrimaries,
4928 pub color_trc: AVColorTransferCharacteristic,
4929 #[doc = " YUV colorspace type.\n - encoding: Set by user\n - decoding: Set by libavcodec"]
4930 pub colorspace: AVColorSpace,
4931 pub chroma_location: AVChromaLocation,
4932 #[doc = " frame timestamp estimated using various heuristics, in stream time base\n - encoding: unused\n - decoding: set by libavcodec, read by user."]
4933 pub best_effort_timestamp: i64,
4934 #[doc = " reordered pos from the last AVPacket that has been input into the decoder\n - encoding: unused\n - decoding: Read by user.\n @deprecated use AV_CODEC_FLAG_COPY_OPAQUE to pass through arbitrary user\n data from packets to frames"]
4935 pub pkt_pos: i64,
4936 #[doc = " metadata.\n - encoding: Set by user.\n - decoding: Set by libavcodec."]
4937 pub metadata: *mut AVDictionary,
4938 #[doc = " decode error flags of the frame, set to a combination of\n FF_DECODE_ERROR_xxx flags if the decoder produced a frame, but there\n were errors during the decoding.\n - encoding: unused\n - decoding: set by libavcodec, read by user."]
4939 pub decode_error_flags: ::std::os::raw::c_int,
4940 #[doc = " size of the corresponding packet containing the compressed\n frame.\n It is set to a negative value if unknown.\n - encoding: unused\n - decoding: set by libavcodec, read by user.\n @deprecated use AV_CODEC_FLAG_COPY_OPAQUE to pass through arbitrary user\n data from packets to frames"]
4941 pub pkt_size: ::std::os::raw::c_int,
4942 #[doc = " For hwaccel-format frames, this should be a reference to the\n AVHWFramesContext describing the frame."]
4943 pub hw_frames_ctx: *mut AVBufferRef,
4944 #[doc = " Frame owner's private data.\n\n This field may be set by the code that allocates/owns the frame data.\n It is then not touched by any library functions, except:\n - a new reference to the underlying buffer is propagated by\n av_frame_copy_props() (and hence by av_frame_ref());\n - it is unreferenced in av_frame_unref();\n - on the caller's explicit request. E.g. libavcodec encoders/decoders\n will propagate a new reference to/from @ref AVPacket \"AVPackets\" if the\n caller sets @ref AV_CODEC_FLAG_COPY_OPAQUE.\n\n @see opaque the plain pointer analogue"]
4945 pub opaque_ref: *mut AVBufferRef,
4946 #[doc = " @anchor cropping\n @name Cropping\n Video frames only. The number of pixels to discard from the the\n top/bottom/left/right border of the frame to obtain the sub-rectangle of\n the frame intended for presentation.\n @{"]
4947 pub crop_top: usize,
4948 pub crop_bottom: usize,
4949 pub crop_left: usize,
4950 pub crop_right: usize,
4951 #[doc = " AVBufferRef for internal use by a single libav* library.\n Must not be used to transfer data between libraries.\n Has to be NULL when ownership of the frame leaves the respective library.\n\n Code outside the FFmpeg libs should never check or change the contents of the buffer ref.\n\n FFmpeg calls av_buffer_unref() on it when the frame is unreferenced.\n av_frame_copy_props() calls create a new reference with av_buffer_ref()\n for the target frame's private_ref field."]
4952 pub private_ref: *mut AVBufferRef,
4953 #[doc = " Channel layout of the audio data."]
4954 pub ch_layout: AVChannelLayout,
4955 #[doc = " Duration of the frame, in the same units as pts. 0 if unknown."]
4956 pub duration: i64,
4957}
4958impl Default for AVFrame {
4959 fn default() -> Self {
4960 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4961 unsafe {
4962 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4963 s.assume_init()
4964 }
4965 }
4966}
4967extern "C" {
4968 #[doc = " Allocate an AVFrame and set its fields to default values. The resulting\n struct must be freed using av_frame_free().\n\n @return An AVFrame filled with default values or NULL on failure.\n\n @note this only allocates the AVFrame itself, not the data buffers. Those\n must be allocated through other means, e.g. with av_frame_get_buffer() or\n manually."]
4969 pub fn av_frame_alloc() -> *mut AVFrame;
4970}
4971extern "C" {
4972 #[doc = " Free the frame and any dynamically allocated objects in it,\n e.g. extended_data. If the frame is reference counted, it will be\n unreferenced first.\n\n @param frame frame to be freed. The pointer will be set to NULL."]
4973 pub fn av_frame_free(frame: *mut *mut AVFrame);
4974}
4975extern "C" {
4976 #[doc = " Set up a new reference to the data described by the source frame.\n\n Copy frame properties from src to dst and create a new reference for each\n AVBufferRef from src.\n\n If src is not reference counted, new buffers are allocated and the data is\n copied.\n\n @warning: dst MUST have been either unreferenced with av_frame_unref(dst),\n or newly allocated with av_frame_alloc() before calling this\n function, or undefined behavior will occur.\n\n @return 0 on success, a negative AVERROR on error"]
4977 pub fn av_frame_ref(dst: *mut AVFrame, src: *const AVFrame) -> ::std::os::raw::c_int;
4978}
4979extern "C" {
4980 #[doc = " Ensure the destination frame refers to the same data described by the source\n frame, either by creating a new reference for each AVBufferRef from src if\n they differ from those in dst, by allocating new buffers and copying data if\n src is not reference counted, or by unrefencing it if src is empty.\n\n Frame properties on dst will be replaced by those from src.\n\n @return 0 on success, a negative AVERROR on error. On error, dst is\n unreferenced."]
4981 pub fn av_frame_replace(dst: *mut AVFrame, src: *const AVFrame) -> ::std::os::raw::c_int;
4982}
4983extern "C" {
4984 #[doc = " Create a new frame that references the same data as src.\n\n This is a shortcut for av_frame_alloc()+av_frame_ref().\n\n @return newly created AVFrame on success, NULL on error."]
4985 pub fn av_frame_clone(src: *const AVFrame) -> *mut AVFrame;
4986}
4987extern "C" {
4988 #[doc = " Unreference all the buffers referenced by frame and reset the frame fields."]
4989 pub fn av_frame_unref(frame: *mut AVFrame);
4990}
4991extern "C" {
4992 #[doc = " Move everything contained in src to dst and reset src.\n\n @warning: dst is not unreferenced, but directly overwritten without reading\n or deallocating its contents. Call av_frame_unref(dst) manually\n before calling this function to ensure that no memory is leaked."]
4993 pub fn av_frame_move_ref(dst: *mut AVFrame, src: *mut AVFrame);
4994}
4995extern "C" {
4996 #[doc = " Allocate new buffer(s) for audio or video data.\n\n The following fields must be set on frame before calling this function:\n - format (pixel format for video, sample format for audio)\n - width and height for video\n - nb_samples and ch_layout for audio\n\n This function will fill AVFrame.data and AVFrame.buf arrays and, if\n necessary, allocate and fill AVFrame.extended_data and AVFrame.extended_buf.\n For planar formats, one buffer will be allocated for each plane.\n\n @warning: if frame already has been allocated, calling this function will\n leak memory. In addition, undefined behavior can occur in certain\n cases.\n\n @param frame frame in which to store the new buffers.\n @param align Required buffer size alignment. If equal to 0, alignment will be\n chosen automatically for the current CPU. It is highly\n recommended to pass 0 here unless you know what you are doing.\n\n @return 0 on success, a negative AVERROR on error."]
4997 pub fn av_frame_get_buffer(
4998 frame: *mut AVFrame,
4999 align: ::std::os::raw::c_int,
5000 ) -> ::std::os::raw::c_int;
5001}
5002extern "C" {
5003 #[doc = " Check if the frame data is writable.\n\n @return A positive value if the frame data is writable (which is true if and\n only if each of the underlying buffers has only one reference, namely the one\n stored in this frame). Return 0 otherwise.\n\n If 1 is returned the answer is valid until av_buffer_ref() is called on any\n of the underlying AVBufferRefs (e.g. through av_frame_ref() or directly).\n\n @see av_frame_make_writable(), av_buffer_is_writable()"]
5004 pub fn av_frame_is_writable(frame: *mut AVFrame) -> ::std::os::raw::c_int;
5005}
5006extern "C" {
5007 #[doc = " Ensure that the frame data is writable, avoiding data copy if possible.\n\n Do nothing if the frame is writable, allocate new buffers and copy the data\n if it is not. Non-refcounted frames behave as non-writable, i.e. a copy\n is always made.\n\n @return 0 on success, a negative AVERROR on error.\n\n @see av_frame_is_writable(), av_buffer_is_writable(),\n av_buffer_make_writable()"]
5008 pub fn av_frame_make_writable(frame: *mut AVFrame) -> ::std::os::raw::c_int;
5009}
5010extern "C" {
5011 #[doc = " Copy the frame data from src to dst.\n\n This function does not allocate anything, dst must be already initialized and\n allocated with the same parameters as src.\n\n This function only copies the frame data (i.e. the contents of the data /\n extended data arrays), not any other properties.\n\n @return >= 0 on success, a negative AVERROR on error."]
5012 pub fn av_frame_copy(dst: *mut AVFrame, src: *const AVFrame) -> ::std::os::raw::c_int;
5013}
5014extern "C" {
5015 #[doc = " Copy only \"metadata\" fields from src to dst.\n\n Metadata for the purpose of this function are those fields that do not affect\n the data layout in the buffers. E.g. pts, sample rate (for audio) or sample\n aspect ratio (for video), but not width/height or channel layout.\n Side data is also copied."]
5016 pub fn av_frame_copy_props(dst: *mut AVFrame, src: *const AVFrame) -> ::std::os::raw::c_int;
5017}
5018extern "C" {
5019 #[doc = " Get the buffer reference a given data plane is stored in.\n\n @param frame the frame to get the plane's buffer from\n @param plane index of the data plane of interest in frame->extended_data.\n\n @return the buffer reference that contains the plane or NULL if the input\n frame is not valid."]
5020 pub fn av_frame_get_plane_buffer(
5021 frame: *const AVFrame,
5022 plane: ::std::os::raw::c_int,
5023 ) -> *mut AVBufferRef;
5024}
5025extern "C" {
5026 #[doc = " Add a new side data to a frame.\n\n @param frame a frame to which the side data should be added\n @param type type of the added side data\n @param size size of the side data\n\n @return newly added side data on success, NULL on error"]
5027 pub fn av_frame_new_side_data(
5028 frame: *mut AVFrame,
5029 type_: AVFrameSideDataType,
5030 size: usize,
5031 ) -> *mut AVFrameSideData;
5032}
5033extern "C" {
5034 #[doc = " Add a new side data to a frame from an existing AVBufferRef\n\n @param frame a frame to which the side data should be added\n @param type the type of the added side data\n @param buf an AVBufferRef to add as side data. The ownership of\n the reference is transferred to the frame.\n\n @return newly added side data on success, NULL on error. On failure\n the frame is unchanged and the AVBufferRef remains owned by\n the caller."]
5035 pub fn av_frame_new_side_data_from_buf(
5036 frame: *mut AVFrame,
5037 type_: AVFrameSideDataType,
5038 buf: *mut AVBufferRef,
5039 ) -> *mut AVFrameSideData;
5040}
5041extern "C" {
5042 #[doc = " @return a pointer to the side data of a given type on success, NULL if there\n is no side data with such type in this frame."]
5043 pub fn av_frame_get_side_data(
5044 frame: *const AVFrame,
5045 type_: AVFrameSideDataType,
5046 ) -> *mut AVFrameSideData;
5047}
5048extern "C" {
5049 #[doc = " Remove and free all side data instances of the given type."]
5050 pub fn av_frame_remove_side_data(frame: *mut AVFrame, type_: AVFrameSideDataType);
5051}
5052#[doc = " Apply the maximum possible cropping, even if it requires setting the\n AVFrame.data[] entries to unaligned pointers. Passing unaligned data\n to FFmpeg API is generally not allowed, and causes undefined behavior\n (such as crashes). You can pass unaligned data only to FFmpeg APIs that\n are explicitly documented to accept it. Use this flag only if you\n absolutely know what you are doing."]
5053pub const AV_FRAME_CROP_UNALIGNED: _bindgen_ty_1 = 1;
5054#[doc = " Flags for frame cropping."]
5055pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
5056extern "C" {
5057 #[doc = " Crop the given video AVFrame according to its crop_left/crop_top/crop_right/\n crop_bottom fields. If cropping is successful, the function will adjust the\n data pointers and the width/height fields, and set the crop fields to 0.\n\n In all cases, the cropping boundaries will be rounded to the inherent\n alignment of the pixel format. In some cases, such as for opaque hwaccel\n formats, the left/top cropping is ignored. The crop fields are set to 0 even\n if the cropping was rounded or ignored.\n\n @param frame the frame which should be cropped\n @param flags Some combination of AV_FRAME_CROP_* flags, or 0.\n\n @return >= 0 on success, a negative AVERROR on error. If the cropping fields\n were invalid, AVERROR(ERANGE) is returned, and nothing is changed."]
5058 pub fn av_frame_apply_cropping(
5059 frame: *mut AVFrame,
5060 flags: ::std::os::raw::c_int,
5061 ) -> ::std::os::raw::c_int;
5062}
5063extern "C" {
5064 #[doc = " @return a string identifying the side data type"]
5065 pub fn av_frame_side_data_name(type_: AVFrameSideDataType) -> *const ::std::os::raw::c_char;
5066}
5067extern "C" {
5068 #[doc = " @return side data descriptor corresponding to a given side data type, NULL\n when not available."]
5069 pub fn av_frame_side_data_desc(type_: AVFrameSideDataType) -> *const AVSideDataDescriptor;
5070}
5071extern "C" {
5072 #[doc = " Free all side data entries and their contents, then zeroes out the\n values which the pointers are pointing to.\n\n @param sd pointer to array of side data to free. Will be set to NULL\n upon return.\n @param nb_sd pointer to an integer containing the number of entries in\n the array. Will be set to 0 upon return."]
5073 pub fn av_frame_side_data_free(
5074 sd: *mut *mut *mut AVFrameSideData,
5075 nb_sd: *mut ::std::os::raw::c_int,
5076 );
5077}
5078extern "C" {
5079 #[doc = " Add new side data entry to an array.\n\n @param sd pointer to array of side data to which to add another entry,\n or to NULL in order to start a new array.\n @param nb_sd pointer to an integer containing the number of entries in\n the array.\n @param type type of the added side data\n @param size size of the side data\n @param flags Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, or 0.\n\n @return newly added side data on success, NULL on error.\n @note In case of AV_FRAME_SIDE_DATA_FLAG_UNIQUE being set, entries of\n matching AVFrameSideDataType will be removed before the addition\n is attempted.\n @note In case of AV_FRAME_SIDE_DATA_FLAG_REPLACE being set, if an\n entry of the same type already exists, it will be replaced instead."]
5080 pub fn av_frame_side_data_new(
5081 sd: *mut *mut *mut AVFrameSideData,
5082 nb_sd: *mut ::std::os::raw::c_int,
5083 type_: AVFrameSideDataType,
5084 size: usize,
5085 flags: ::std::os::raw::c_uint,
5086 ) -> *mut AVFrameSideData;
5087}
5088extern "C" {
5089 #[doc = " Add a new side data entry to an array from an existing AVBufferRef.\n\n @param sd pointer to array of side data to which to add another entry,\n or to NULL in order to start a new array.\n @param nb_sd pointer to an integer containing the number of entries in\n the array.\n @param type type of the added side data\n @param buf Pointer to AVBufferRef to add to the array. On success,\n the function takes ownership of the AVBufferRef and *buf is\n set to NULL, unless AV_FRAME_SIDE_DATA_FLAG_NEW_REF is set\n in which case the ownership will remain with the caller.\n @param flags Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, or 0.\n\n @return newly added side data on success, NULL on error.\n @note In case of AV_FRAME_SIDE_DATA_FLAG_UNIQUE being set, entries of\n matching AVFrameSideDataType will be removed before the addition\n is attempted.\n @note In case of AV_FRAME_SIDE_DATA_FLAG_REPLACE being set, if an\n entry of the same type already exists, it will be replaced instead.\n"]
5090 pub fn av_frame_side_data_add(
5091 sd: *mut *mut *mut AVFrameSideData,
5092 nb_sd: *mut ::std::os::raw::c_int,
5093 type_: AVFrameSideDataType,
5094 buf: *mut *mut AVBufferRef,
5095 flags: ::std::os::raw::c_uint,
5096 ) -> *mut AVFrameSideData;
5097}
5098extern "C" {
5099 #[doc = " Add a new side data entry to an array based on existing side data, taking\n a reference towards the contained AVBufferRef.\n\n @param sd pointer to array of side data to which to add another entry,\n or to NULL in order to start a new array.\n @param nb_sd pointer to an integer containing the number of entries in\n the array.\n @param src side data to be cloned, with a new reference utilized\n for the buffer.\n @param flags Some combination of AV_FRAME_SIDE_DATA_FLAG_* flags, or 0.\n\n @return negative error code on failure, >=0 on success.\n @note In case of AV_FRAME_SIDE_DATA_FLAG_UNIQUE being set, entries of\n matching AVFrameSideDataType will be removed before the addition\n is attempted.\n @note In case of AV_FRAME_SIDE_DATA_FLAG_REPLACE being set, if an\n entry of the same type already exists, it will be replaced instead."]
5100 pub fn av_frame_side_data_clone(
5101 sd: *mut *mut *mut AVFrameSideData,
5102 nb_sd: *mut ::std::os::raw::c_int,
5103 src: *const AVFrameSideData,
5104 flags: ::std::os::raw::c_uint,
5105 ) -> ::std::os::raw::c_int;
5106}
5107extern "C" {
5108 #[doc = " Get a side data entry of a specific type from an array.\n\n @param sd array of side data.\n @param nb_sd integer containing the number of entries in the array.\n @param type type of side data to be queried\n\n @return a pointer to the side data of a given type on success, NULL if there\n is no side data with such type in this set."]
5109 pub fn av_frame_side_data_get_c(
5110 sd: *const *const AVFrameSideData,
5111 nb_sd: ::std::os::raw::c_int,
5112 type_: AVFrameSideDataType,
5113 ) -> *const AVFrameSideData;
5114}
5115extern "C" {
5116 #[doc = " Remove and free all side data instances of the given type from an array."]
5117 pub fn av_frame_side_data_remove(
5118 sd: *mut *mut *mut AVFrameSideData,
5119 nb_sd: *mut ::std::os::raw::c_int,
5120 type_: AVFrameSideDataType,
5121 );
5122}
5123pub const AVHWDeviceType_AV_HWDEVICE_TYPE_NONE: AVHWDeviceType = 0;
5124pub const AVHWDeviceType_AV_HWDEVICE_TYPE_VDPAU: AVHWDeviceType = 1;
5125pub const AVHWDeviceType_AV_HWDEVICE_TYPE_CUDA: AVHWDeviceType = 2;
5126pub const AVHWDeviceType_AV_HWDEVICE_TYPE_VAAPI: AVHWDeviceType = 3;
5127pub const AVHWDeviceType_AV_HWDEVICE_TYPE_DXVA2: AVHWDeviceType = 4;
5128pub const AVHWDeviceType_AV_HWDEVICE_TYPE_QSV: AVHWDeviceType = 5;
5129pub const AVHWDeviceType_AV_HWDEVICE_TYPE_VIDEOTOOLBOX: AVHWDeviceType = 6;
5130pub const AVHWDeviceType_AV_HWDEVICE_TYPE_D3D11VA: AVHWDeviceType = 7;
5131pub const AVHWDeviceType_AV_HWDEVICE_TYPE_DRM: AVHWDeviceType = 8;
5132pub const AVHWDeviceType_AV_HWDEVICE_TYPE_OPENCL: AVHWDeviceType = 9;
5133pub const AVHWDeviceType_AV_HWDEVICE_TYPE_MEDIACODEC: AVHWDeviceType = 10;
5134pub const AVHWDeviceType_AV_HWDEVICE_TYPE_VULKAN: AVHWDeviceType = 11;
5135pub const AVHWDeviceType_AV_HWDEVICE_TYPE_D3D12VA: AVHWDeviceType = 12;
5136pub type AVHWDeviceType = ::std::os::raw::c_uint;
5137#[doc = " This struct aggregates all the (hardware/vendor-specific) \"high-level\" state,\n i.e. state that is not tied to a concrete processing configuration.\n E.g., in an API that supports hardware-accelerated encoding and decoding,\n this struct will (if possible) wrap the state that is common to both encoding\n and decoding and from which specific instances of encoders or decoders can be\n derived.\n\n This struct is reference-counted with the AVBuffer mechanism. The\n av_hwdevice_ctx_alloc() constructor yields a reference, whose data field\n points to the actual AVHWDeviceContext. Further objects derived from\n AVHWDeviceContext (such as AVHWFramesContext, describing a frame pool with\n specific properties) will hold an internal reference to it. After all the\n references are released, the AVHWDeviceContext itself will be freed,\n optionally invoking a user-specified callback for uninitializing the hardware\n state."]
5138#[repr(C)]
5139#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5140pub struct AVHWDeviceContext {
5141 #[doc = " A class for logging. Set by av_hwdevice_ctx_alloc()."]
5142 pub av_class: *const AVClass,
5143 #[doc = " This field identifies the underlying API used for hardware access.\n\n This field is set when this struct is allocated and never changed\n afterwards."]
5144 pub type_: AVHWDeviceType,
5145 #[doc = " The format-specific data, allocated and freed by libavutil along with\n this context.\n\n Should be cast by the user to the format-specific context defined in the\n corresponding header (hwcontext_*.h) and filled as described in the\n documentation before calling av_hwdevice_ctx_init().\n\n After calling av_hwdevice_ctx_init() this struct should not be modified\n by the caller."]
5146 pub hwctx: *mut ::std::os::raw::c_void,
5147 #[doc = " This field may be set by the caller before calling av_hwdevice_ctx_init().\n\n If non-NULL, this callback will be called when the last reference to\n this context is unreferenced, immediately before it is freed.\n\n @note when other objects (e.g an AVHWFramesContext) are derived from this\n struct, this callback will be invoked after all such child objects\n are fully uninitialized and their respective destructors invoked."]
5148 pub free: ::std::option::Option<unsafe extern "C" fn(ctx: *mut AVHWDeviceContext)>,
5149 #[doc = " Arbitrary user data, to be used e.g. by the free() callback."]
5150 pub user_opaque: *mut ::std::os::raw::c_void,
5151}
5152impl Default for AVHWDeviceContext {
5153 fn default() -> Self {
5154 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5155 unsafe {
5156 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5157 s.assume_init()
5158 }
5159 }
5160}
5161#[doc = " This struct describes a set or pool of \"hardware\" frames (i.e. those with\n data not located in normal system memory). All the frames in the pool are\n assumed to be allocated in the same way and interchangeable.\n\n This struct is reference-counted with the AVBuffer mechanism and tied to a\n given AVHWDeviceContext instance. The av_hwframe_ctx_alloc() constructor\n yields a reference, whose data field points to the actual AVHWFramesContext\n struct."]
5162#[repr(C)]
5163#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5164pub struct AVHWFramesContext {
5165 #[doc = " A class for logging."]
5166 pub av_class: *const AVClass,
5167 #[doc = " A reference to the parent AVHWDeviceContext. This reference is owned and\n managed by the enclosing AVHWFramesContext, but the caller may derive\n additional references from it."]
5168 pub device_ref: *mut AVBufferRef,
5169 #[doc = " The parent AVHWDeviceContext. This is simply a pointer to\n device_ref->data provided for convenience.\n\n Set by libavutil in av_hwframe_ctx_init()."]
5170 pub device_ctx: *mut AVHWDeviceContext,
5171 #[doc = " The format-specific data, allocated and freed automatically along with\n this context.\n\n The user shall ignore this field if the corresponding format-specific\n header (hwcontext_*.h) does not define a context to be used as\n AVHWFramesContext.hwctx.\n\n Otherwise, it should be cast by the user to said context and filled\n as described in the documentation before calling av_hwframe_ctx_init().\n\n After any frames using this context are created, the contents of this\n struct should not be modified by the caller."]
5172 pub hwctx: *mut ::std::os::raw::c_void,
5173 #[doc = " This field may be set by the caller before calling av_hwframe_ctx_init().\n\n If non-NULL, this callback will be called when the last reference to\n this context is unreferenced, immediately before it is freed."]
5174 pub free: ::std::option::Option<unsafe extern "C" fn(ctx: *mut AVHWFramesContext)>,
5175 #[doc = " Arbitrary user data, to be used e.g. by the free() callback."]
5176 pub user_opaque: *mut ::std::os::raw::c_void,
5177 #[doc = " A pool from which the frames are allocated by av_hwframe_get_buffer().\n This field may be set by the caller before calling av_hwframe_ctx_init().\n The buffers returned by calling av_buffer_pool_get() on this pool must\n have the properties described in the documentation in the corresponding hw\n type's header (hwcontext_*.h). The pool will be freed strictly before\n this struct's free() callback is invoked.\n\n This field may be NULL, then libavutil will attempt to allocate a pool\n internally. Note that certain device types enforce pools allocated at\n fixed size (frame count), which cannot be extended dynamically. In such a\n case, initial_pool_size must be set appropriately."]
5178 pub pool: *mut AVBufferPool,
5179 #[doc = " Initial size of the frame pool. If a device type does not support\n dynamically resizing the pool, then this is also the maximum pool size.\n\n May be set by the caller before calling av_hwframe_ctx_init(). Must be\n set if pool is NULL and the device type does not support dynamic pools."]
5180 pub initial_pool_size: ::std::os::raw::c_int,
5181 #[doc = " The pixel format identifying the underlying HW surface type.\n\n Must be a hwaccel format, i.e. the corresponding descriptor must have the\n AV_PIX_FMT_FLAG_HWACCEL flag set.\n\n Must be set by the user before calling av_hwframe_ctx_init()."]
5182 pub format: AVPixelFormat,
5183 #[doc = " The pixel format identifying the actual data layout of the hardware\n frames.\n\n Must be set by the caller before calling av_hwframe_ctx_init().\n\n @note when the underlying API does not provide the exact data layout, but\n only the colorspace/bit depth, this field should be set to the fully\n planar version of that format (e.g. for 8-bit 420 YUV it should be\n AV_PIX_FMT_YUV420P, not AV_PIX_FMT_NV12 or anything else)."]
5184 pub sw_format: AVPixelFormat,
5185 #[doc = " The allocated dimensions of the frames in this pool.\n\n Must be set by the user before calling av_hwframe_ctx_init()."]
5186 pub width: ::std::os::raw::c_int,
5187 #[doc = " The allocated dimensions of the frames in this pool.\n\n Must be set by the user before calling av_hwframe_ctx_init()."]
5188 pub height: ::std::os::raw::c_int,
5189}
5190impl Default for AVHWFramesContext {
5191 fn default() -> Self {
5192 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5193 unsafe {
5194 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5195 s.assume_init()
5196 }
5197 }
5198}
5199extern "C" {
5200 #[doc = " Look up an AVHWDeviceType by name.\n\n @param name String name of the device type (case-insensitive).\n @return The type from enum AVHWDeviceType, or AV_HWDEVICE_TYPE_NONE if\n not found."]
5201 pub fn av_hwdevice_find_type_by_name(name: *const ::std::os::raw::c_char) -> AVHWDeviceType;
5202}
5203extern "C" {
5204 #[doc = " Get the string name of an AVHWDeviceType.\n\n @param type Type from enum AVHWDeviceType.\n @return Pointer to a static string containing the name, or NULL if the type\n is not valid."]
5205 pub fn av_hwdevice_get_type_name(type_: AVHWDeviceType) -> *const ::std::os::raw::c_char;
5206}
5207extern "C" {
5208 #[doc = " Iterate over supported device types.\n\n @param prev AV_HWDEVICE_TYPE_NONE initially, then the previous type\n returned by this function in subsequent iterations.\n @return The next usable device type from enum AVHWDeviceType, or\n AV_HWDEVICE_TYPE_NONE if there are no more."]
5209 pub fn av_hwdevice_iterate_types(prev: AVHWDeviceType) -> AVHWDeviceType;
5210}
5211extern "C" {
5212 #[doc = " Allocate an AVHWDeviceContext for a given hardware type.\n\n @param type the type of the hardware device to allocate.\n @return a reference to the newly created AVHWDeviceContext on success or NULL\n on failure."]
5213 pub fn av_hwdevice_ctx_alloc(type_: AVHWDeviceType) -> *mut AVBufferRef;
5214}
5215extern "C" {
5216 #[doc = " Finalize the device context before use. This function must be called after\n the context is filled with all the required information and before it is\n used in any way.\n\n @param ref a reference to the AVHWDeviceContext\n @return 0 on success, a negative AVERROR code on failure"]
5217 pub fn av_hwdevice_ctx_init(ref_: *mut AVBufferRef) -> ::std::os::raw::c_int;
5218}
5219extern "C" {
5220 #[doc = " Open a device of the specified type and create an AVHWDeviceContext for it.\n\n This is a convenience function intended to cover the simple cases. Callers\n who need to fine-tune device creation/management should open the device\n manually and then wrap it in an AVHWDeviceContext using\n av_hwdevice_ctx_alloc()/av_hwdevice_ctx_init().\n\n The returned context is already initialized and ready for use, the caller\n should not call av_hwdevice_ctx_init() on it. The user_opaque/free fields of\n the created AVHWDeviceContext are set by this function and should not be\n touched by the caller.\n\n @param device_ctx On success, a reference to the newly-created device context\n will be written here. The reference is owned by the caller\n and must be released with av_buffer_unref() when no longer\n needed. On failure, NULL will be written to this pointer.\n @param type The type of the device to create.\n @param device A type-specific string identifying the device to open.\n @param opts A dictionary of additional (type-specific) options to use in\n opening the device. The dictionary remains owned by the caller.\n @param flags currently unused\n\n @return 0 on success, a negative AVERROR code on failure."]
5221 pub fn av_hwdevice_ctx_create(
5222 device_ctx: *mut *mut AVBufferRef,
5223 type_: AVHWDeviceType,
5224 device: *const ::std::os::raw::c_char,
5225 opts: *mut AVDictionary,
5226 flags: ::std::os::raw::c_int,
5227 ) -> ::std::os::raw::c_int;
5228}
5229extern "C" {
5230 #[doc = " Create a new device of the specified type from an existing device.\n\n If the source device is a device of the target type or was originally\n derived from such a device (possibly through one or more intermediate\n devices of other types), then this will return a reference to the\n existing device of the same type as is requested.\n\n Otherwise, it will attempt to derive a new device from the given source\n device. If direct derivation to the new type is not implemented, it will\n attempt the same derivation from each ancestor of the source device in\n turn looking for an implemented derivation method.\n\n @param dst_ctx On success, a reference to the newly-created\n AVHWDeviceContext.\n @param type The type of the new device to create.\n @param src_ctx A reference to an existing AVHWDeviceContext which will be\n used to create the new device.\n @param flags Currently unused; should be set to zero.\n @return Zero on success, a negative AVERROR code on failure."]
5231 pub fn av_hwdevice_ctx_create_derived(
5232 dst_ctx: *mut *mut AVBufferRef,
5233 type_: AVHWDeviceType,
5234 src_ctx: *mut AVBufferRef,
5235 flags: ::std::os::raw::c_int,
5236 ) -> ::std::os::raw::c_int;
5237}
5238extern "C" {
5239 #[doc = " Create a new device of the specified type from an existing device.\n\n This function performs the same action as av_hwdevice_ctx_create_derived,\n however, it is able to set options for the new device to be derived.\n\n @param dst_ctx On success, a reference to the newly-created\n AVHWDeviceContext.\n @param type The type of the new device to create.\n @param src_ctx A reference to an existing AVHWDeviceContext which will be\n used to create the new device.\n @param options Options for the new device to create, same format as in\n av_hwdevice_ctx_create.\n @param flags Currently unused; should be set to zero.\n @return Zero on success, a negative AVERROR code on failure."]
5240 pub fn av_hwdevice_ctx_create_derived_opts(
5241 dst_ctx: *mut *mut AVBufferRef,
5242 type_: AVHWDeviceType,
5243 src_ctx: *mut AVBufferRef,
5244 options: *mut AVDictionary,
5245 flags: ::std::os::raw::c_int,
5246 ) -> ::std::os::raw::c_int;
5247}
5248extern "C" {
5249 #[doc = " Allocate an AVHWFramesContext tied to a given device context.\n\n @param device_ctx a reference to a AVHWDeviceContext. This function will make\n a new reference for internal use, the one passed to the\n function remains owned by the caller.\n @return a reference to the newly created AVHWFramesContext on success or NULL\n on failure."]
5250 pub fn av_hwframe_ctx_alloc(device_ctx: *mut AVBufferRef) -> *mut AVBufferRef;
5251}
5252extern "C" {
5253 #[doc = " Finalize the context before use. This function must be called after the\n context is filled with all the required information and before it is attached\n to any frames.\n\n @param ref a reference to the AVHWFramesContext\n @return 0 on success, a negative AVERROR code on failure"]
5254 pub fn av_hwframe_ctx_init(ref_: *mut AVBufferRef) -> ::std::os::raw::c_int;
5255}
5256extern "C" {
5257 #[doc = " Allocate a new frame attached to the given AVHWFramesContext.\n\n @param hwframe_ctx a reference to an AVHWFramesContext\n @param frame an empty (freshly allocated or unreffed) frame to be filled with\n newly allocated buffers.\n @param flags currently unused, should be set to zero\n @return 0 on success, a negative AVERROR code on failure"]
5258 pub fn av_hwframe_get_buffer(
5259 hwframe_ctx: *mut AVBufferRef,
5260 frame: *mut AVFrame,
5261 flags: ::std::os::raw::c_int,
5262 ) -> ::std::os::raw::c_int;
5263}
5264extern "C" {
5265 #[doc = " Copy data to or from a hw surface. At least one of dst/src must have an\n AVHWFramesContext attached.\n\n If src has an AVHWFramesContext attached, then the format of dst (if set)\n must use one of the formats returned by av_hwframe_transfer_get_formats(src,\n AV_HWFRAME_TRANSFER_DIRECTION_FROM).\n If dst has an AVHWFramesContext attached, then the format of src must use one\n of the formats returned by av_hwframe_transfer_get_formats(dst,\n AV_HWFRAME_TRANSFER_DIRECTION_TO)\n\n dst may be \"clean\" (i.e. with data/buf pointers unset), in which case the\n data buffers will be allocated by this function using av_frame_get_buffer().\n If dst->format is set, then this format will be used, otherwise (when\n dst->format is AV_PIX_FMT_NONE) the first acceptable format will be chosen.\n\n The two frames must have matching allocated dimensions (i.e. equal to\n AVHWFramesContext.width/height), since not all device types support\n transferring a sub-rectangle of the whole surface. The display dimensions\n (i.e. AVFrame.width/height) may be smaller than the allocated dimensions, but\n also have to be equal for both frames. When the display dimensions are\n smaller than the allocated dimensions, the content of the padding in the\n destination frame is unspecified.\n\n @param dst the destination frame. dst is not touched on failure.\n @param src the source frame.\n @param flags currently unused, should be set to zero\n @return 0 on success, a negative AVERROR error code on failure."]
5266 pub fn av_hwframe_transfer_data(
5267 dst: *mut AVFrame,
5268 src: *const AVFrame,
5269 flags: ::std::os::raw::c_int,
5270 ) -> ::std::os::raw::c_int;
5271}
5272#[doc = " Transfer the data from the queried hw frame."]
5273pub const AVHWFrameTransferDirection_AV_HWFRAME_TRANSFER_DIRECTION_FROM:
5274 AVHWFrameTransferDirection = 0;
5275#[doc = " Transfer the data to the queried hw frame."]
5276pub const AVHWFrameTransferDirection_AV_HWFRAME_TRANSFER_DIRECTION_TO: AVHWFrameTransferDirection =
5277 1;
5278pub type AVHWFrameTransferDirection = ::std::os::raw::c_uint;
5279extern "C" {
5280 #[doc = " Get a list of possible source or target formats usable in\n av_hwframe_transfer_data().\n\n @param hwframe_ctx the frame context to obtain the information for\n @param dir the direction of the transfer\n @param formats the pointer to the output format list will be written here.\n The list is terminated with AV_PIX_FMT_NONE and must be freed\n by the caller when no longer needed using av_free().\n If this function returns successfully, the format list will\n have at least one item (not counting the terminator).\n On failure, the contents of this pointer are unspecified.\n @param flags currently unused, should be set to zero\n @return 0 on success, a negative AVERROR code on failure."]
5281 pub fn av_hwframe_transfer_get_formats(
5282 hwframe_ctx: *mut AVBufferRef,
5283 dir: AVHWFrameTransferDirection,
5284 formats: *mut *mut AVPixelFormat,
5285 flags: ::std::os::raw::c_int,
5286 ) -> ::std::os::raw::c_int;
5287}
5288#[doc = " This struct describes the constraints on hardware frames attached to\n a given device with a hardware-specific configuration. This is returned\n by av_hwdevice_get_hwframe_constraints() and must be freed by\n av_hwframe_constraints_free() after use."]
5289#[repr(C)]
5290#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5291pub struct AVHWFramesConstraints {
5292 #[doc = " A list of possible values for format in the hw_frames_ctx,\n terminated by AV_PIX_FMT_NONE. This member will always be filled."]
5293 pub valid_hw_formats: *mut AVPixelFormat,
5294 #[doc = " A list of possible values for sw_format in the hw_frames_ctx,\n terminated by AV_PIX_FMT_NONE. Can be NULL if this information is\n not known."]
5295 pub valid_sw_formats: *mut AVPixelFormat,
5296 #[doc = " The minimum size of frames in this hw_frames_ctx.\n (Zero if not known.)"]
5297 pub min_width: ::std::os::raw::c_int,
5298 pub min_height: ::std::os::raw::c_int,
5299 #[doc = " The maximum size of frames in this hw_frames_ctx.\n (INT_MAX if not known / no limit.)"]
5300 pub max_width: ::std::os::raw::c_int,
5301 pub max_height: ::std::os::raw::c_int,
5302}
5303impl Default for AVHWFramesConstraints {
5304 fn default() -> Self {
5305 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5306 unsafe {
5307 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5308 s.assume_init()
5309 }
5310 }
5311}
5312extern "C" {
5313 #[doc = " Allocate a HW-specific configuration structure for a given HW device.\n After use, the user must free all members as required by the specific\n hardware structure being used, then free the structure itself with\n av_free().\n\n @param device_ctx a reference to the associated AVHWDeviceContext.\n @return The newly created HW-specific configuration structure on\n success or NULL on failure."]
5314 pub fn av_hwdevice_hwconfig_alloc(device_ctx: *mut AVBufferRef) -> *mut ::std::os::raw::c_void;
5315}
5316extern "C" {
5317 #[doc = " Get the constraints on HW frames given a device and the HW-specific\n configuration to be used with that device. If no HW-specific\n configuration is provided, returns the maximum possible capabilities\n of the device.\n\n @param ref a reference to the associated AVHWDeviceContext.\n @param hwconfig a filled HW-specific configuration structure, or NULL\n to return the maximum possible capabilities of the device.\n @return AVHWFramesConstraints structure describing the constraints\n on the device, or NULL if not available."]
5318 pub fn av_hwdevice_get_hwframe_constraints(
5319 ref_: *mut AVBufferRef,
5320 hwconfig: *const ::std::os::raw::c_void,
5321 ) -> *mut AVHWFramesConstraints;
5322}
5323extern "C" {
5324 #[doc = " Free an AVHWFrameConstraints structure.\n\n @param constraints The (filled or unfilled) AVHWFrameConstraints structure."]
5325 pub fn av_hwframe_constraints_free(constraints: *mut *mut AVHWFramesConstraints);
5326}
5327#[doc = " The mapping must be readable."]
5328pub const AV_HWFRAME_MAP_READ: _bindgen_ty_2 = 1;
5329#[doc = " The mapping must be writeable."]
5330pub const AV_HWFRAME_MAP_WRITE: _bindgen_ty_2 = 2;
5331#[doc = " The mapped frame will be overwritten completely in subsequent\n operations, so the current frame data need not be loaded. Any values\n which are not overwritten are unspecified."]
5332pub const AV_HWFRAME_MAP_OVERWRITE: _bindgen_ty_2 = 4;
5333#[doc = " The mapping must be direct. That is, there must not be any copying in\n the map or unmap steps. Note that performance of direct mappings may\n be much lower than normal memory."]
5334pub const AV_HWFRAME_MAP_DIRECT: _bindgen_ty_2 = 8;
5335#[doc = " Flags to apply to frame mappings."]
5336pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
5337extern "C" {
5338 #[doc = " Map a hardware frame.\n\n This has a number of different possible effects, depending on the format\n and origin of the src and dst frames. On input, src should be a usable\n frame with valid buffers and dst should be blank (typically as just created\n by av_frame_alloc()). src should have an associated hwframe context, and\n dst may optionally have a format and associated hwframe context.\n\n If src was created by mapping a frame from the hwframe context of dst,\n then this function undoes the mapping - dst is replaced by a reference to\n the frame that src was originally mapped from.\n\n If both src and dst have an associated hwframe context, then this function\n attempts to map the src frame from its hardware context to that of dst and\n then fill dst with appropriate data to be usable there. This will only be\n possible if the hwframe contexts and associated devices are compatible -\n given compatible devices, av_hwframe_ctx_create_derived() can be used to\n create a hwframe context for dst in which mapping should be possible.\n\n If src has a hwframe context but dst does not, then the src frame is\n mapped to normal memory and should thereafter be usable as a normal frame.\n If the format is set on dst, then the mapping will attempt to create dst\n with that format and fail if it is not possible. If format is unset (is\n AV_PIX_FMT_NONE) then dst will be mapped with whatever the most appropriate\n format to use is (probably the sw_format of the src hwframe context).\n\n A return value of AVERROR(ENOSYS) indicates that the mapping is not\n possible with the given arguments and hwframe setup, while other return\n values indicate that it failed somehow.\n\n On failure, the destination frame will be left blank, except for the\n hw_frames_ctx/format fields thay may have been set by the caller - those will\n be preserved as they were.\n\n @param dst Destination frame, to contain the mapping.\n @param src Source frame, to be mapped.\n @param flags Some combination of AV_HWFRAME_MAP_* flags.\n @return Zero on success, negative AVERROR code on failure."]
5339 pub fn av_hwframe_map(
5340 dst: *mut AVFrame,
5341 src: *const AVFrame,
5342 flags: ::std::os::raw::c_int,
5343 ) -> ::std::os::raw::c_int;
5344}
5345extern "C" {
5346 #[doc = " Create and initialise an AVHWFramesContext as a mapping of another existing\n AVHWFramesContext on a different device.\n\n av_hwframe_ctx_init() should not be called after this.\n\n @param derived_frame_ctx On success, a reference to the newly created\n AVHWFramesContext.\n @param format The AVPixelFormat for the derived context.\n @param derived_device_ctx A reference to the device to create the new\n AVHWFramesContext on.\n @param source_frame_ctx A reference to an existing AVHWFramesContext\n which will be mapped to the derived context.\n @param flags Some combination of AV_HWFRAME_MAP_* flags, defining the\n mapping parameters to apply to frames which are allocated\n in the derived device.\n @return Zero on success, negative AVERROR code on failure."]
5347 pub fn av_hwframe_ctx_create_derived(
5348 derived_frame_ctx: *mut *mut AVBufferRef,
5349 format: AVPixelFormat,
5350 derived_device_ctx: *mut AVBufferRef,
5351 source_frame_ctx: *mut AVBufferRef,
5352 flags: ::std::os::raw::c_int,
5353 ) -> ::std::os::raw::c_int;
5354}
5355pub const AVCodecID_AV_CODEC_ID_NONE: AVCodecID = 0;
5356pub const AVCodecID_AV_CODEC_ID_MPEG1VIDEO: AVCodecID = 1;
5357#[doc = "< preferred ID for MPEG-1/2 video decoding"]
5358pub const AVCodecID_AV_CODEC_ID_MPEG2VIDEO: AVCodecID = 2;
5359pub const AVCodecID_AV_CODEC_ID_H261: AVCodecID = 3;
5360pub const AVCodecID_AV_CODEC_ID_H263: AVCodecID = 4;
5361pub const AVCodecID_AV_CODEC_ID_RV10: AVCodecID = 5;
5362pub const AVCodecID_AV_CODEC_ID_RV20: AVCodecID = 6;
5363pub const AVCodecID_AV_CODEC_ID_MJPEG: AVCodecID = 7;
5364pub const AVCodecID_AV_CODEC_ID_MJPEGB: AVCodecID = 8;
5365pub const AVCodecID_AV_CODEC_ID_LJPEG: AVCodecID = 9;
5366pub const AVCodecID_AV_CODEC_ID_SP5X: AVCodecID = 10;
5367pub const AVCodecID_AV_CODEC_ID_JPEGLS: AVCodecID = 11;
5368pub const AVCodecID_AV_CODEC_ID_MPEG4: AVCodecID = 12;
5369pub const AVCodecID_AV_CODEC_ID_RAWVIDEO: AVCodecID = 13;
5370pub const AVCodecID_AV_CODEC_ID_MSMPEG4V1: AVCodecID = 14;
5371pub const AVCodecID_AV_CODEC_ID_MSMPEG4V2: AVCodecID = 15;
5372pub const AVCodecID_AV_CODEC_ID_MSMPEG4V3: AVCodecID = 16;
5373pub const AVCodecID_AV_CODEC_ID_WMV1: AVCodecID = 17;
5374pub const AVCodecID_AV_CODEC_ID_WMV2: AVCodecID = 18;
5375pub const AVCodecID_AV_CODEC_ID_H263P: AVCodecID = 19;
5376pub const AVCodecID_AV_CODEC_ID_H263I: AVCodecID = 20;
5377pub const AVCodecID_AV_CODEC_ID_FLV1: AVCodecID = 21;
5378pub const AVCodecID_AV_CODEC_ID_SVQ1: AVCodecID = 22;
5379pub const AVCodecID_AV_CODEC_ID_SVQ3: AVCodecID = 23;
5380pub const AVCodecID_AV_CODEC_ID_DVVIDEO: AVCodecID = 24;
5381pub const AVCodecID_AV_CODEC_ID_HUFFYUV: AVCodecID = 25;
5382pub const AVCodecID_AV_CODEC_ID_CYUV: AVCodecID = 26;
5383pub const AVCodecID_AV_CODEC_ID_H264: AVCodecID = 27;
5384pub const AVCodecID_AV_CODEC_ID_INDEO3: AVCodecID = 28;
5385pub const AVCodecID_AV_CODEC_ID_VP3: AVCodecID = 29;
5386pub const AVCodecID_AV_CODEC_ID_THEORA: AVCodecID = 30;
5387pub const AVCodecID_AV_CODEC_ID_ASV1: AVCodecID = 31;
5388pub const AVCodecID_AV_CODEC_ID_ASV2: AVCodecID = 32;
5389pub const AVCodecID_AV_CODEC_ID_FFV1: AVCodecID = 33;
5390pub const AVCodecID_AV_CODEC_ID_4XM: AVCodecID = 34;
5391pub const AVCodecID_AV_CODEC_ID_VCR1: AVCodecID = 35;
5392pub const AVCodecID_AV_CODEC_ID_CLJR: AVCodecID = 36;
5393pub const AVCodecID_AV_CODEC_ID_MDEC: AVCodecID = 37;
5394pub const AVCodecID_AV_CODEC_ID_ROQ: AVCodecID = 38;
5395pub const AVCodecID_AV_CODEC_ID_INTERPLAY_VIDEO: AVCodecID = 39;
5396pub const AVCodecID_AV_CODEC_ID_XAN_WC3: AVCodecID = 40;
5397pub const AVCodecID_AV_CODEC_ID_XAN_WC4: AVCodecID = 41;
5398pub const AVCodecID_AV_CODEC_ID_RPZA: AVCodecID = 42;
5399pub const AVCodecID_AV_CODEC_ID_CINEPAK: AVCodecID = 43;
5400pub const AVCodecID_AV_CODEC_ID_WS_VQA: AVCodecID = 44;
5401pub const AVCodecID_AV_CODEC_ID_MSRLE: AVCodecID = 45;
5402pub const AVCodecID_AV_CODEC_ID_MSVIDEO1: AVCodecID = 46;
5403pub const AVCodecID_AV_CODEC_ID_IDCIN: AVCodecID = 47;
5404pub const AVCodecID_AV_CODEC_ID_8BPS: AVCodecID = 48;
5405pub const AVCodecID_AV_CODEC_ID_SMC: AVCodecID = 49;
5406pub const AVCodecID_AV_CODEC_ID_FLIC: AVCodecID = 50;
5407pub const AVCodecID_AV_CODEC_ID_TRUEMOTION1: AVCodecID = 51;
5408pub const AVCodecID_AV_CODEC_ID_VMDVIDEO: AVCodecID = 52;
5409pub const AVCodecID_AV_CODEC_ID_MSZH: AVCodecID = 53;
5410pub const AVCodecID_AV_CODEC_ID_ZLIB: AVCodecID = 54;
5411pub const AVCodecID_AV_CODEC_ID_QTRLE: AVCodecID = 55;
5412pub const AVCodecID_AV_CODEC_ID_TSCC: AVCodecID = 56;
5413pub const AVCodecID_AV_CODEC_ID_ULTI: AVCodecID = 57;
5414pub const AVCodecID_AV_CODEC_ID_QDRAW: AVCodecID = 58;
5415pub const AVCodecID_AV_CODEC_ID_VIXL: AVCodecID = 59;
5416pub const AVCodecID_AV_CODEC_ID_QPEG: AVCodecID = 60;
5417pub const AVCodecID_AV_CODEC_ID_PNG: AVCodecID = 61;
5418pub const AVCodecID_AV_CODEC_ID_PPM: AVCodecID = 62;
5419pub const AVCodecID_AV_CODEC_ID_PBM: AVCodecID = 63;
5420pub const AVCodecID_AV_CODEC_ID_PGM: AVCodecID = 64;
5421pub const AVCodecID_AV_CODEC_ID_PGMYUV: AVCodecID = 65;
5422pub const AVCodecID_AV_CODEC_ID_PAM: AVCodecID = 66;
5423pub const AVCodecID_AV_CODEC_ID_FFVHUFF: AVCodecID = 67;
5424pub const AVCodecID_AV_CODEC_ID_RV30: AVCodecID = 68;
5425pub const AVCodecID_AV_CODEC_ID_RV40: AVCodecID = 69;
5426pub const AVCodecID_AV_CODEC_ID_VC1: AVCodecID = 70;
5427pub const AVCodecID_AV_CODEC_ID_WMV3: AVCodecID = 71;
5428pub const AVCodecID_AV_CODEC_ID_LOCO: AVCodecID = 72;
5429pub const AVCodecID_AV_CODEC_ID_WNV1: AVCodecID = 73;
5430pub const AVCodecID_AV_CODEC_ID_AASC: AVCodecID = 74;
5431pub const AVCodecID_AV_CODEC_ID_INDEO2: AVCodecID = 75;
5432pub const AVCodecID_AV_CODEC_ID_FRAPS: AVCodecID = 76;
5433pub const AVCodecID_AV_CODEC_ID_TRUEMOTION2: AVCodecID = 77;
5434pub const AVCodecID_AV_CODEC_ID_BMP: AVCodecID = 78;
5435pub const AVCodecID_AV_CODEC_ID_CSCD: AVCodecID = 79;
5436pub const AVCodecID_AV_CODEC_ID_MMVIDEO: AVCodecID = 80;
5437pub const AVCodecID_AV_CODEC_ID_ZMBV: AVCodecID = 81;
5438pub const AVCodecID_AV_CODEC_ID_AVS: AVCodecID = 82;
5439pub const AVCodecID_AV_CODEC_ID_SMACKVIDEO: AVCodecID = 83;
5440pub const AVCodecID_AV_CODEC_ID_NUV: AVCodecID = 84;
5441pub const AVCodecID_AV_CODEC_ID_KMVC: AVCodecID = 85;
5442pub const AVCodecID_AV_CODEC_ID_FLASHSV: AVCodecID = 86;
5443pub const AVCodecID_AV_CODEC_ID_CAVS: AVCodecID = 87;
5444pub const AVCodecID_AV_CODEC_ID_JPEG2000: AVCodecID = 88;
5445pub const AVCodecID_AV_CODEC_ID_VMNC: AVCodecID = 89;
5446pub const AVCodecID_AV_CODEC_ID_VP5: AVCodecID = 90;
5447pub const AVCodecID_AV_CODEC_ID_VP6: AVCodecID = 91;
5448pub const AVCodecID_AV_CODEC_ID_VP6F: AVCodecID = 92;
5449pub const AVCodecID_AV_CODEC_ID_TARGA: AVCodecID = 93;
5450pub const AVCodecID_AV_CODEC_ID_DSICINVIDEO: AVCodecID = 94;
5451pub const AVCodecID_AV_CODEC_ID_TIERTEXSEQVIDEO: AVCodecID = 95;
5452pub const AVCodecID_AV_CODEC_ID_TIFF: AVCodecID = 96;
5453pub const AVCodecID_AV_CODEC_ID_GIF: AVCodecID = 97;
5454pub const AVCodecID_AV_CODEC_ID_DXA: AVCodecID = 98;
5455pub const AVCodecID_AV_CODEC_ID_DNXHD: AVCodecID = 99;
5456pub const AVCodecID_AV_CODEC_ID_THP: AVCodecID = 100;
5457pub const AVCodecID_AV_CODEC_ID_SGI: AVCodecID = 101;
5458pub const AVCodecID_AV_CODEC_ID_C93: AVCodecID = 102;
5459pub const AVCodecID_AV_CODEC_ID_BETHSOFTVID: AVCodecID = 103;
5460pub const AVCodecID_AV_CODEC_ID_PTX: AVCodecID = 104;
5461pub const AVCodecID_AV_CODEC_ID_TXD: AVCodecID = 105;
5462pub const AVCodecID_AV_CODEC_ID_VP6A: AVCodecID = 106;
5463pub const AVCodecID_AV_CODEC_ID_AMV: AVCodecID = 107;
5464pub const AVCodecID_AV_CODEC_ID_VB: AVCodecID = 108;
5465pub const AVCodecID_AV_CODEC_ID_PCX: AVCodecID = 109;
5466pub const AVCodecID_AV_CODEC_ID_SUNRAST: AVCodecID = 110;
5467pub const AVCodecID_AV_CODEC_ID_INDEO4: AVCodecID = 111;
5468pub const AVCodecID_AV_CODEC_ID_INDEO5: AVCodecID = 112;
5469pub const AVCodecID_AV_CODEC_ID_MIMIC: AVCodecID = 113;
5470pub const AVCodecID_AV_CODEC_ID_RL2: AVCodecID = 114;
5471pub const AVCodecID_AV_CODEC_ID_ESCAPE124: AVCodecID = 115;
5472pub const AVCodecID_AV_CODEC_ID_DIRAC: AVCodecID = 116;
5473pub const AVCodecID_AV_CODEC_ID_BFI: AVCodecID = 117;
5474pub const AVCodecID_AV_CODEC_ID_CMV: AVCodecID = 118;
5475pub const AVCodecID_AV_CODEC_ID_MOTIONPIXELS: AVCodecID = 119;
5476pub const AVCodecID_AV_CODEC_ID_TGV: AVCodecID = 120;
5477pub const AVCodecID_AV_CODEC_ID_TGQ: AVCodecID = 121;
5478pub const AVCodecID_AV_CODEC_ID_TQI: AVCodecID = 122;
5479pub const AVCodecID_AV_CODEC_ID_AURA: AVCodecID = 123;
5480pub const AVCodecID_AV_CODEC_ID_AURA2: AVCodecID = 124;
5481pub const AVCodecID_AV_CODEC_ID_V210X: AVCodecID = 125;
5482pub const AVCodecID_AV_CODEC_ID_TMV: AVCodecID = 126;
5483pub const AVCodecID_AV_CODEC_ID_V210: AVCodecID = 127;
5484pub const AVCodecID_AV_CODEC_ID_DPX: AVCodecID = 128;
5485pub const AVCodecID_AV_CODEC_ID_MAD: AVCodecID = 129;
5486pub const AVCodecID_AV_CODEC_ID_FRWU: AVCodecID = 130;
5487pub const AVCodecID_AV_CODEC_ID_FLASHSV2: AVCodecID = 131;
5488pub const AVCodecID_AV_CODEC_ID_CDGRAPHICS: AVCodecID = 132;
5489pub const AVCodecID_AV_CODEC_ID_R210: AVCodecID = 133;
5490pub const AVCodecID_AV_CODEC_ID_ANM: AVCodecID = 134;
5491pub const AVCodecID_AV_CODEC_ID_BINKVIDEO: AVCodecID = 135;
5492pub const AVCodecID_AV_CODEC_ID_IFF_ILBM: AVCodecID = 136;
5493pub const AVCodecID_AV_CODEC_ID_KGV1: AVCodecID = 137;
5494pub const AVCodecID_AV_CODEC_ID_YOP: AVCodecID = 138;
5495pub const AVCodecID_AV_CODEC_ID_VP8: AVCodecID = 139;
5496pub const AVCodecID_AV_CODEC_ID_PICTOR: AVCodecID = 140;
5497pub const AVCodecID_AV_CODEC_ID_ANSI: AVCodecID = 141;
5498pub const AVCodecID_AV_CODEC_ID_A64_MULTI: AVCodecID = 142;
5499pub const AVCodecID_AV_CODEC_ID_A64_MULTI5: AVCodecID = 143;
5500pub const AVCodecID_AV_CODEC_ID_R10K: AVCodecID = 144;
5501pub const AVCodecID_AV_CODEC_ID_MXPEG: AVCodecID = 145;
5502pub const AVCodecID_AV_CODEC_ID_LAGARITH: AVCodecID = 146;
5503pub const AVCodecID_AV_CODEC_ID_PRORES: AVCodecID = 147;
5504pub const AVCodecID_AV_CODEC_ID_JV: AVCodecID = 148;
5505pub const AVCodecID_AV_CODEC_ID_DFA: AVCodecID = 149;
5506pub const AVCodecID_AV_CODEC_ID_WMV3IMAGE: AVCodecID = 150;
5507pub const AVCodecID_AV_CODEC_ID_VC1IMAGE: AVCodecID = 151;
5508pub const AVCodecID_AV_CODEC_ID_UTVIDEO: AVCodecID = 152;
5509pub const AVCodecID_AV_CODEC_ID_BMV_VIDEO: AVCodecID = 153;
5510pub const AVCodecID_AV_CODEC_ID_VBLE: AVCodecID = 154;
5511pub const AVCodecID_AV_CODEC_ID_DXTORY: AVCodecID = 155;
5512pub const AVCodecID_AV_CODEC_ID_V410: AVCodecID = 156;
5513pub const AVCodecID_AV_CODEC_ID_XWD: AVCodecID = 157;
5514pub const AVCodecID_AV_CODEC_ID_CDXL: AVCodecID = 158;
5515pub const AVCodecID_AV_CODEC_ID_XBM: AVCodecID = 159;
5516pub const AVCodecID_AV_CODEC_ID_ZEROCODEC: AVCodecID = 160;
5517pub const AVCodecID_AV_CODEC_ID_MSS1: AVCodecID = 161;
5518pub const AVCodecID_AV_CODEC_ID_MSA1: AVCodecID = 162;
5519pub const AVCodecID_AV_CODEC_ID_TSCC2: AVCodecID = 163;
5520pub const AVCodecID_AV_CODEC_ID_MTS2: AVCodecID = 164;
5521pub const AVCodecID_AV_CODEC_ID_CLLC: AVCodecID = 165;
5522pub const AVCodecID_AV_CODEC_ID_MSS2: AVCodecID = 166;
5523pub const AVCodecID_AV_CODEC_ID_VP9: AVCodecID = 167;
5524pub const AVCodecID_AV_CODEC_ID_AIC: AVCodecID = 168;
5525pub const AVCodecID_AV_CODEC_ID_ESCAPE130: AVCodecID = 169;
5526pub const AVCodecID_AV_CODEC_ID_G2M: AVCodecID = 170;
5527pub const AVCodecID_AV_CODEC_ID_WEBP: AVCodecID = 171;
5528pub const AVCodecID_AV_CODEC_ID_HNM4_VIDEO: AVCodecID = 172;
5529pub const AVCodecID_AV_CODEC_ID_HEVC: AVCodecID = 173;
5530pub const AVCodecID_AV_CODEC_ID_FIC: AVCodecID = 174;
5531pub const AVCodecID_AV_CODEC_ID_ALIAS_PIX: AVCodecID = 175;
5532pub const AVCodecID_AV_CODEC_ID_BRENDER_PIX: AVCodecID = 176;
5533pub const AVCodecID_AV_CODEC_ID_PAF_VIDEO: AVCodecID = 177;
5534pub const AVCodecID_AV_CODEC_ID_EXR: AVCodecID = 178;
5535pub const AVCodecID_AV_CODEC_ID_VP7: AVCodecID = 179;
5536pub const AVCodecID_AV_CODEC_ID_SANM: AVCodecID = 180;
5537pub const AVCodecID_AV_CODEC_ID_SGIRLE: AVCodecID = 181;
5538pub const AVCodecID_AV_CODEC_ID_MVC1: AVCodecID = 182;
5539pub const AVCodecID_AV_CODEC_ID_MVC2: AVCodecID = 183;
5540pub const AVCodecID_AV_CODEC_ID_HQX: AVCodecID = 184;
5541pub const AVCodecID_AV_CODEC_ID_TDSC: AVCodecID = 185;
5542pub const AVCodecID_AV_CODEC_ID_HQ_HQA: AVCodecID = 186;
5543pub const AVCodecID_AV_CODEC_ID_HAP: AVCodecID = 187;
5544pub const AVCodecID_AV_CODEC_ID_DDS: AVCodecID = 188;
5545pub const AVCodecID_AV_CODEC_ID_DXV: AVCodecID = 189;
5546pub const AVCodecID_AV_CODEC_ID_SCREENPRESSO: AVCodecID = 190;
5547pub const AVCodecID_AV_CODEC_ID_RSCC: AVCodecID = 191;
5548pub const AVCodecID_AV_CODEC_ID_AVS2: AVCodecID = 192;
5549pub const AVCodecID_AV_CODEC_ID_PGX: AVCodecID = 193;
5550pub const AVCodecID_AV_CODEC_ID_AVS3: AVCodecID = 194;
5551pub const AVCodecID_AV_CODEC_ID_MSP2: AVCodecID = 195;
5552pub const AVCodecID_AV_CODEC_ID_VVC: AVCodecID = 196;
5553pub const AVCodecID_AV_CODEC_ID_Y41P: AVCodecID = 197;
5554pub const AVCodecID_AV_CODEC_ID_AVRP: AVCodecID = 198;
5555pub const AVCodecID_AV_CODEC_ID_012V: AVCodecID = 199;
5556pub const AVCodecID_AV_CODEC_ID_AVUI: AVCodecID = 200;
5557pub const AVCodecID_AV_CODEC_ID_TARGA_Y216: AVCodecID = 201;
5558pub const AVCodecID_AV_CODEC_ID_V308: AVCodecID = 202;
5559pub const AVCodecID_AV_CODEC_ID_V408: AVCodecID = 203;
5560pub const AVCodecID_AV_CODEC_ID_YUV4: AVCodecID = 204;
5561pub const AVCodecID_AV_CODEC_ID_AVRN: AVCodecID = 205;
5562pub const AVCodecID_AV_CODEC_ID_CPIA: AVCodecID = 206;
5563pub const AVCodecID_AV_CODEC_ID_XFACE: AVCodecID = 207;
5564pub const AVCodecID_AV_CODEC_ID_SNOW: AVCodecID = 208;
5565pub const AVCodecID_AV_CODEC_ID_SMVJPEG: AVCodecID = 209;
5566pub const AVCodecID_AV_CODEC_ID_APNG: AVCodecID = 210;
5567pub const AVCodecID_AV_CODEC_ID_DAALA: AVCodecID = 211;
5568pub const AVCodecID_AV_CODEC_ID_CFHD: AVCodecID = 212;
5569pub const AVCodecID_AV_CODEC_ID_TRUEMOTION2RT: AVCodecID = 213;
5570pub const AVCodecID_AV_CODEC_ID_M101: AVCodecID = 214;
5571pub const AVCodecID_AV_CODEC_ID_MAGICYUV: AVCodecID = 215;
5572pub const AVCodecID_AV_CODEC_ID_SHEERVIDEO: AVCodecID = 216;
5573pub const AVCodecID_AV_CODEC_ID_YLC: AVCodecID = 217;
5574pub const AVCodecID_AV_CODEC_ID_PSD: AVCodecID = 218;
5575pub const AVCodecID_AV_CODEC_ID_PIXLET: AVCodecID = 219;
5576pub const AVCodecID_AV_CODEC_ID_SPEEDHQ: AVCodecID = 220;
5577pub const AVCodecID_AV_CODEC_ID_FMVC: AVCodecID = 221;
5578pub const AVCodecID_AV_CODEC_ID_SCPR: AVCodecID = 222;
5579pub const AVCodecID_AV_CODEC_ID_CLEARVIDEO: AVCodecID = 223;
5580pub const AVCodecID_AV_CODEC_ID_XPM: AVCodecID = 224;
5581pub const AVCodecID_AV_CODEC_ID_AV1: AVCodecID = 225;
5582pub const AVCodecID_AV_CODEC_ID_BITPACKED: AVCodecID = 226;
5583pub const AVCodecID_AV_CODEC_ID_MSCC: AVCodecID = 227;
5584pub const AVCodecID_AV_CODEC_ID_SRGC: AVCodecID = 228;
5585pub const AVCodecID_AV_CODEC_ID_SVG: AVCodecID = 229;
5586pub const AVCodecID_AV_CODEC_ID_GDV: AVCodecID = 230;
5587pub const AVCodecID_AV_CODEC_ID_FITS: AVCodecID = 231;
5588pub const AVCodecID_AV_CODEC_ID_IMM4: AVCodecID = 232;
5589pub const AVCodecID_AV_CODEC_ID_PROSUMER: AVCodecID = 233;
5590pub const AVCodecID_AV_CODEC_ID_MWSC: AVCodecID = 234;
5591pub const AVCodecID_AV_CODEC_ID_WCMV: AVCodecID = 235;
5592pub const AVCodecID_AV_CODEC_ID_RASC: AVCodecID = 236;
5593pub const AVCodecID_AV_CODEC_ID_HYMT: AVCodecID = 237;
5594pub const AVCodecID_AV_CODEC_ID_ARBC: AVCodecID = 238;
5595pub const AVCodecID_AV_CODEC_ID_AGM: AVCodecID = 239;
5596pub const AVCodecID_AV_CODEC_ID_LSCR: AVCodecID = 240;
5597pub const AVCodecID_AV_CODEC_ID_VP4: AVCodecID = 241;
5598pub const AVCodecID_AV_CODEC_ID_IMM5: AVCodecID = 242;
5599pub const AVCodecID_AV_CODEC_ID_MVDV: AVCodecID = 243;
5600pub const AVCodecID_AV_CODEC_ID_MVHA: AVCodecID = 244;
5601pub const AVCodecID_AV_CODEC_ID_CDTOONS: AVCodecID = 245;
5602pub const AVCodecID_AV_CODEC_ID_MV30: AVCodecID = 246;
5603pub const AVCodecID_AV_CODEC_ID_NOTCHLC: AVCodecID = 247;
5604pub const AVCodecID_AV_CODEC_ID_PFM: AVCodecID = 248;
5605pub const AVCodecID_AV_CODEC_ID_MOBICLIP: AVCodecID = 249;
5606pub const AVCodecID_AV_CODEC_ID_PHOTOCD: AVCodecID = 250;
5607pub const AVCodecID_AV_CODEC_ID_IPU: AVCodecID = 251;
5608pub const AVCodecID_AV_CODEC_ID_ARGO: AVCodecID = 252;
5609pub const AVCodecID_AV_CODEC_ID_CRI: AVCodecID = 253;
5610pub const AVCodecID_AV_CODEC_ID_SIMBIOSIS_IMX: AVCodecID = 254;
5611pub const AVCodecID_AV_CODEC_ID_SGA_VIDEO: AVCodecID = 255;
5612pub const AVCodecID_AV_CODEC_ID_GEM: AVCodecID = 256;
5613pub const AVCodecID_AV_CODEC_ID_VBN: AVCodecID = 257;
5614pub const AVCodecID_AV_CODEC_ID_JPEGXL: AVCodecID = 258;
5615pub const AVCodecID_AV_CODEC_ID_QOI: AVCodecID = 259;
5616pub const AVCodecID_AV_CODEC_ID_PHM: AVCodecID = 260;
5617pub const AVCodecID_AV_CODEC_ID_RADIANCE_HDR: AVCodecID = 261;
5618pub const AVCodecID_AV_CODEC_ID_WBMP: AVCodecID = 262;
5619pub const AVCodecID_AV_CODEC_ID_MEDIA100: AVCodecID = 263;
5620pub const AVCodecID_AV_CODEC_ID_VQC: AVCodecID = 264;
5621pub const AVCodecID_AV_CODEC_ID_PDV: AVCodecID = 265;
5622pub const AVCodecID_AV_CODEC_ID_EVC: AVCodecID = 266;
5623pub const AVCodecID_AV_CODEC_ID_RTV1: AVCodecID = 267;
5624pub const AVCodecID_AV_CODEC_ID_VMIX: AVCodecID = 268;
5625pub const AVCodecID_AV_CODEC_ID_LEAD: AVCodecID = 269;
5626#[doc = "< A dummy id pointing at the start of audio codecs"]
5627pub const AVCodecID_AV_CODEC_ID_FIRST_AUDIO: AVCodecID = 65536;
5628pub const AVCodecID_AV_CODEC_ID_PCM_S16LE: AVCodecID = 65536;
5629pub const AVCodecID_AV_CODEC_ID_PCM_S16BE: AVCodecID = 65537;
5630pub const AVCodecID_AV_CODEC_ID_PCM_U16LE: AVCodecID = 65538;
5631pub const AVCodecID_AV_CODEC_ID_PCM_U16BE: AVCodecID = 65539;
5632pub const AVCodecID_AV_CODEC_ID_PCM_S8: AVCodecID = 65540;
5633pub const AVCodecID_AV_CODEC_ID_PCM_U8: AVCodecID = 65541;
5634pub const AVCodecID_AV_CODEC_ID_PCM_MULAW: AVCodecID = 65542;
5635pub const AVCodecID_AV_CODEC_ID_PCM_ALAW: AVCodecID = 65543;
5636pub const AVCodecID_AV_CODEC_ID_PCM_S32LE: AVCodecID = 65544;
5637pub const AVCodecID_AV_CODEC_ID_PCM_S32BE: AVCodecID = 65545;
5638pub const AVCodecID_AV_CODEC_ID_PCM_U32LE: AVCodecID = 65546;
5639pub const AVCodecID_AV_CODEC_ID_PCM_U32BE: AVCodecID = 65547;
5640pub const AVCodecID_AV_CODEC_ID_PCM_S24LE: AVCodecID = 65548;
5641pub const AVCodecID_AV_CODEC_ID_PCM_S24BE: AVCodecID = 65549;
5642pub const AVCodecID_AV_CODEC_ID_PCM_U24LE: AVCodecID = 65550;
5643pub const AVCodecID_AV_CODEC_ID_PCM_U24BE: AVCodecID = 65551;
5644pub const AVCodecID_AV_CODEC_ID_PCM_S24DAUD: AVCodecID = 65552;
5645pub const AVCodecID_AV_CODEC_ID_PCM_ZORK: AVCodecID = 65553;
5646pub const AVCodecID_AV_CODEC_ID_PCM_S16LE_PLANAR: AVCodecID = 65554;
5647pub const AVCodecID_AV_CODEC_ID_PCM_DVD: AVCodecID = 65555;
5648pub const AVCodecID_AV_CODEC_ID_PCM_F32BE: AVCodecID = 65556;
5649pub const AVCodecID_AV_CODEC_ID_PCM_F32LE: AVCodecID = 65557;
5650pub const AVCodecID_AV_CODEC_ID_PCM_F64BE: AVCodecID = 65558;
5651pub const AVCodecID_AV_CODEC_ID_PCM_F64LE: AVCodecID = 65559;
5652pub const AVCodecID_AV_CODEC_ID_PCM_BLURAY: AVCodecID = 65560;
5653pub const AVCodecID_AV_CODEC_ID_PCM_LXF: AVCodecID = 65561;
5654pub const AVCodecID_AV_CODEC_ID_S302M: AVCodecID = 65562;
5655pub const AVCodecID_AV_CODEC_ID_PCM_S8_PLANAR: AVCodecID = 65563;
5656pub const AVCodecID_AV_CODEC_ID_PCM_S24LE_PLANAR: AVCodecID = 65564;
5657pub const AVCodecID_AV_CODEC_ID_PCM_S32LE_PLANAR: AVCodecID = 65565;
5658pub const AVCodecID_AV_CODEC_ID_PCM_S16BE_PLANAR: AVCodecID = 65566;
5659pub const AVCodecID_AV_CODEC_ID_PCM_S64LE: AVCodecID = 65567;
5660pub const AVCodecID_AV_CODEC_ID_PCM_S64BE: AVCodecID = 65568;
5661pub const AVCodecID_AV_CODEC_ID_PCM_F16LE: AVCodecID = 65569;
5662pub const AVCodecID_AV_CODEC_ID_PCM_F24LE: AVCodecID = 65570;
5663pub const AVCodecID_AV_CODEC_ID_PCM_VIDC: AVCodecID = 65571;
5664pub const AVCodecID_AV_CODEC_ID_PCM_SGA: AVCodecID = 65572;
5665pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_QT: AVCodecID = 69632;
5666pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_WAV: AVCodecID = 69633;
5667pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_DK3: AVCodecID = 69634;
5668pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_DK4: AVCodecID = 69635;
5669pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_WS: AVCodecID = 69636;
5670pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_SMJPEG: AVCodecID = 69637;
5671pub const AVCodecID_AV_CODEC_ID_ADPCM_MS: AVCodecID = 69638;
5672pub const AVCodecID_AV_CODEC_ID_ADPCM_4XM: AVCodecID = 69639;
5673pub const AVCodecID_AV_CODEC_ID_ADPCM_XA: AVCodecID = 69640;
5674pub const AVCodecID_AV_CODEC_ID_ADPCM_ADX: AVCodecID = 69641;
5675pub const AVCodecID_AV_CODEC_ID_ADPCM_EA: AVCodecID = 69642;
5676pub const AVCodecID_AV_CODEC_ID_ADPCM_G726: AVCodecID = 69643;
5677pub const AVCodecID_AV_CODEC_ID_ADPCM_CT: AVCodecID = 69644;
5678pub const AVCodecID_AV_CODEC_ID_ADPCM_SWF: AVCodecID = 69645;
5679pub const AVCodecID_AV_CODEC_ID_ADPCM_YAMAHA: AVCodecID = 69646;
5680pub const AVCodecID_AV_CODEC_ID_ADPCM_SBPRO_4: AVCodecID = 69647;
5681pub const AVCodecID_AV_CODEC_ID_ADPCM_SBPRO_3: AVCodecID = 69648;
5682pub const AVCodecID_AV_CODEC_ID_ADPCM_SBPRO_2: AVCodecID = 69649;
5683pub const AVCodecID_AV_CODEC_ID_ADPCM_THP: AVCodecID = 69650;
5684pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_AMV: AVCodecID = 69651;
5685pub const AVCodecID_AV_CODEC_ID_ADPCM_EA_R1: AVCodecID = 69652;
5686pub const AVCodecID_AV_CODEC_ID_ADPCM_EA_R3: AVCodecID = 69653;
5687pub const AVCodecID_AV_CODEC_ID_ADPCM_EA_R2: AVCodecID = 69654;
5688pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_EA_SEAD: AVCodecID = 69655;
5689pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_EA_EACS: AVCodecID = 69656;
5690pub const AVCodecID_AV_CODEC_ID_ADPCM_EA_XAS: AVCodecID = 69657;
5691pub const AVCodecID_AV_CODEC_ID_ADPCM_EA_MAXIS_XA: AVCodecID = 69658;
5692pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_ISS: AVCodecID = 69659;
5693pub const AVCodecID_AV_CODEC_ID_ADPCM_G722: AVCodecID = 69660;
5694pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_APC: AVCodecID = 69661;
5695pub const AVCodecID_AV_CODEC_ID_ADPCM_VIMA: AVCodecID = 69662;
5696pub const AVCodecID_AV_CODEC_ID_ADPCM_AFC: AVCodecID = 69663;
5697pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_OKI: AVCodecID = 69664;
5698pub const AVCodecID_AV_CODEC_ID_ADPCM_DTK: AVCodecID = 69665;
5699pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_RAD: AVCodecID = 69666;
5700pub const AVCodecID_AV_CODEC_ID_ADPCM_G726LE: AVCodecID = 69667;
5701pub const AVCodecID_AV_CODEC_ID_ADPCM_THP_LE: AVCodecID = 69668;
5702pub const AVCodecID_AV_CODEC_ID_ADPCM_PSX: AVCodecID = 69669;
5703pub const AVCodecID_AV_CODEC_ID_ADPCM_AICA: AVCodecID = 69670;
5704pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_DAT4: AVCodecID = 69671;
5705pub const AVCodecID_AV_CODEC_ID_ADPCM_MTAF: AVCodecID = 69672;
5706pub const AVCodecID_AV_CODEC_ID_ADPCM_AGM: AVCodecID = 69673;
5707pub const AVCodecID_AV_CODEC_ID_ADPCM_ARGO: AVCodecID = 69674;
5708pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_SSI: AVCodecID = 69675;
5709pub const AVCodecID_AV_CODEC_ID_ADPCM_ZORK: AVCodecID = 69676;
5710pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_APM: AVCodecID = 69677;
5711pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_ALP: AVCodecID = 69678;
5712pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_MTF: AVCodecID = 69679;
5713pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_CUNNING: AVCodecID = 69680;
5714pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_MOFLEX: AVCodecID = 69681;
5715pub const AVCodecID_AV_CODEC_ID_ADPCM_IMA_ACORN: AVCodecID = 69682;
5716pub const AVCodecID_AV_CODEC_ID_ADPCM_XMD: AVCodecID = 69683;
5717pub const AVCodecID_AV_CODEC_ID_AMR_NB: AVCodecID = 73728;
5718pub const AVCodecID_AV_CODEC_ID_AMR_WB: AVCodecID = 73729;
5719pub const AVCodecID_AV_CODEC_ID_RA_144: AVCodecID = 77824;
5720pub const AVCodecID_AV_CODEC_ID_RA_288: AVCodecID = 77825;
5721pub const AVCodecID_AV_CODEC_ID_ROQ_DPCM: AVCodecID = 81920;
5722pub const AVCodecID_AV_CODEC_ID_INTERPLAY_DPCM: AVCodecID = 81921;
5723pub const AVCodecID_AV_CODEC_ID_XAN_DPCM: AVCodecID = 81922;
5724pub const AVCodecID_AV_CODEC_ID_SOL_DPCM: AVCodecID = 81923;
5725pub const AVCodecID_AV_CODEC_ID_SDX2_DPCM: AVCodecID = 81924;
5726pub const AVCodecID_AV_CODEC_ID_GREMLIN_DPCM: AVCodecID = 81925;
5727pub const AVCodecID_AV_CODEC_ID_DERF_DPCM: AVCodecID = 81926;
5728pub const AVCodecID_AV_CODEC_ID_WADY_DPCM: AVCodecID = 81927;
5729pub const AVCodecID_AV_CODEC_ID_CBD2_DPCM: AVCodecID = 81928;
5730pub const AVCodecID_AV_CODEC_ID_MP2: AVCodecID = 86016;
5731#[doc = "< preferred ID for decoding MPEG audio layer 1, 2 or 3"]
5732pub const AVCodecID_AV_CODEC_ID_MP3: AVCodecID = 86017;
5733pub const AVCodecID_AV_CODEC_ID_AAC: AVCodecID = 86018;
5734pub const AVCodecID_AV_CODEC_ID_AC3: AVCodecID = 86019;
5735pub const AVCodecID_AV_CODEC_ID_DTS: AVCodecID = 86020;
5736pub const AVCodecID_AV_CODEC_ID_VORBIS: AVCodecID = 86021;
5737pub const AVCodecID_AV_CODEC_ID_DVAUDIO: AVCodecID = 86022;
5738pub const AVCodecID_AV_CODEC_ID_WMAV1: AVCodecID = 86023;
5739pub const AVCodecID_AV_CODEC_ID_WMAV2: AVCodecID = 86024;
5740pub const AVCodecID_AV_CODEC_ID_MACE3: AVCodecID = 86025;
5741pub const AVCodecID_AV_CODEC_ID_MACE6: AVCodecID = 86026;
5742pub const AVCodecID_AV_CODEC_ID_VMDAUDIO: AVCodecID = 86027;
5743pub const AVCodecID_AV_CODEC_ID_FLAC: AVCodecID = 86028;
5744pub const AVCodecID_AV_CODEC_ID_MP3ADU: AVCodecID = 86029;
5745pub const AVCodecID_AV_CODEC_ID_MP3ON4: AVCodecID = 86030;
5746pub const AVCodecID_AV_CODEC_ID_SHORTEN: AVCodecID = 86031;
5747pub const AVCodecID_AV_CODEC_ID_ALAC: AVCodecID = 86032;
5748pub const AVCodecID_AV_CODEC_ID_WESTWOOD_SND1: AVCodecID = 86033;
5749#[doc = "< as in Berlin toast format"]
5750pub const AVCodecID_AV_CODEC_ID_GSM: AVCodecID = 86034;
5751pub const AVCodecID_AV_CODEC_ID_QDM2: AVCodecID = 86035;
5752pub const AVCodecID_AV_CODEC_ID_COOK: AVCodecID = 86036;
5753pub const AVCodecID_AV_CODEC_ID_TRUESPEECH: AVCodecID = 86037;
5754pub const AVCodecID_AV_CODEC_ID_TTA: AVCodecID = 86038;
5755pub const AVCodecID_AV_CODEC_ID_SMACKAUDIO: AVCodecID = 86039;
5756pub const AVCodecID_AV_CODEC_ID_QCELP: AVCodecID = 86040;
5757pub const AVCodecID_AV_CODEC_ID_WAVPACK: AVCodecID = 86041;
5758pub const AVCodecID_AV_CODEC_ID_DSICINAUDIO: AVCodecID = 86042;
5759pub const AVCodecID_AV_CODEC_ID_IMC: AVCodecID = 86043;
5760pub const AVCodecID_AV_CODEC_ID_MUSEPACK7: AVCodecID = 86044;
5761pub const AVCodecID_AV_CODEC_ID_MLP: AVCodecID = 86045;
5762pub const AVCodecID_AV_CODEC_ID_GSM_MS: AVCodecID = 86046;
5763pub const AVCodecID_AV_CODEC_ID_ATRAC3: AVCodecID = 86047;
5764pub const AVCodecID_AV_CODEC_ID_APE: AVCodecID = 86048;
5765pub const AVCodecID_AV_CODEC_ID_NELLYMOSER: AVCodecID = 86049;
5766pub const AVCodecID_AV_CODEC_ID_MUSEPACK8: AVCodecID = 86050;
5767pub const AVCodecID_AV_CODEC_ID_SPEEX: AVCodecID = 86051;
5768pub const AVCodecID_AV_CODEC_ID_WMAVOICE: AVCodecID = 86052;
5769pub const AVCodecID_AV_CODEC_ID_WMAPRO: AVCodecID = 86053;
5770pub const AVCodecID_AV_CODEC_ID_WMALOSSLESS: AVCodecID = 86054;
5771pub const AVCodecID_AV_CODEC_ID_ATRAC3P: AVCodecID = 86055;
5772pub const AVCodecID_AV_CODEC_ID_EAC3: AVCodecID = 86056;
5773pub const AVCodecID_AV_CODEC_ID_SIPR: AVCodecID = 86057;
5774pub const AVCodecID_AV_CODEC_ID_MP1: AVCodecID = 86058;
5775pub const AVCodecID_AV_CODEC_ID_TWINVQ: AVCodecID = 86059;
5776pub const AVCodecID_AV_CODEC_ID_TRUEHD: AVCodecID = 86060;
5777pub const AVCodecID_AV_CODEC_ID_MP4ALS: AVCodecID = 86061;
5778pub const AVCodecID_AV_CODEC_ID_ATRAC1: AVCodecID = 86062;
5779pub const AVCodecID_AV_CODEC_ID_BINKAUDIO_RDFT: AVCodecID = 86063;
5780pub const AVCodecID_AV_CODEC_ID_BINKAUDIO_DCT: AVCodecID = 86064;
5781pub const AVCodecID_AV_CODEC_ID_AAC_LATM: AVCodecID = 86065;
5782pub const AVCodecID_AV_CODEC_ID_QDMC: AVCodecID = 86066;
5783pub const AVCodecID_AV_CODEC_ID_CELT: AVCodecID = 86067;
5784pub const AVCodecID_AV_CODEC_ID_G723_1: AVCodecID = 86068;
5785pub const AVCodecID_AV_CODEC_ID_G729: AVCodecID = 86069;
5786pub const AVCodecID_AV_CODEC_ID_8SVX_EXP: AVCodecID = 86070;
5787pub const AVCodecID_AV_CODEC_ID_8SVX_FIB: AVCodecID = 86071;
5788pub const AVCodecID_AV_CODEC_ID_BMV_AUDIO: AVCodecID = 86072;
5789pub const AVCodecID_AV_CODEC_ID_RALF: AVCodecID = 86073;
5790pub const AVCodecID_AV_CODEC_ID_IAC: AVCodecID = 86074;
5791pub const AVCodecID_AV_CODEC_ID_ILBC: AVCodecID = 86075;
5792pub const AVCodecID_AV_CODEC_ID_OPUS: AVCodecID = 86076;
5793pub const AVCodecID_AV_CODEC_ID_COMFORT_NOISE: AVCodecID = 86077;
5794pub const AVCodecID_AV_CODEC_ID_TAK: AVCodecID = 86078;
5795pub const AVCodecID_AV_CODEC_ID_METASOUND: AVCodecID = 86079;
5796pub const AVCodecID_AV_CODEC_ID_PAF_AUDIO: AVCodecID = 86080;
5797pub const AVCodecID_AV_CODEC_ID_ON2AVC: AVCodecID = 86081;
5798pub const AVCodecID_AV_CODEC_ID_DSS_SP: AVCodecID = 86082;
5799pub const AVCodecID_AV_CODEC_ID_CODEC2: AVCodecID = 86083;
5800pub const AVCodecID_AV_CODEC_ID_FFWAVESYNTH: AVCodecID = 86084;
5801pub const AVCodecID_AV_CODEC_ID_SONIC: AVCodecID = 86085;
5802pub const AVCodecID_AV_CODEC_ID_SONIC_LS: AVCodecID = 86086;
5803pub const AVCodecID_AV_CODEC_ID_EVRC: AVCodecID = 86087;
5804pub const AVCodecID_AV_CODEC_ID_SMV: AVCodecID = 86088;
5805pub const AVCodecID_AV_CODEC_ID_DSD_LSBF: AVCodecID = 86089;
5806pub const AVCodecID_AV_CODEC_ID_DSD_MSBF: AVCodecID = 86090;
5807pub const AVCodecID_AV_CODEC_ID_DSD_LSBF_PLANAR: AVCodecID = 86091;
5808pub const AVCodecID_AV_CODEC_ID_DSD_MSBF_PLANAR: AVCodecID = 86092;
5809pub const AVCodecID_AV_CODEC_ID_4GV: AVCodecID = 86093;
5810pub const AVCodecID_AV_CODEC_ID_INTERPLAY_ACM: AVCodecID = 86094;
5811pub const AVCodecID_AV_CODEC_ID_XMA1: AVCodecID = 86095;
5812pub const AVCodecID_AV_CODEC_ID_XMA2: AVCodecID = 86096;
5813pub const AVCodecID_AV_CODEC_ID_DST: AVCodecID = 86097;
5814pub const AVCodecID_AV_CODEC_ID_ATRAC3AL: AVCodecID = 86098;
5815pub const AVCodecID_AV_CODEC_ID_ATRAC3PAL: AVCodecID = 86099;
5816pub const AVCodecID_AV_CODEC_ID_DOLBY_E: AVCodecID = 86100;
5817pub const AVCodecID_AV_CODEC_ID_APTX: AVCodecID = 86101;
5818pub const AVCodecID_AV_CODEC_ID_APTX_HD: AVCodecID = 86102;
5819pub const AVCodecID_AV_CODEC_ID_SBC: AVCodecID = 86103;
5820pub const AVCodecID_AV_CODEC_ID_ATRAC9: AVCodecID = 86104;
5821pub const AVCodecID_AV_CODEC_ID_HCOM: AVCodecID = 86105;
5822pub const AVCodecID_AV_CODEC_ID_ACELP_KELVIN: AVCodecID = 86106;
5823pub const AVCodecID_AV_CODEC_ID_MPEGH_3D_AUDIO: AVCodecID = 86107;
5824pub const AVCodecID_AV_CODEC_ID_SIREN: AVCodecID = 86108;
5825pub const AVCodecID_AV_CODEC_ID_HCA: AVCodecID = 86109;
5826pub const AVCodecID_AV_CODEC_ID_FASTAUDIO: AVCodecID = 86110;
5827pub const AVCodecID_AV_CODEC_ID_MSNSIREN: AVCodecID = 86111;
5828pub const AVCodecID_AV_CODEC_ID_DFPWM: AVCodecID = 86112;
5829pub const AVCodecID_AV_CODEC_ID_BONK: AVCodecID = 86113;
5830pub const AVCodecID_AV_CODEC_ID_MISC4: AVCodecID = 86114;
5831pub const AVCodecID_AV_CODEC_ID_APAC: AVCodecID = 86115;
5832pub const AVCodecID_AV_CODEC_ID_FTR: AVCodecID = 86116;
5833pub const AVCodecID_AV_CODEC_ID_WAVARC: AVCodecID = 86117;
5834pub const AVCodecID_AV_CODEC_ID_RKA: AVCodecID = 86118;
5835pub const AVCodecID_AV_CODEC_ID_AC4: AVCodecID = 86119;
5836pub const AVCodecID_AV_CODEC_ID_OSQ: AVCodecID = 86120;
5837pub const AVCodecID_AV_CODEC_ID_QOA: AVCodecID = 86121;
5838pub const AVCodecID_AV_CODEC_ID_LC3: AVCodecID = 86122;
5839#[doc = "< A dummy ID pointing at the start of subtitle codecs."]
5840pub const AVCodecID_AV_CODEC_ID_FIRST_SUBTITLE: AVCodecID = 94208;
5841pub const AVCodecID_AV_CODEC_ID_DVD_SUBTITLE: AVCodecID = 94208;
5842pub const AVCodecID_AV_CODEC_ID_DVB_SUBTITLE: AVCodecID = 94209;
5843#[doc = "< raw UTF-8 text"]
5844pub const AVCodecID_AV_CODEC_ID_TEXT: AVCodecID = 94210;
5845pub const AVCodecID_AV_CODEC_ID_XSUB: AVCodecID = 94211;
5846pub const AVCodecID_AV_CODEC_ID_SSA: AVCodecID = 94212;
5847pub const AVCodecID_AV_CODEC_ID_MOV_TEXT: AVCodecID = 94213;
5848pub const AVCodecID_AV_CODEC_ID_HDMV_PGS_SUBTITLE: AVCodecID = 94214;
5849pub const AVCodecID_AV_CODEC_ID_DVB_TELETEXT: AVCodecID = 94215;
5850pub const AVCodecID_AV_CODEC_ID_SRT: AVCodecID = 94216;
5851pub const AVCodecID_AV_CODEC_ID_MICRODVD: AVCodecID = 94217;
5852pub const AVCodecID_AV_CODEC_ID_EIA_608: AVCodecID = 94218;
5853pub const AVCodecID_AV_CODEC_ID_JACOSUB: AVCodecID = 94219;
5854pub const AVCodecID_AV_CODEC_ID_SAMI: AVCodecID = 94220;
5855pub const AVCodecID_AV_CODEC_ID_REALTEXT: AVCodecID = 94221;
5856pub const AVCodecID_AV_CODEC_ID_STL: AVCodecID = 94222;
5857pub const AVCodecID_AV_CODEC_ID_SUBVIEWER1: AVCodecID = 94223;
5858pub const AVCodecID_AV_CODEC_ID_SUBVIEWER: AVCodecID = 94224;
5859pub const AVCodecID_AV_CODEC_ID_SUBRIP: AVCodecID = 94225;
5860pub const AVCodecID_AV_CODEC_ID_WEBVTT: AVCodecID = 94226;
5861pub const AVCodecID_AV_CODEC_ID_MPL2: AVCodecID = 94227;
5862pub const AVCodecID_AV_CODEC_ID_VPLAYER: AVCodecID = 94228;
5863pub const AVCodecID_AV_CODEC_ID_PJS: AVCodecID = 94229;
5864pub const AVCodecID_AV_CODEC_ID_ASS: AVCodecID = 94230;
5865pub const AVCodecID_AV_CODEC_ID_HDMV_TEXT_SUBTITLE: AVCodecID = 94231;
5866pub const AVCodecID_AV_CODEC_ID_TTML: AVCodecID = 94232;
5867pub const AVCodecID_AV_CODEC_ID_ARIB_CAPTION: AVCodecID = 94233;
5868#[doc = "< A dummy ID pointing at the start of various fake codecs."]
5869pub const AVCodecID_AV_CODEC_ID_FIRST_UNKNOWN: AVCodecID = 98304;
5870pub const AVCodecID_AV_CODEC_ID_TTF: AVCodecID = 98304;
5871#[doc = "< Contain timestamp estimated through PCR of program stream."]
5872pub const AVCodecID_AV_CODEC_ID_SCTE_35: AVCodecID = 98305;
5873pub const AVCodecID_AV_CODEC_ID_EPG: AVCodecID = 98306;
5874pub const AVCodecID_AV_CODEC_ID_BINTEXT: AVCodecID = 98307;
5875pub const AVCodecID_AV_CODEC_ID_XBIN: AVCodecID = 98308;
5876pub const AVCodecID_AV_CODEC_ID_IDF: AVCodecID = 98309;
5877pub const AVCodecID_AV_CODEC_ID_OTF: AVCodecID = 98310;
5878pub const AVCodecID_AV_CODEC_ID_SMPTE_KLV: AVCodecID = 98311;
5879pub const AVCodecID_AV_CODEC_ID_DVD_NAV: AVCodecID = 98312;
5880pub const AVCodecID_AV_CODEC_ID_TIMED_ID3: AVCodecID = 98313;
5881pub const AVCodecID_AV_CODEC_ID_BIN_DATA: AVCodecID = 98314;
5882pub const AVCodecID_AV_CODEC_ID_SMPTE_2038: AVCodecID = 98315;
5883#[doc = "< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it"]
5884pub const AVCodecID_AV_CODEC_ID_PROBE: AVCodecID = 102400;
5885#[doc = "< _FAKE_ codec to indicate a raw MPEG-2 TS\n stream (only used by libavformat)"]
5886pub const AVCodecID_AV_CODEC_ID_MPEG2TS: AVCodecID = 131072;
5887#[doc = "< _FAKE_ codec to indicate a MPEG-4 Systems\n stream (only used by libavformat)"]
5888pub const AVCodecID_AV_CODEC_ID_MPEG4SYSTEMS: AVCodecID = 131073;
5889#[doc = "< Dummy codec for streams containing only metadata information."]
5890pub const AVCodecID_AV_CODEC_ID_FFMETADATA: AVCodecID = 135168;
5891#[doc = "< Passthrough codec, AVFrames wrapped in AVPacket"]
5892pub const AVCodecID_AV_CODEC_ID_WRAPPED_AVFRAME: AVCodecID = 135169;
5893#[doc = " Dummy null video codec, useful mainly for development and debugging.\n Null encoder/decoder discard all input and never return any output."]
5894pub const AVCodecID_AV_CODEC_ID_VNULL: AVCodecID = 135170;
5895#[doc = " Dummy null audio codec, useful mainly for development and debugging.\n Null encoder/decoder discard all input and never return any output."]
5896pub const AVCodecID_AV_CODEC_ID_ANULL: AVCodecID = 135171;
5897#[doc = " Identify the syntax and semantics of the bitstream.\n The principle is roughly:\n Two decoders with the same ID can decode the same streams.\n Two encoders with the same ID can encode compatible streams.\n There may be slight deviations from the principle due to implementation\n details.\n\n If you add a codec ID to this list, add it so that\n 1. no value of an existing codec ID changes (that would break ABI),\n 2. it is as close as possible to similar codecs\n\n After adding new codec IDs, do not forget to add an entry to the codec\n descriptor list and bump libavcodec minor version."]
5898pub type AVCodecID = ::std::os::raw::c_uint;
5899extern "C" {
5900 #[doc = " Get the type of the given codec."]
5901 pub fn avcodec_get_type(codec_id: AVCodecID) -> AVMediaType;
5902}
5903extern "C" {
5904 #[doc = " Get the name of a codec.\n @return a static string identifying the codec; never NULL"]
5905 pub fn avcodec_get_name(id: AVCodecID) -> *const ::std::os::raw::c_char;
5906}
5907extern "C" {
5908 #[doc = " Return codec bits per sample.\n\n @param[in] codec_id the codec\n @return Number of bits per sample or zero if unknown for the given codec."]
5909 pub fn av_get_bits_per_sample(codec_id: AVCodecID) -> ::std::os::raw::c_int;
5910}
5911extern "C" {
5912 #[doc = " Return codec bits per sample.\n Only return non-zero if the bits per sample is exactly correct, not an\n approximation.\n\n @param[in] codec_id the codec\n @return Number of bits per sample or zero if unknown for the given codec."]
5913 pub fn av_get_exact_bits_per_sample(codec_id: AVCodecID) -> ::std::os::raw::c_int;
5914}
5915extern "C" {
5916 #[doc = " Return a name for the specified profile, if available.\n\n @param codec_id the ID of the codec to which the requested profile belongs\n @param profile the profile value for which a name is requested\n @return A name for the profile if found, NULL otherwise.\n\n @note unlike av_get_profile_name(), which searches a list of profiles\n supported by a specific decoder or encoder implementation, this\n function searches the list of profiles from the AVCodecDescriptor"]
5917 pub fn avcodec_profile_name(
5918 codec_id: AVCodecID,
5919 profile: ::std::os::raw::c_int,
5920 ) -> *const ::std::os::raw::c_char;
5921}
5922extern "C" {
5923 #[doc = " Return the PCM codec associated with a sample format.\n @param be endianness, 0 for little, 1 for big,\n -1 (or anything else) for native\n @return AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE"]
5924 pub fn av_get_pcm_codec(fmt: AVSampleFormat, be: ::std::os::raw::c_int) -> AVCodecID;
5925}
5926#[doc = " AVProfile."]
5927#[repr(C)]
5928#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5929pub struct AVProfile {
5930 pub profile: ::std::os::raw::c_int,
5931 #[doc = "< short name for the profile"]
5932 pub name: *const ::std::os::raw::c_char,
5933}
5934impl Default for AVProfile {
5935 fn default() -> Self {
5936 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5937 unsafe {
5938 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5939 s.assume_init()
5940 }
5941 }
5942}
5943#[doc = " AVCodec."]
5944#[repr(C)]
5945#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
5946pub struct AVCodec {
5947 #[doc = " Name of the codec implementation.\n The name is globally unique among encoders and among decoders (but an\n encoder and a decoder can share the same name).\n This is the primary way to find a codec from the user perspective."]
5948 pub name: *const ::std::os::raw::c_char,
5949 #[doc = " Descriptive name for the codec, meant to be more human readable than name.\n You should use the NULL_IF_CONFIG_SMALL() macro to define it."]
5950 pub long_name: *const ::std::os::raw::c_char,
5951 pub type_: AVMediaType,
5952 pub id: AVCodecID,
5953 #[doc = " Codec capabilities.\n see AV_CODEC_CAP_*"]
5954 pub capabilities: ::std::os::raw::c_int,
5955 #[doc = "< maximum value for lowres supported by the decoder"]
5956 pub max_lowres: u8,
5957 #[doc = "< array of supported framerates, or NULL if any, array is terminated by {0,0}"]
5958 pub supported_framerates: *const AVRational,
5959 #[doc = "< array of supported pixel formats, or NULL if unknown, array is terminated by -1"]
5960 pub pix_fmts: *const AVPixelFormat,
5961 #[doc = "< array of supported audio samplerates, or NULL if unknown, array is terminated by 0"]
5962 pub supported_samplerates: *const ::std::os::raw::c_int,
5963 #[doc = "< array of supported sample formats, or NULL if unknown, array is terminated by -1"]
5964 pub sample_fmts: *const AVSampleFormat,
5965 #[doc = "< AVClass for the private context"]
5966 pub priv_class: *const AVClass,
5967 #[doc = "< array of recognized profiles, or NULL if unknown, array is terminated by {AV_PROFILE_UNKNOWN}"]
5968 pub profiles: *const AVProfile,
5969 #[doc = " Group name of the codec implementation.\n This is a short symbolic name of the wrapper backing this codec. A\n wrapper uses some kind of external implementation for the codec, such\n as an external library, or a codec implementation provided by the OS or\n the hardware.\n If this field is NULL, this is a builtin, libavcodec native codec.\n If non-NULL, this will be the suffix in AVCodec.name in most cases\n (usually AVCodec.name will be of the form \"<codec_name>_<wrapper_name>\")."]
5970 pub wrapper_name: *const ::std::os::raw::c_char,
5971 #[doc = " Array of supported channel layouts, terminated with a zeroed layout."]
5972 pub ch_layouts: *const AVChannelLayout,
5973}
5974impl Default for AVCodec {
5975 fn default() -> Self {
5976 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5977 unsafe {
5978 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5979 s.assume_init()
5980 }
5981 }
5982}
5983extern "C" {
5984 #[doc = " Iterate over all registered codecs.\n\n @param opaque a pointer where libavcodec will store the iteration state. Must\n point to NULL to start the iteration.\n\n @return the next registered codec or NULL when the iteration is\n finished"]
5985 pub fn av_codec_iterate(opaque: *mut *mut ::std::os::raw::c_void) -> *const AVCodec;
5986}
5987extern "C" {
5988 #[doc = " Find a registered decoder with a matching codec ID.\n\n @param id AVCodecID of the requested decoder\n @return A decoder if one was found, NULL otherwise."]
5989 pub fn avcodec_find_decoder(id: AVCodecID) -> *const AVCodec;
5990}
5991extern "C" {
5992 #[doc = " Find a registered decoder with the specified name.\n\n @param name name of the requested decoder\n @return A decoder if one was found, NULL otherwise."]
5993 pub fn avcodec_find_decoder_by_name(name: *const ::std::os::raw::c_char) -> *const AVCodec;
5994}
5995extern "C" {
5996 #[doc = " Find a registered encoder with a matching codec ID.\n\n @param id AVCodecID of the requested encoder\n @return An encoder if one was found, NULL otherwise."]
5997 pub fn avcodec_find_encoder(id: AVCodecID) -> *const AVCodec;
5998}
5999extern "C" {
6000 #[doc = " Find a registered encoder with the specified name.\n\n @param name name of the requested encoder\n @return An encoder if one was found, NULL otherwise."]
6001 pub fn avcodec_find_encoder_by_name(name: *const ::std::os::raw::c_char) -> *const AVCodec;
6002}
6003extern "C" {
6004 #[doc = " @return a non-zero number if codec is an encoder, zero otherwise"]
6005 pub fn av_codec_is_encoder(codec: *const AVCodec) -> ::std::os::raw::c_int;
6006}
6007extern "C" {
6008 #[doc = " @return a non-zero number if codec is a decoder, zero otherwise"]
6009 pub fn av_codec_is_decoder(codec: *const AVCodec) -> ::std::os::raw::c_int;
6010}
6011extern "C" {
6012 #[doc = " Return a name for the specified profile, if available.\n\n @param codec the codec that is searched for the given profile\n @param profile the profile value for which a name is requested\n @return A name for the profile if found, NULL otherwise."]
6013 pub fn av_get_profile_name(
6014 codec: *const AVCodec,
6015 profile: ::std::os::raw::c_int,
6016 ) -> *const ::std::os::raw::c_char;
6017}
6018#[doc = " The codec supports this format via the hw_device_ctx interface.\n\n When selecting this format, AVCodecContext.hw_device_ctx should\n have been set to a device of the specified type before calling\n avcodec_open2()."]
6019pub const AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX: _bindgen_ty_3 = 1;
6020#[doc = " The codec supports this format via the hw_frames_ctx interface.\n\n When selecting this format for a decoder,\n AVCodecContext.hw_frames_ctx should be set to a suitable frames\n context inside the get_format() callback. The frames context\n must have been created on a device of the specified type.\n\n When selecting this format for an encoder,\n AVCodecContext.hw_frames_ctx should be set to the context which\n will be used for the input frames before calling avcodec_open2()."]
6021pub const AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX: _bindgen_ty_3 = 2;
6022#[doc = " The codec supports this format by some internal method.\n\n This format can be selected without any additional configuration -\n no device or frames context is required."]
6023pub const AV_CODEC_HW_CONFIG_METHOD_INTERNAL: _bindgen_ty_3 = 4;
6024#[doc = " The codec supports this format by some ad-hoc method.\n\n Additional settings and/or function calls are required. See the\n codec-specific documentation for details. (Methods requiring\n this sort of configuration are deprecated and others should be\n used in preference.)"]
6025pub const AV_CODEC_HW_CONFIG_METHOD_AD_HOC: _bindgen_ty_3 = 8;
6026pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
6027#[repr(C)]
6028#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6029pub struct AVCodecHWConfig {
6030 #[doc = " For decoders, a hardware pixel format which that decoder may be\n able to decode to if suitable hardware is available.\n\n For encoders, a pixel format which the encoder may be able to\n accept. If set to AV_PIX_FMT_NONE, this applies to all pixel\n formats supported by the codec."]
6031 pub pix_fmt: AVPixelFormat,
6032 #[doc = " Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible\n setup methods which can be used with this configuration."]
6033 pub methods: ::std::os::raw::c_int,
6034 #[doc = " The device type associated with the configuration.\n\n Must be set for AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX and\n AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, otherwise unused."]
6035 pub device_type: AVHWDeviceType,
6036}
6037impl Default for AVCodecHWConfig {
6038 fn default() -> Self {
6039 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6040 unsafe {
6041 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6042 s.assume_init()
6043 }
6044 }
6045}
6046extern "C" {
6047 #[doc = " Retrieve supported hardware configurations for a codec.\n\n Values of index from zero to some maximum return the indexed configuration\n descriptor; all other values return NULL. If the codec does not support\n any hardware configurations then it will always return NULL."]
6048 pub fn avcodec_get_hw_config(
6049 codec: *const AVCodec,
6050 index: ::std::os::raw::c_int,
6051 ) -> *const AVCodecHWConfig;
6052}
6053pub const AVFieldOrder_AV_FIELD_UNKNOWN: AVFieldOrder = 0;
6054pub const AVFieldOrder_AV_FIELD_PROGRESSIVE: AVFieldOrder = 1;
6055#[doc = "< Top coded_first, top displayed first"]
6056pub const AVFieldOrder_AV_FIELD_TT: AVFieldOrder = 2;
6057#[doc = "< Bottom coded first, bottom displayed first"]
6058pub const AVFieldOrder_AV_FIELD_BB: AVFieldOrder = 3;
6059#[doc = "< Top coded first, bottom displayed first"]
6060pub const AVFieldOrder_AV_FIELD_TB: AVFieldOrder = 4;
6061#[doc = "< Bottom coded first, top displayed first"]
6062pub const AVFieldOrder_AV_FIELD_BT: AVFieldOrder = 5;
6063pub type AVFieldOrder = ::std::os::raw::c_uint;
6064#[doc = "< discard nothing"]
6065pub const AVDiscard_AVDISCARD_NONE: AVDiscard = -16;
6066#[doc = "< discard useless packets like 0 size packets in avi"]
6067pub const AVDiscard_AVDISCARD_DEFAULT: AVDiscard = 0;
6068#[doc = "< discard all non reference"]
6069pub const AVDiscard_AVDISCARD_NONREF: AVDiscard = 8;
6070#[doc = "< discard all bidirectional frames"]
6071pub const AVDiscard_AVDISCARD_BIDIR: AVDiscard = 16;
6072#[doc = "< discard all non intra frames"]
6073pub const AVDiscard_AVDISCARD_NONINTRA: AVDiscard = 24;
6074#[doc = "< discard all frames except keyframes"]
6075pub const AVDiscard_AVDISCARD_NONKEY: AVDiscard = 32;
6076#[doc = "< discard all"]
6077pub const AVDiscard_AVDISCARD_ALL: AVDiscard = 48;
6078#[doc = " @ingroup lavc_decoding"]
6079pub type AVDiscard = ::std::os::raw::c_int;
6080pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_MAIN: AVAudioServiceType = 0;
6081pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_EFFECTS: AVAudioServiceType = 1;
6082pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED: AVAudioServiceType = 2;
6083pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED: AVAudioServiceType = 3;
6084pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_DIALOGUE: AVAudioServiceType = 4;
6085pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_COMMENTARY: AVAudioServiceType = 5;
6086pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_EMERGENCY: AVAudioServiceType = 6;
6087pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_VOICE_OVER: AVAudioServiceType = 7;
6088pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_KARAOKE: AVAudioServiceType = 8;
6089#[doc = "< Not part of ABI"]
6090pub const AVAudioServiceType_AV_AUDIO_SERVICE_TYPE_NB: AVAudioServiceType = 9;
6091pub type AVAudioServiceType = ::std::os::raw::c_uint;
6092#[doc = " Pan Scan area.\n This specifies the area which should be displayed.\n Note there may be multiple such areas for one frame."]
6093#[repr(C)]
6094#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6095pub struct AVPanScan {
6096 #[doc = " id\n - encoding: Set by user.\n - decoding: Set by libavcodec."]
6097 pub id: ::std::os::raw::c_int,
6098 #[doc = " width and height in 1/16 pel\n - encoding: Set by user.\n - decoding: Set by libavcodec."]
6099 pub width: ::std::os::raw::c_int,
6100 pub height: ::std::os::raw::c_int,
6101 #[doc = " position of the top left corner in 1/16 pel for up to 3 fields/frames\n - encoding: Set by user.\n - decoding: Set by libavcodec."]
6102 pub position: [[i16; 2usize]; 3usize],
6103}
6104#[doc = " This structure describes the bitrate properties of an encoded bitstream. It\n roughly corresponds to a subset the VBV parameters for MPEG-2 or HRD\n parameters for H.264/HEVC."]
6105#[repr(C)]
6106#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6107pub struct AVCPBProperties {
6108 #[doc = " Maximum bitrate of the stream, in bits per second.\n Zero if unknown or unspecified."]
6109 pub max_bitrate: i64,
6110 #[doc = " Minimum bitrate of the stream, in bits per second.\n Zero if unknown or unspecified."]
6111 pub min_bitrate: i64,
6112 #[doc = " Average bitrate of the stream, in bits per second.\n Zero if unknown or unspecified."]
6113 pub avg_bitrate: i64,
6114 #[doc = " The size of the buffer to which the ratecontrol is applied, in bits.\n Zero if unknown or unspecified."]
6115 pub buffer_size: i64,
6116 #[doc = " The delay between the time the packet this structure is associated with\n is received and the time when it should be decoded, in periods of a 27MHz\n clock.\n\n UINT64_MAX when unknown or unspecified."]
6117 pub vbv_delay: u64,
6118}
6119extern "C" {
6120 #[doc = " Allocate a CPB properties structure and initialize its fields to default\n values.\n\n @param size if non-NULL, the size of the allocated struct will be written\n here. This is useful for embedding it in side data.\n\n @return the newly allocated struct or NULL on failure"]
6121 pub fn av_cpb_properties_alloc(size: *mut usize) -> *mut AVCPBProperties;
6122}
6123#[doc = " This structure supplies correlation between a packet timestamp and a wall clock\n production time. The definition follows the Producer Reference Time ('prft')\n as defined in ISO/IEC 14496-12"]
6124#[repr(C)]
6125#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6126pub struct AVProducerReferenceTime {
6127 #[doc = " A UTC timestamp, in microseconds, since Unix epoch (e.g, av_gettime())."]
6128 pub wallclock: i64,
6129 pub flags: ::std::os::raw::c_int,
6130}
6131extern "C" {
6132 #[doc = " Encode extradata length to a buffer. Used by xiph codecs.\n\n @param s buffer to write to; must be at least (v/255+1) bytes long\n @param v size of extradata in bytes\n @return number of bytes written to the buffer."]
6133 pub fn av_xiphlacing(
6134 s: *mut ::std::os::raw::c_uchar,
6135 v: ::std::os::raw::c_uint,
6136 ) -> ::std::os::raw::c_uint;
6137}
6138#[doc = " An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE\n bytes worth of palette. This side data signals that a new palette is\n present."]
6139pub const AVPacketSideDataType_AV_PKT_DATA_PALETTE: AVPacketSideDataType = 0;
6140#[doc = " The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format\n that the extradata buffer was changed and the receiving side should\n act upon it appropriately. The new extradata is embedded in the side\n data buffer and should be immediately used for processing the current\n frame or packet."]
6141pub const AVPacketSideDataType_AV_PKT_DATA_NEW_EXTRADATA: AVPacketSideDataType = 1;
6142#[doc = " An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:\n @code\n u32le param_flags\n if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT)\n s32le channel_count\n if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)\n u64le channel_layout\n if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)\n s32le sample_rate\n if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)\n s32le width\n s32le height\n @endcode"]
6143pub const AVPacketSideDataType_AV_PKT_DATA_PARAM_CHANGE: AVPacketSideDataType = 2;
6144#[doc = " An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of\n structures with info about macroblocks relevant to splitting the\n packet into smaller packets on macroblock edges (e.g. as for RFC 2190).\n That is, it does not necessarily contain info about all macroblocks,\n as long as the distance between macroblocks in the info is smaller\n than the target payload size.\n Each MB info structure is 12 bytes, and is laid out as follows:\n @code\n u32le bit offset from the start of the packet\n u8 current quantizer at the start of the macroblock\n u8 GOB number\n u16le macroblock address within the GOB\n u8 horizontal MV predictor\n u8 vertical MV predictor\n u8 horizontal MV predictor for block number 3\n u8 vertical MV predictor for block number 3\n @endcode"]
6145pub const AVPacketSideDataType_AV_PKT_DATA_H263_MB_INFO: AVPacketSideDataType = 3;
6146#[doc = " This side data should be associated with an audio stream and contains\n ReplayGain information in form of the AVReplayGain struct."]
6147pub const AVPacketSideDataType_AV_PKT_DATA_REPLAYGAIN: AVPacketSideDataType = 4;
6148#[doc = " This side data contains a 3x3 transformation matrix describing an affine\n transformation that needs to be applied to the decoded video frames for\n correct presentation.\n\n See libavutil/display.h for a detailed description of the data."]
6149pub const AVPacketSideDataType_AV_PKT_DATA_DISPLAYMATRIX: AVPacketSideDataType = 5;
6150#[doc = " This side data should be associated with a video stream and contains\n Stereoscopic 3D information in form of the AVStereo3D struct."]
6151pub const AVPacketSideDataType_AV_PKT_DATA_STEREO3D: AVPacketSideDataType = 6;
6152#[doc = " This side data should be associated with an audio stream and corresponds\n to enum AVAudioServiceType."]
6153pub const AVPacketSideDataType_AV_PKT_DATA_AUDIO_SERVICE_TYPE: AVPacketSideDataType = 7;
6154#[doc = " This side data contains quality related information from the encoder.\n @code\n u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad).\n u8 picture type\n u8 error count\n u16 reserved\n u64le[error count] sum of squared differences between encoder in and output\n @endcode"]
6155pub const AVPacketSideDataType_AV_PKT_DATA_QUALITY_STATS: AVPacketSideDataType = 8;
6156#[doc = " This side data contains an integer value representing the stream index\n of a \"fallback\" track. A fallback track indicates an alternate\n track to use when the current track can not be decoded for some reason.\n e.g. no decoder available for codec."]
6157pub const AVPacketSideDataType_AV_PKT_DATA_FALLBACK_TRACK: AVPacketSideDataType = 9;
6158#[doc = " This side data corresponds to the AVCPBProperties struct."]
6159pub const AVPacketSideDataType_AV_PKT_DATA_CPB_PROPERTIES: AVPacketSideDataType = 10;
6160#[doc = " Recommmends skipping the specified number of samples\n @code\n u32le number of samples to skip from start of this packet\n u32le number of samples to skip from end of this packet\n u8 reason for start skip\n u8 reason for end skip (0=padding silence, 1=convergence)\n @endcode"]
6161pub const AVPacketSideDataType_AV_PKT_DATA_SKIP_SAMPLES: AVPacketSideDataType = 11;
6162#[doc = " An AV_PKT_DATA_JP_DUALMONO side data packet indicates that\n the packet may contain \"dual mono\" audio specific to Japanese DTV\n and if it is true, recommends only the selected channel to be used.\n @code\n u8 selected channels (0=main/left, 1=sub/right, 2=both)\n @endcode"]
6163pub const AVPacketSideDataType_AV_PKT_DATA_JP_DUALMONO: AVPacketSideDataType = 12;
6164#[doc = " A list of zero terminated key/value strings. There is no end marker for\n the list, so it is required to rely on the side data size to stop."]
6165pub const AVPacketSideDataType_AV_PKT_DATA_STRINGS_METADATA: AVPacketSideDataType = 13;
6166#[doc = " Subtitle event position\n @code\n u32le x1\n u32le y1\n u32le x2\n u32le y2\n @endcode"]
6167pub const AVPacketSideDataType_AV_PKT_DATA_SUBTITLE_POSITION: AVPacketSideDataType = 14;
6168#[doc = " Data found in BlockAdditional element of matroska container. There is\n no end marker for the data, so it is required to rely on the side data\n size to recognize the end. 8 byte id (as found in BlockAddId) followed\n by data."]
6169pub const AVPacketSideDataType_AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL: AVPacketSideDataType = 15;
6170#[doc = " The optional first identifier line of a WebVTT cue."]
6171pub const AVPacketSideDataType_AV_PKT_DATA_WEBVTT_IDENTIFIER: AVPacketSideDataType = 16;
6172#[doc = " The optional settings (rendering instructions) that immediately\n follow the timestamp specifier of a WebVTT cue."]
6173pub const AVPacketSideDataType_AV_PKT_DATA_WEBVTT_SETTINGS: AVPacketSideDataType = 17;
6174#[doc = " A list of zero terminated key/value strings. There is no end marker for\n the list, so it is required to rely on the side data size to stop. This\n side data includes updated metadata which appeared in the stream."]
6175pub const AVPacketSideDataType_AV_PKT_DATA_METADATA_UPDATE: AVPacketSideDataType = 18;
6176#[doc = " MPEGTS stream ID as uint8_t, this is required to pass the stream ID\n information from the demuxer to the corresponding muxer."]
6177pub const AVPacketSideDataType_AV_PKT_DATA_MPEGTS_STREAM_ID: AVPacketSideDataType = 19;
6178#[doc = " Mastering display metadata (based on SMPTE-2086:2014). This metadata\n should be associated with a video stream and contains data in the form\n of the AVMasteringDisplayMetadata struct."]
6179pub const AVPacketSideDataType_AV_PKT_DATA_MASTERING_DISPLAY_METADATA: AVPacketSideDataType = 20;
6180#[doc = " This side data should be associated with a video stream and corresponds\n to the AVSphericalMapping structure."]
6181pub const AVPacketSideDataType_AV_PKT_DATA_SPHERICAL: AVPacketSideDataType = 21;
6182#[doc = " Content light level (based on CTA-861.3). This metadata should be\n associated with a video stream and contains data in the form of the\n AVContentLightMetadata struct."]
6183pub const AVPacketSideDataType_AV_PKT_DATA_CONTENT_LIGHT_LEVEL: AVPacketSideDataType = 22;
6184#[doc = " ATSC A53 Part 4 Closed Captions. This metadata should be associated with\n a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data.\n The number of bytes of CC data is AVPacketSideData.size."]
6185pub const AVPacketSideDataType_AV_PKT_DATA_A53_CC: AVPacketSideDataType = 23;
6186#[doc = " This side data is encryption initialization data.\n The format is not part of ABI, use av_encryption_init_info_* methods to\n access."]
6187pub const AVPacketSideDataType_AV_PKT_DATA_ENCRYPTION_INIT_INFO: AVPacketSideDataType = 24;
6188#[doc = " This side data contains encryption info for how to decrypt the packet.\n The format is not part of ABI, use av_encryption_info_* methods to access."]
6189pub const AVPacketSideDataType_AV_PKT_DATA_ENCRYPTION_INFO: AVPacketSideDataType = 25;
6190#[doc = " Active Format Description data consisting of a single byte as specified\n in ETSI TS 101 154 using AVActiveFormatDescription enum."]
6191pub const AVPacketSideDataType_AV_PKT_DATA_AFD: AVPacketSideDataType = 26;
6192#[doc = " Producer Reference Time data corresponding to the AVProducerReferenceTime struct,\n usually exported by some encoders (on demand through the prft flag set in the\n AVCodecContext export_side_data field)."]
6193pub const AVPacketSideDataType_AV_PKT_DATA_PRFT: AVPacketSideDataType = 27;
6194#[doc = " ICC profile data consisting of an opaque octet buffer following the\n format described by ISO 15076-1."]
6195pub const AVPacketSideDataType_AV_PKT_DATA_ICC_PROFILE: AVPacketSideDataType = 28;
6196#[doc = " DOVI configuration\n ref:\n dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2, section 2.2\n dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2, section 3.3\n Tags are stored in struct AVDOVIDecoderConfigurationRecord."]
6197pub const AVPacketSideDataType_AV_PKT_DATA_DOVI_CONF: AVPacketSideDataType = 29;
6198#[doc = " Timecode which conforms to SMPTE ST 12-1:2014. The data is an array of 4 uint32_t\n where the first uint32_t describes how many (1-3) of the other timecodes are used.\n The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()\n function in libavutil/timecode.h."]
6199pub const AVPacketSideDataType_AV_PKT_DATA_S12M_TIMECODE: AVPacketSideDataType = 30;
6200#[doc = " HDR10+ dynamic metadata associated with a video frame. The metadata is in\n the form of the AVDynamicHDRPlus struct and contains\n information for color volume transform - application 4 of\n SMPTE 2094-40:2016 standard."]
6201pub const AVPacketSideDataType_AV_PKT_DATA_DYNAMIC_HDR10_PLUS: AVPacketSideDataType = 31;
6202#[doc = " IAMF Mix Gain Parameter Data associated with the audio frame. This metadata\n is in the form of the AVIAMFParamDefinition struct and contains information\n defined in sections 3.6.1 and 3.8.1 of the Immersive Audio Model and\n Formats standard."]
6203pub const AVPacketSideDataType_AV_PKT_DATA_IAMF_MIX_GAIN_PARAM: AVPacketSideDataType = 32;
6204#[doc = " IAMF Demixing Info Parameter Data associated with the audio frame. This\n metadata is in the form of the AVIAMFParamDefinition struct and contains\n information defined in sections 3.6.1 and 3.8.2 of the Immersive Audio Model\n and Formats standard."]
6205pub const AVPacketSideDataType_AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM: AVPacketSideDataType = 33;
6206#[doc = " IAMF Recon Gain Info Parameter Data associated with the audio frame. This\n metadata is in the form of the AVIAMFParamDefinition struct and contains\n information defined in sections 3.6.1 and 3.8.3 of the Immersive Audio Model\n and Formats standard."]
6207pub const AVPacketSideDataType_AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM: AVPacketSideDataType = 34;
6208#[doc = " Ambient viewing environment metadata, as defined by H.274. This metadata\n should be associated with a video stream and contains data in the form\n of the AVAmbientViewingEnvironment struct."]
6209pub const AVPacketSideDataType_AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT: AVPacketSideDataType = 35;
6210#[doc = " The number of side data types.\n This is not part of the public API/ABI in the sense that it may\n change when new side data types are added.\n This must stay the last enum value.\n If its value becomes huge, some code using it\n needs to be updated as it assumes it to be smaller than other limits."]
6211pub const AVPacketSideDataType_AV_PKT_DATA_NB: AVPacketSideDataType = 36;
6212#[doc = " @defgroup lavc_packet_side_data AVPacketSideData\n\n Types and functions for working with AVPacketSideData.\n @{"]
6213pub type AVPacketSideDataType = ::std::os::raw::c_uint;
6214#[doc = " This structure stores auxiliary information for decoding, presenting, or\n otherwise processing the coded stream. It is typically exported by demuxers\n and encoders and can be fed to decoders and muxers either in a per packet\n basis, or as global side data (applying to the entire coded stream).\n\n Global side data is handled as follows:\n - During demuxing, it may be exported through\n @ref AVStream.codecpar.side_data \"AVStream's codec parameters\", which can\n then be passed as input to decoders through the\n @ref AVCodecContext.coded_side_data \"decoder context's side data\", for\n initialization.\n - For muxing, it can be fed through @ref AVStream.codecpar.side_data\n \"AVStream's codec parameters\", typically the output of encoders through\n the @ref AVCodecContext.coded_side_data \"encoder context's side data\", for\n initialization.\n\n Packet specific side data is handled as follows:\n - During demuxing, it may be exported through @ref AVPacket.side_data\n \"AVPacket's side data\", which can then be passed as input to decoders.\n - For muxing, it can be fed through @ref AVPacket.side_data \"AVPacket's\n side data\", typically the output of encoders.\n\n Different modules may accept or export different types of side data\n depending on media type and codec. Refer to @ref AVPacketSideDataType for a\n list of defined types and where they may be found or used."]
6215#[repr(C)]
6216#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6217pub struct AVPacketSideData {
6218 pub data: *mut u8,
6219 pub size: usize,
6220 pub type_: AVPacketSideDataType,
6221}
6222impl Default for AVPacketSideData {
6223 fn default() -> Self {
6224 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6225 unsafe {
6226 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6227 s.assume_init()
6228 }
6229 }
6230}
6231extern "C" {
6232 #[doc = " Allocate a new packet side data.\n\n @param sd pointer to an array of side data to which the side data should\n be added. *sd may be NULL, in which case the array will be\n initialized.\n @param nb_sd pointer to an integer containing the number of entries in\n the array. The integer value will be increased by 1 on success.\n @param type side data type\n @param size desired side data size\n @param flags currently unused. Must be zero\n\n @return pointer to freshly allocated side data on success, or NULL otherwise."]
6233 pub fn av_packet_side_data_new(
6234 psd: *mut *mut AVPacketSideData,
6235 pnb_sd: *mut ::std::os::raw::c_int,
6236 type_: AVPacketSideDataType,
6237 size: usize,
6238 flags: ::std::os::raw::c_int,
6239 ) -> *mut AVPacketSideData;
6240}
6241extern "C" {
6242 #[doc = " Wrap existing data as packet side data.\n\n @param sd pointer to an array of side data to which the side data should\n be added. *sd may be NULL, in which case the array will be\n initialized\n @param nb_sd pointer to an integer containing the number of entries in\n the array. The integer value will be increased by 1 on success.\n @param type side data type\n @param data a data array. It must be allocated with the av_malloc() family\n of functions. The ownership of the data is transferred to the\n side data array on success\n @param size size of the data array\n @param flags currently unused. Must be zero\n\n @return pointer to freshly allocated side data on success, or NULL otherwise\n On failure, the side data array is unchanged and the data remains\n owned by the caller."]
6243 pub fn av_packet_side_data_add(
6244 sd: *mut *mut AVPacketSideData,
6245 nb_sd: *mut ::std::os::raw::c_int,
6246 type_: AVPacketSideDataType,
6247 data: *mut ::std::os::raw::c_void,
6248 size: usize,
6249 flags: ::std::os::raw::c_int,
6250 ) -> *mut AVPacketSideData;
6251}
6252extern "C" {
6253 #[doc = " Get side information from a side data array.\n\n @param sd the array from which the side data should be fetched\n @param nb_sd value containing the number of entries in the array.\n @param type desired side information type\n\n @return pointer to side data if present or NULL otherwise"]
6254 pub fn av_packet_side_data_get(
6255 sd: *const AVPacketSideData,
6256 nb_sd: ::std::os::raw::c_int,
6257 type_: AVPacketSideDataType,
6258 ) -> *const AVPacketSideData;
6259}
6260extern "C" {
6261 #[doc = " Remove side data of the given type from a side data array.\n\n @param sd the array from which the side data should be removed\n @param nb_sd pointer to an integer containing the number of entries in\n the array. Will be reduced by the amount of entries removed\n upon return\n @param type side information type"]
6262 pub fn av_packet_side_data_remove(
6263 sd: *mut AVPacketSideData,
6264 nb_sd: *mut ::std::os::raw::c_int,
6265 type_: AVPacketSideDataType,
6266 );
6267}
6268extern "C" {
6269 #[doc = " Convenience function to free all the side data stored in an array, and\n the array itself.\n\n @param sd pointer to array of side data to free. Will be set to NULL\n upon return.\n @param nb_sd pointer to an integer containing the number of entries in\n the array. Will be set to 0 upon return."]
6270 pub fn av_packet_side_data_free(
6271 sd: *mut *mut AVPacketSideData,
6272 nb_sd: *mut ::std::os::raw::c_int,
6273 );
6274}
6275extern "C" {
6276 pub fn av_packet_side_data_name(type_: AVPacketSideDataType) -> *const ::std::os::raw::c_char;
6277}
6278#[doc = " This structure stores compressed data. It is typically exported by demuxers\n and then passed as input to decoders, or received as output from encoders and\n then passed to muxers.\n\n For video, it should typically contain one compressed frame. For audio it may\n contain several compressed frames. Encoders are allowed to output empty\n packets, with no compressed data, containing only side data\n (e.g. to update some stream parameters at the end of encoding).\n\n The semantics of data ownership depends on the buf field.\n If it is set, the packet data is dynamically allocated and is\n valid indefinitely until a call to av_packet_unref() reduces the\n reference count to 0.\n\n If the buf field is not set av_packet_ref() would make a copy instead\n of increasing the reference count.\n\n The side data is always allocated with av_malloc(), copied by\n av_packet_ref() and freed by av_packet_unref().\n\n sizeof(AVPacket) being a part of the public ABI is deprecated. once\n av_init_packet() is removed, new packets will only be able to be allocated\n with av_packet_alloc(), and new fields may be added to the end of the struct\n with a minor bump.\n\n @see av_packet_alloc\n @see av_packet_ref\n @see av_packet_unref"]
6279#[repr(C)]
6280#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6281pub struct AVPacket {
6282 #[doc = " A reference to the reference-counted buffer where the packet data is\n stored.\n May be NULL, then the packet data is not reference-counted."]
6283 pub buf: *mut AVBufferRef,
6284 #[doc = " Presentation timestamp in AVStream->time_base units; the time at which\n the decompressed packet will be presented to the user.\n Can be AV_NOPTS_VALUE if it is not stored in the file.\n pts MUST be larger or equal to dts as presentation cannot happen before\n decompression, unless one wants to view hex dumps. Some formats misuse\n the terms dts and pts/cts to mean something different. Such timestamps\n must be converted to true pts/dts before they are stored in AVPacket."]
6285 pub pts: i64,
6286 #[doc = " Decompression timestamp in AVStream->time_base units; the time at which\n the packet is decompressed.\n Can be AV_NOPTS_VALUE if it is not stored in the file."]
6287 pub dts: i64,
6288 pub data: *mut u8,
6289 pub size: ::std::os::raw::c_int,
6290 pub stream_index: ::std::os::raw::c_int,
6291 #[doc = " A combination of AV_PKT_FLAG values"]
6292 pub flags: ::std::os::raw::c_int,
6293 #[doc = " Additional packet data that can be provided by the container.\n Packet can contain several types of side information."]
6294 pub side_data: *mut AVPacketSideData,
6295 pub side_data_elems: ::std::os::raw::c_int,
6296 #[doc = " Duration of this packet in AVStream->time_base units, 0 if unknown.\n Equals next_pts - this_pts in presentation order."]
6297 pub duration: i64,
6298 #[doc = "< byte position in stream, -1 if unknown"]
6299 pub pos: i64,
6300 #[doc = " for some private data of the user"]
6301 pub opaque: *mut ::std::os::raw::c_void,
6302 #[doc = " AVBufferRef for free use by the API user. FFmpeg will never check the\n contents of the buffer ref. FFmpeg calls av_buffer_unref() on it when\n the packet is unreferenced. av_packet_copy_props() calls create a new\n reference with av_buffer_ref() for the target packet's opaque_ref field.\n\n This is unrelated to the opaque field, although it serves a similar\n purpose."]
6303 pub opaque_ref: *mut AVBufferRef,
6304 #[doc = " Time base of the packet's timestamps.\n In the future, this field may be set on packets output by encoders or\n demuxers, but its value will be by default ignored on input to decoders\n or muxers."]
6305 pub time_base: AVRational,
6306}
6307impl Default for AVPacket {
6308 fn default() -> Self {
6309 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6310 unsafe {
6311 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6312 s.assume_init()
6313 }
6314 }
6315}
6316#[repr(C)]
6317#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6318pub struct AVPacketList {
6319 pub pkt: AVPacket,
6320 pub next: *mut AVPacketList,
6321}
6322impl Default for AVPacketList {
6323 fn default() -> Self {
6324 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6325 unsafe {
6326 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6327 s.assume_init()
6328 }
6329 }
6330}
6331pub const AVSideDataParamChangeFlags_AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE:
6332 AVSideDataParamChangeFlags = 4;
6333pub const AVSideDataParamChangeFlags_AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS:
6334 AVSideDataParamChangeFlags = 8;
6335pub type AVSideDataParamChangeFlags = ::std::os::raw::c_uint;
6336extern "C" {
6337 #[doc = " Allocate an AVPacket and set its fields to default values. The resulting\n struct must be freed using av_packet_free().\n\n @return An AVPacket filled with default values or NULL on failure.\n\n @note this only allocates the AVPacket itself, not the data buffers. Those\n must be allocated through other means such as av_new_packet.\n\n @see av_new_packet"]
6338 pub fn av_packet_alloc() -> *mut AVPacket;
6339}
6340extern "C" {
6341 #[doc = " Create a new packet that references the same data as src.\n\n This is a shortcut for av_packet_alloc()+av_packet_ref().\n\n @return newly created AVPacket on success, NULL on error.\n\n @see av_packet_alloc\n @see av_packet_ref"]
6342 pub fn av_packet_clone(src: *const AVPacket) -> *mut AVPacket;
6343}
6344extern "C" {
6345 #[doc = " Free the packet, if the packet is reference counted, it will be\n unreferenced first.\n\n @param pkt packet to be freed. The pointer will be set to NULL.\n @note passing NULL is a no-op."]
6346 pub fn av_packet_free(pkt: *mut *mut AVPacket);
6347}
6348extern "C" {
6349 #[doc = " Initialize optional fields of a packet with default values.\n\n Note, this does not touch the data and size members, which have to be\n initialized separately.\n\n @param pkt packet\n\n @see av_packet_alloc\n @see av_packet_unref\n\n @deprecated This function is deprecated. Once it's removed,\nsizeof(AVPacket) will not be a part of the ABI anymore."]
6350 pub fn av_init_packet(pkt: *mut AVPacket);
6351}
6352extern "C" {
6353 #[doc = " Allocate the payload of a packet and initialize its fields with\n default values.\n\n @param pkt packet\n @param size wanted payload size\n @return 0 if OK, AVERROR_xxx otherwise"]
6354 pub fn av_new_packet(pkt: *mut AVPacket, size: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
6355}
6356extern "C" {
6357 #[doc = " Reduce packet size, correctly zeroing padding\n\n @param pkt packet\n @param size new size"]
6358 pub fn av_shrink_packet(pkt: *mut AVPacket, size: ::std::os::raw::c_int);
6359}
6360extern "C" {
6361 #[doc = " Increase packet size, correctly zeroing padding\n\n @param pkt packet\n @param grow_by number of bytes by which to increase the size of the packet"]
6362 pub fn av_grow_packet(
6363 pkt: *mut AVPacket,
6364 grow_by: ::std::os::raw::c_int,
6365 ) -> ::std::os::raw::c_int;
6366}
6367extern "C" {
6368 #[doc = " Initialize a reference-counted packet from av_malloc()ed data.\n\n @param pkt packet to be initialized. This function will set the data, size,\n and buf fields, all others are left untouched.\n @param data Data allocated by av_malloc() to be used as packet data. If this\n function returns successfully, the data is owned by the underlying AVBuffer.\n The caller may not access the data through other means.\n @param size size of data in bytes, without the padding. I.e. the full buffer\n size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE.\n\n @return 0 on success, a negative AVERROR on error"]
6369 pub fn av_packet_from_data(
6370 pkt: *mut AVPacket,
6371 data: *mut u8,
6372 size: ::std::os::raw::c_int,
6373 ) -> ::std::os::raw::c_int;
6374}
6375extern "C" {
6376 #[doc = " Allocate new information of a packet.\n\n @param pkt packet\n @param type side information type\n @param size side information size\n @return pointer to fresh allocated data or NULL otherwise"]
6377 pub fn av_packet_new_side_data(
6378 pkt: *mut AVPacket,
6379 type_: AVPacketSideDataType,
6380 size: usize,
6381 ) -> *mut u8;
6382}
6383extern "C" {
6384 #[doc = " Wrap an existing array as a packet side data.\n\n @param pkt packet\n @param type side information type\n @param data the side data array. It must be allocated with the av_malloc()\n family of functions. The ownership of the data is transferred to\n pkt.\n @param size side information size\n @return a non-negative number on success, a negative AVERROR code on\n failure. On failure, the packet is unchanged and the data remains\n owned by the caller."]
6385 pub fn av_packet_add_side_data(
6386 pkt: *mut AVPacket,
6387 type_: AVPacketSideDataType,
6388 data: *mut u8,
6389 size: usize,
6390 ) -> ::std::os::raw::c_int;
6391}
6392extern "C" {
6393 #[doc = " Shrink the already allocated side data buffer\n\n @param pkt packet\n @param type side information type\n @param size new side information size\n @return 0 on success, < 0 on failure"]
6394 pub fn av_packet_shrink_side_data(
6395 pkt: *mut AVPacket,
6396 type_: AVPacketSideDataType,
6397 size: usize,
6398 ) -> ::std::os::raw::c_int;
6399}
6400extern "C" {
6401 #[doc = " Get side information from packet.\n\n @param pkt packet\n @param type desired side information type\n @param size If supplied, *size will be set to the size of the side data\n or to zero if the desired side data is not present.\n @return pointer to data if present or NULL otherwise"]
6402 pub fn av_packet_get_side_data(
6403 pkt: *const AVPacket,
6404 type_: AVPacketSideDataType,
6405 size: *mut usize,
6406 ) -> *mut u8;
6407}
6408extern "C" {
6409 #[doc = " Pack a dictionary for use in side_data.\n\n @param dict The dictionary to pack.\n @param size pointer to store the size of the returned data\n @return pointer to data if successful, NULL otherwise"]
6410 pub fn av_packet_pack_dictionary(dict: *mut AVDictionary, size: *mut usize) -> *mut u8;
6411}
6412extern "C" {
6413 #[doc = " Unpack a dictionary from side_data.\n\n @param data data from side_data\n @param size size of the data\n @param dict the metadata storage dictionary\n @return 0 on success, < 0 on failure"]
6414 pub fn av_packet_unpack_dictionary(
6415 data: *const u8,
6416 size: usize,
6417 dict: *mut *mut AVDictionary,
6418 ) -> ::std::os::raw::c_int;
6419}
6420extern "C" {
6421 #[doc = " Convenience function to free all the side data stored.\n All the other fields stay untouched.\n\n @param pkt packet"]
6422 pub fn av_packet_free_side_data(pkt: *mut AVPacket);
6423}
6424extern "C" {
6425 #[doc = " Setup a new reference to the data described by a given packet\n\n If src is reference-counted, setup dst as a new reference to the\n buffer in src. Otherwise allocate a new buffer in dst and copy the\n data from src into it.\n\n All the other fields are copied from src.\n\n @see av_packet_unref\n\n @param dst Destination packet. Will be completely overwritten.\n @param src Source packet\n\n @return 0 on success, a negative AVERROR on error. On error, dst\n will be blank (as if returned by av_packet_alloc())."]
6426 pub fn av_packet_ref(dst: *mut AVPacket, src: *const AVPacket) -> ::std::os::raw::c_int;
6427}
6428extern "C" {
6429 #[doc = " Wipe the packet.\n\n Unreference the buffer referenced by the packet and reset the\n remaining packet fields to their default values.\n\n @param pkt The packet to be unreferenced."]
6430 pub fn av_packet_unref(pkt: *mut AVPacket);
6431}
6432extern "C" {
6433 #[doc = " Move every field in src to dst and reset src.\n\n @see av_packet_unref\n\n @param src Source packet, will be reset\n @param dst Destination packet"]
6434 pub fn av_packet_move_ref(dst: *mut AVPacket, src: *mut AVPacket);
6435}
6436extern "C" {
6437 #[doc = " Copy only \"properties\" fields from src to dst.\n\n Properties for the purpose of this function are all the fields\n beside those related to the packet data (buf, data, size)\n\n @param dst Destination packet\n @param src Source packet\n\n @return 0 on success AVERROR on failure."]
6438 pub fn av_packet_copy_props(dst: *mut AVPacket, src: *const AVPacket) -> ::std::os::raw::c_int;
6439}
6440extern "C" {
6441 #[doc = " Ensure the data described by a given packet is reference counted.\n\n @note This function does not ensure that the reference will be writable.\n Use av_packet_make_writable instead for that purpose.\n\n @see av_packet_ref\n @see av_packet_make_writable\n\n @param pkt packet whose data should be made reference counted.\n\n @return 0 on success, a negative AVERROR on error. On failure, the\n packet is unchanged."]
6442 pub fn av_packet_make_refcounted(pkt: *mut AVPacket) -> ::std::os::raw::c_int;
6443}
6444extern "C" {
6445 #[doc = " Create a writable reference for the data described by a given packet,\n avoiding data copy if possible.\n\n @param pkt Packet whose data should be made writable.\n\n @return 0 on success, a negative AVERROR on failure. On failure, the\n packet is unchanged."]
6446 pub fn av_packet_make_writable(pkt: *mut AVPacket) -> ::std::os::raw::c_int;
6447}
6448extern "C" {
6449 #[doc = " Convert valid timing fields (timestamps / durations) in a packet from one\n timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be\n ignored.\n\n @param pkt packet on which the conversion will be performed\n @param tb_src source timebase, in which the timing fields in pkt are\n expressed\n @param tb_dst destination timebase, to which the timing fields will be\n converted"]
6450 pub fn av_packet_rescale_ts(pkt: *mut AVPacket, tb_src: AVRational, tb_dst: AVRational);
6451}
6452#[doc = " This struct describes the properties of a single codec described by an\n AVCodecID.\n @see avcodec_descriptor_get()"]
6453#[repr(C)]
6454#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6455pub struct AVCodecDescriptor {
6456 pub id: AVCodecID,
6457 pub type_: AVMediaType,
6458 #[doc = " Name of the codec described by this descriptor. It is non-empty and\n unique for each codec descriptor. It should contain alphanumeric\n characters and '_' only."]
6459 pub name: *const ::std::os::raw::c_char,
6460 #[doc = " A more descriptive name for this codec. May be NULL."]
6461 pub long_name: *const ::std::os::raw::c_char,
6462 #[doc = " Codec properties, a combination of AV_CODEC_PROP_* flags."]
6463 pub props: ::std::os::raw::c_int,
6464 #[doc = " MIME type(s) associated with the codec.\n May be NULL; if not, a NULL-terminated array of MIME types.\n The first item is always non-NULL and is the preferred MIME type."]
6465 pub mime_types: *const *const ::std::os::raw::c_char,
6466 #[doc = " If non-NULL, an array of profiles recognized for this codec.\n Terminated with AV_PROFILE_UNKNOWN."]
6467 pub profiles: *const AVProfile,
6468}
6469impl Default for AVCodecDescriptor {
6470 fn default() -> Self {
6471 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6472 unsafe {
6473 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6474 s.assume_init()
6475 }
6476 }
6477}
6478extern "C" {
6479 #[doc = " @return descriptor for given codec ID or NULL if no descriptor exists."]
6480 pub fn avcodec_descriptor_get(id: AVCodecID) -> *const AVCodecDescriptor;
6481}
6482extern "C" {
6483 #[doc = " Iterate over all codec descriptors known to libavcodec.\n\n @param prev previous descriptor. NULL to get the first descriptor.\n\n @return next descriptor or NULL after the last descriptor"]
6484 pub fn avcodec_descriptor_next(prev: *const AVCodecDescriptor) -> *const AVCodecDescriptor;
6485}
6486extern "C" {
6487 #[doc = " @return codec descriptor with the given name or NULL if no such descriptor\n exists."]
6488 pub fn avcodec_descriptor_get_by_name(
6489 name: *const ::std::os::raw::c_char,
6490 ) -> *const AVCodecDescriptor;
6491}
6492#[doc = " This struct describes the properties of an encoded stream.\n\n sizeof(AVCodecParameters) is not a part of the public ABI, this struct must\n be allocated with avcodec_parameters_alloc() and freed with\n avcodec_parameters_free()."]
6493#[repr(C)]
6494#[derive(Copy, Clone)]
6495pub struct AVCodecParameters {
6496 #[doc = " General type of the encoded data."]
6497 pub codec_type: AVMediaType,
6498 #[doc = " Specific type of the encoded data (the codec used)."]
6499 pub codec_id: AVCodecID,
6500 #[doc = " Additional information about the codec (corresponds to the AVI FOURCC)."]
6501 pub codec_tag: u32,
6502 #[doc = " Extra binary data needed for initializing the decoder, codec-dependent.\n\n Must be allocated with av_malloc() and will be freed by\n avcodec_parameters_free(). The allocated size of extradata must be at\n least extradata_size + AV_INPUT_BUFFER_PADDING_SIZE, with the padding\n bytes zeroed."]
6503 pub extradata: *mut u8,
6504 #[doc = " Size of the extradata content in bytes."]
6505 pub extradata_size: ::std::os::raw::c_int,
6506 #[doc = " Additional data associated with the entire stream.\n\n Should be allocated with av_packet_side_data_new() or\n av_packet_side_data_add(), and will be freed by avcodec_parameters_free()."]
6507 pub coded_side_data: *mut AVPacketSideData,
6508 #[doc = " Amount of entries in @ref coded_side_data."]
6509 pub nb_coded_side_data: ::std::os::raw::c_int,
6510 #[doc = " - video: the pixel format, the value corresponds to enum AVPixelFormat.\n - audio: the sample format, the value corresponds to enum AVSampleFormat."]
6511 pub format: ::std::os::raw::c_int,
6512 #[doc = " The average bitrate of the encoded data (in bits per second)."]
6513 pub bit_rate: i64,
6514 #[doc = " The number of bits per sample in the codedwords.\n\n This is basically the bitrate per sample. It is mandatory for a bunch of\n formats to actually decode them. It's the number of bits for one sample in\n the actual coded bitstream.\n\n This could be for example 4 for ADPCM\n For PCM formats this matches bits_per_raw_sample\n Can be 0"]
6515 pub bits_per_coded_sample: ::std::os::raw::c_int,
6516 #[doc = " This is the number of valid bits in each output sample. If the\n sample format has more bits, the least significant bits are additional\n padding bits, which are always 0. Use right shifts to reduce the sample\n to its actual size. For example, audio formats with 24 bit samples will\n have bits_per_raw_sample set to 24, and format set to AV_SAMPLE_FMT_S32.\n To get the original sample use \"(int32_t)sample >> 8\".\"\n\n For ADPCM this might be 12 or 16 or similar\n Can be 0"]
6517 pub bits_per_raw_sample: ::std::os::raw::c_int,
6518 #[doc = " Codec-specific bitstream restrictions that the stream conforms to."]
6519 pub profile: ::std::os::raw::c_int,
6520 pub level: ::std::os::raw::c_int,
6521 #[doc = " Video only. The dimensions of the video frame in pixels."]
6522 pub width: ::std::os::raw::c_int,
6523 pub height: ::std::os::raw::c_int,
6524 #[doc = " Video only. The aspect ratio (width / height) which a single pixel\n should have when displayed.\n\n When the aspect ratio is unknown / undefined, the numerator should be\n set to 0 (the denominator may have any value)."]
6525 pub sample_aspect_ratio: AVRational,
6526 #[doc = " Video only. Number of frames per second, for streams with constant frame\n durations. Should be set to { 0, 1 } when some frames have differing\n durations or if the value is not known.\n\n @note This field correponds to values that are stored in codec-level\n headers and is typically overridden by container/transport-layer\n timestamps, when available. It should thus be used only as a last resort,\n when no higher-level timing information is available."]
6527 pub framerate: AVRational,
6528 #[doc = " Video only. The order of the fields in interlaced video."]
6529 pub field_order: AVFieldOrder,
6530 #[doc = " Video only. Additional colorspace characteristics."]
6531 pub color_range: AVColorRange,
6532 pub color_primaries: AVColorPrimaries,
6533 pub color_trc: AVColorTransferCharacteristic,
6534 pub color_space: AVColorSpace,
6535 pub chroma_location: AVChromaLocation,
6536 #[doc = " Video only. Number of delayed frames."]
6537 pub video_delay: ::std::os::raw::c_int,
6538 #[doc = " Audio only. The channel layout and number of channels."]
6539 pub ch_layout: AVChannelLayout,
6540 #[doc = " Audio only. The number of audio samples per second."]
6541 pub sample_rate: ::std::os::raw::c_int,
6542 #[doc = " Audio only. The number of bytes per coded audio frame, required by some\n formats.\n\n Corresponds to nBlockAlign in WAVEFORMATEX."]
6543 pub block_align: ::std::os::raw::c_int,
6544 #[doc = " Audio only. Audio frame size, if known. Required by some formats to be static."]
6545 pub frame_size: ::std::os::raw::c_int,
6546 #[doc = " Audio only. The amount of padding (in samples) inserted by the encoder at\n the beginning of the audio. I.e. this number of leading decoded samples\n must be discarded by the caller to get the original audio without leading\n padding."]
6547 pub initial_padding: ::std::os::raw::c_int,
6548 #[doc = " Audio only. The amount of padding (in samples) appended by the encoder to\n the end of the audio. I.e. this number of decoded samples must be\n discarded by the caller from the end of the stream to get the original\n audio without any trailing padding."]
6549 pub trailing_padding: ::std::os::raw::c_int,
6550 #[doc = " Audio only. Number of samples to skip after a discontinuity."]
6551 pub seek_preroll: ::std::os::raw::c_int,
6552}
6553impl Default for AVCodecParameters {
6554 fn default() -> Self {
6555 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6556 unsafe {
6557 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6558 s.assume_init()
6559 }
6560 }
6561}
6562extern "C" {
6563 #[doc = " Allocate a new AVCodecParameters and set its fields to default values\n (unknown/invalid/0). The returned struct must be freed with\n avcodec_parameters_free()."]
6564 pub fn avcodec_parameters_alloc() -> *mut AVCodecParameters;
6565}
6566extern "C" {
6567 #[doc = " Free an AVCodecParameters instance and everything associated with it and\n write NULL to the supplied pointer."]
6568 pub fn avcodec_parameters_free(par: *mut *mut AVCodecParameters);
6569}
6570extern "C" {
6571 #[doc = " Copy the contents of src to dst. Any allocated fields in dst are freed and\n replaced with newly allocated duplicates of the corresponding fields in src.\n\n @return >= 0 on success, a negative AVERROR code on failure."]
6572 pub fn avcodec_parameters_copy(
6573 dst: *mut AVCodecParameters,
6574 src: *const AVCodecParameters,
6575 ) -> ::std::os::raw::c_int;
6576}
6577extern "C" {
6578 #[doc = " This function is the same as av_get_audio_frame_duration(), except it works\n with AVCodecParameters instead of an AVCodecContext."]
6579 pub fn av_get_audio_frame_duration2(
6580 par: *mut AVCodecParameters,
6581 frame_bytes: ::std::os::raw::c_int,
6582 ) -> ::std::os::raw::c_int;
6583}
6584#[doc = " @ingroup lavc_encoding"]
6585#[repr(C)]
6586#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)]
6587pub struct RcOverride {
6588 pub start_frame: ::std::os::raw::c_int,
6589 pub end_frame: ::std::os::raw::c_int,
6590 pub qscale: ::std::os::raw::c_int,
6591 pub quality_factor: f32,
6592}
6593#[doc = " main external API structure.\n New fields can be added to the end with minor version bumps.\n Removal, reordering and changes to existing fields require a major\n version bump.\n You can use AVOptions (av_opt* / av_set/get*()) to access these fields from user\n applications.\n The name string for AVOptions options matches the associated command line\n parameter name and can be found in libavcodec/options_table.h\n The AVOption/command line parameter names differ in some cases from the C\n structure field names for historic reasons or brevity.\n sizeof(AVCodecContext) must not be used outside libav*."]
6594#[repr(C)]
6595#[derive(Copy, Clone)]
6596pub struct AVCodecContext {
6597 #[doc = " information on struct for av_log\n - set by avcodec_alloc_context3"]
6598 pub av_class: *const AVClass,
6599 pub log_level_offset: ::std::os::raw::c_int,
6600 pub codec_type: AVMediaType,
6601 pub codec: *const AVCodec,
6602 pub codec_id: AVCodecID,
6603 #[doc = " fourcc (LSB first, so \"ABCD\" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').\n This is used to work around some encoder bugs.\n A demuxer should set this to what is stored in the field used to identify the codec.\n If there are multiple such fields in a container then the demuxer should choose the one\n which maximizes the information about the used codec.\n If the codec tag field in a container is larger than 32 bits then the demuxer should\n remap the longer ID to 32 bits with a table or other structure. Alternatively a new\n extra_codec_tag + size could be added but for this a clear advantage must be demonstrated\n first.\n - encoding: Set by user, if not then the default based on codec_id will be used.\n - decoding: Set by user, will be converted to uppercase by libavcodec during init."]
6604 pub codec_tag: ::std::os::raw::c_uint,
6605 pub priv_data: *mut ::std::os::raw::c_void,
6606 #[doc = " Private context used for internal data.\n\n Unlike priv_data, this is not codec-specific. It is used in general\n libavcodec functions."]
6607 pub internal: *mut AVCodecInternal,
6608 #[doc = " Private data of the user, can be used to carry app specific stuff.\n - encoding: Set by user.\n - decoding: Set by user."]
6609 pub opaque: *mut ::std::os::raw::c_void,
6610 #[doc = " the average bitrate\n - encoding: Set by user; unused for constant quantizer encoding.\n - decoding: Set by user, may be overwritten by libavcodec\n if this info is available in the stream"]
6611 pub bit_rate: i64,
6612 #[doc = " AV_CODEC_FLAG_*.\n - encoding: Set by user.\n - decoding: Set by user."]
6613 pub flags: ::std::os::raw::c_int,
6614 #[doc = " AV_CODEC_FLAG2_*\n - encoding: Set by user.\n - decoding: Set by user."]
6615 pub flags2: ::std::os::raw::c_int,
6616 #[doc = " some codecs need / can use extradata like Huffman tables.\n MJPEG: Huffman tables\n rv10: additional flags\n MPEG-4: global headers (they can be in the bitstream or here)\n The allocated memory should be AV_INPUT_BUFFER_PADDING_SIZE bytes larger\n than extradata_size to avoid problems if it is read with the bitstream reader.\n The bytewise contents of extradata must not depend on the architecture or CPU endianness.\n Must be allocated with the av_malloc() family of functions.\n - encoding: Set/allocated/freed by libavcodec.\n - decoding: Set/allocated/freed by user."]
6617 pub extradata: *mut u8,
6618 pub extradata_size: ::std::os::raw::c_int,
6619 #[doc = " This is the fundamental unit of time (in seconds) in terms\n of which frame timestamps are represented. For fixed-fps content,\n timebase should be 1/framerate and timestamp increments should be\n identically 1.\n This often, but not always is the inverse of the frame rate or field rate\n for video. 1/time_base is not the average frame rate if the frame rate is not\n constant.\n\n Like containers, elementary streams also can store timestamps, 1/time_base\n is the unit in which these timestamps are specified.\n As example of such codec time base see ISO/IEC 14496-2:2001(E)\n vop_time_increment_resolution and fixed_vop_rate\n (fixed_vop_rate == 0 implies that it is different from the framerate)\n\n - encoding: MUST be set by user.\n - decoding: unused."]
6620 pub time_base: AVRational,
6621 #[doc = " Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.\n - encoding: unused.\n - decoding: set by user."]
6622 pub pkt_timebase: AVRational,
6623 #[doc = " - decoding: For codecs that store a framerate value in the compressed\n bitstream, the decoder may export it here. { 0, 1} when\n unknown.\n - encoding: May be used to signal the framerate of CFR content to an\n encoder."]
6624 pub framerate: AVRational,
6625 #[doc = " For some codecs, the time base is closer to the field rate than the frame rate.\n Most notably, H.264 and MPEG-2 specify time_base as half of frame duration\n if no telecine is used ...\n\n Set to time_base ticks per frame. Default 1, e.g., H.264/MPEG-2 set it to 2.\n\n @deprecated\n - decoding: Use AVCodecDescriptor.props & AV_CODEC_PROP_FIELDS\n - encoding: Set AVCodecContext.framerate instead\n"]
6626 pub ticks_per_frame: ::std::os::raw::c_int,
6627 #[doc = " Codec delay.\n\n Encoding: Number of frames delay there will be from the encoder input to\n the decoder output. (we assume the decoder matches the spec)\n Decoding: Number of frames delay in addition to what a standard decoder\n as specified in the spec would produce.\n\n Video:\n Number of frames the decoded output will be delayed relative to the\n encoded input.\n\n Audio:\n For encoding, this field is unused (see initial_padding).\n\n For decoding, this is the number of samples the decoder needs to\n output before the decoder's output is valid. When seeking, you should\n start decoding this many samples prior to your desired seek point.\n\n - encoding: Set by libavcodec.\n - decoding: Set by libavcodec."]
6628 pub delay: ::std::os::raw::c_int,
6629 #[doc = " picture width / height.\n\n @note Those fields may not match the values of the last\n AVFrame output by avcodec_receive_frame() due frame\n reordering.\n\n - encoding: MUST be set by user.\n - decoding: May be set by the user before opening the decoder if known e.g.\n from the container. Some decoders will require the dimensions\n to be set by the caller. During decoding, the decoder may\n overwrite those values as required while parsing the data."]
6630 pub width: ::std::os::raw::c_int,
6631 #[doc = " picture width / height.\n\n @note Those fields may not match the values of the last\n AVFrame output by avcodec_receive_frame() due frame\n reordering.\n\n - encoding: MUST be set by user.\n - decoding: May be set by the user before opening the decoder if known e.g.\n from the container. Some decoders will require the dimensions\n to be set by the caller. During decoding, the decoder may\n overwrite those values as required while parsing the data."]
6632 pub height: ::std::os::raw::c_int,
6633 #[doc = " Bitstream width / height, may be different from width/height e.g. when\n the decoded frame is cropped before being output or lowres is enabled.\n\n @note Those field may not match the value of the last\n AVFrame output by avcodec_receive_frame() due frame\n reordering.\n\n - encoding: unused\n - decoding: May be set by the user before opening the decoder if known\n e.g. from the container. During decoding, the decoder may\n overwrite those values as required while parsing the data."]
6634 pub coded_width: ::std::os::raw::c_int,
6635 #[doc = " Bitstream width / height, may be different from width/height e.g. when\n the decoded frame is cropped before being output or lowres is enabled.\n\n @note Those field may not match the value of the last\n AVFrame output by avcodec_receive_frame() due frame\n reordering.\n\n - encoding: unused\n - decoding: May be set by the user before opening the decoder if known\n e.g. from the container. During decoding, the decoder may\n overwrite those values as required while parsing the data."]
6636 pub coded_height: ::std::os::raw::c_int,
6637 #[doc = " sample aspect ratio (0 if unknown)\n That is the width of a pixel divided by the height of the pixel.\n Numerator and denominator must be relatively prime and smaller than 256 for some video standards.\n - encoding: Set by user.\n - decoding: Set by libavcodec."]
6638 pub sample_aspect_ratio: AVRational,
6639 #[doc = " Pixel format, see AV_PIX_FMT_xxx.\n May be set by the demuxer if known from headers.\n May be overridden by the decoder if it knows better.\n\n @note This field may not match the value of the last\n AVFrame output by avcodec_receive_frame() due frame\n reordering.\n\n - encoding: Set by user.\n - decoding: Set by user if known, overridden by libavcodec while\n parsing the data."]
6640 pub pix_fmt: AVPixelFormat,
6641 #[doc = " Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.\n - encoding: unused.\n - decoding: Set by libavcodec before calling get_format()"]
6642 pub sw_pix_fmt: AVPixelFormat,
6643 #[doc = " Chromaticity coordinates of the source primaries.\n - encoding: Set by user\n - decoding: Set by libavcodec"]
6644 pub color_primaries: AVColorPrimaries,
6645 #[doc = " Color Transfer Characteristic.\n - encoding: Set by user\n - decoding: Set by libavcodec"]
6646 pub color_trc: AVColorTransferCharacteristic,
6647 #[doc = " YUV colorspace type.\n - encoding: Set by user\n - decoding: Set by libavcodec"]
6648 pub colorspace: AVColorSpace,
6649 #[doc = " MPEG vs JPEG YUV range.\n - encoding: Set by user to override the default output color range value,\n If not specified, libavcodec sets the color range depending on the\n output format.\n - decoding: Set by libavcodec, can be set by the user to propagate the\n color range to components reading from the decoder context."]
6650 pub color_range: AVColorRange,
6651 #[doc = " This defines the location of chroma samples.\n - encoding: Set by user\n - decoding: Set by libavcodec"]
6652 pub chroma_sample_location: AVChromaLocation,
6653 #[doc = " Field order\n - encoding: set by libavcodec\n - decoding: Set by user."]
6654 pub field_order: AVFieldOrder,
6655 #[doc = " number of reference frames\n - encoding: Set by user.\n - decoding: Set by lavc."]
6656 pub refs: ::std::os::raw::c_int,
6657 #[doc = " Size of the frame reordering buffer in the decoder.\n For MPEG-2 it is 1 IPB or 0 low delay IP.\n - encoding: Set by libavcodec.\n - decoding: Set by libavcodec."]
6658 pub has_b_frames: ::std::os::raw::c_int,
6659 #[doc = " slice flags\n - encoding: unused\n - decoding: Set by user."]
6660 pub slice_flags: ::std::os::raw::c_int,
6661 #[doc = " If non NULL, 'draw_horiz_band' is called by the libavcodec\n decoder to draw a horizontal band. It improves cache usage. Not\n all codecs can do that. You must check the codec capabilities\n beforehand.\n When multithreading is used, it may be called from multiple threads\n at the same time; threads might draw different parts of the same AVFrame,\n or multiple AVFrames, and there is no guarantee that slices will be drawn\n in order.\n The function is also used by hardware acceleration APIs.\n It is called at least once during frame decoding to pass\n the data needed for hardware render.\n In that mode instead of pixel data, AVFrame points to\n a structure specific to the acceleration API. The application\n reads the structure and can change some fields to indicate progress\n or mark state.\n - encoding: unused\n - decoding: Set by user.\n @param height the height of the slice\n @param y the y position of the slice\n @param type 1->top field, 2->bottom field, 3->frame\n @param offset offset into the AVFrame.data from which the slice should be read"]
6662 pub draw_horiz_band: ::std::option::Option<
6663 unsafe extern "C" fn(
6664 s: *mut AVCodecContext,
6665 src: *const AVFrame,
6666 offset: *mut ::std::os::raw::c_int,
6667 y: ::std::os::raw::c_int,
6668 type_: ::std::os::raw::c_int,
6669 height: ::std::os::raw::c_int,
6670 ),
6671 >,
6672 #[doc = " Callback to negotiate the pixel format. Decoding only, may be set by the\n caller before avcodec_open2().\n\n Called by some decoders to select the pixel format that will be used for\n the output frames. This is mainly used to set up hardware acceleration,\n then the provided format list contains the corresponding hwaccel pixel\n formats alongside the \"software\" one. The software pixel format may also\n be retrieved from \\ref sw_pix_fmt.\n\n This callback will be called when the coded frame properties (such as\n resolution, pixel format, etc.) change and more than one output format is\n supported for those new properties. If a hardware pixel format is chosen\n and initialization for it fails, the callback may be called again\n immediately.\n\n This callback may be called from different threads if the decoder is\n multi-threaded, but not from more than one thread simultaneously.\n\n @param fmt list of formats which may be used in the current\n configuration, terminated by AV_PIX_FMT_NONE.\n @warning Behavior is undefined if the callback returns a value other\n than one of the formats in fmt or AV_PIX_FMT_NONE.\n @return the chosen format or AV_PIX_FMT_NONE"]
6673 pub get_format: ::std::option::Option<
6674 unsafe extern "C" fn(s: *mut AVCodecContext, fmt: *const AVPixelFormat) -> AVPixelFormat,
6675 >,
6676 #[doc = " maximum number of B-frames between non-B-frames\n Note: The output will be delayed by max_b_frames+1 relative to the input.\n - encoding: Set by user.\n - decoding: unused"]
6677 pub max_b_frames: ::std::os::raw::c_int,
6678 #[doc = " qscale factor between IP and B-frames\n If > 0 then the last P-frame quantizer will be used (q= lastp_q*factor+offset).\n If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset).\n - encoding: Set by user.\n - decoding: unused"]
6679 pub b_quant_factor: f32,
6680 #[doc = " qscale offset between IP and B-frames\n - encoding: Set by user.\n - decoding: unused"]
6681 pub b_quant_offset: f32,
6682 #[doc = " qscale factor between P- and I-frames\n If > 0 then the last P-frame quantizer will be used (q = lastp_q * factor + offset).\n If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset).\n - encoding: Set by user.\n - decoding: unused"]
6683 pub i_quant_factor: f32,
6684 #[doc = " qscale offset between P and I-frames\n - encoding: Set by user.\n - decoding: unused"]
6685 pub i_quant_offset: f32,
6686 #[doc = " luminance masking (0-> disabled)\n - encoding: Set by user.\n - decoding: unused"]
6687 pub lumi_masking: f32,
6688 #[doc = " temporary complexity masking (0-> disabled)\n - encoding: Set by user.\n - decoding: unused"]
6689 pub temporal_cplx_masking: f32,
6690 #[doc = " spatial complexity masking (0-> disabled)\n - encoding: Set by user.\n - decoding: unused"]
6691 pub spatial_cplx_masking: f32,
6692 #[doc = " p block masking (0-> disabled)\n - encoding: Set by user.\n - decoding: unused"]
6693 pub p_masking: f32,
6694 #[doc = " darkness masking (0-> disabled)\n - encoding: Set by user.\n - decoding: unused"]
6695 pub dark_masking: f32,
6696 #[doc = " noise vs. sse weight for the nsse comparison function\n - encoding: Set by user.\n - decoding: unused"]
6697 pub nsse_weight: ::std::os::raw::c_int,
6698 #[doc = " motion estimation comparison function\n - encoding: Set by user.\n - decoding: unused"]
6699 pub me_cmp: ::std::os::raw::c_int,
6700 #[doc = " subpixel motion estimation comparison function\n - encoding: Set by user.\n - decoding: unused"]
6701 pub me_sub_cmp: ::std::os::raw::c_int,
6702 #[doc = " macroblock comparison function (not supported yet)\n - encoding: Set by user.\n - decoding: unused"]
6703 pub mb_cmp: ::std::os::raw::c_int,
6704 #[doc = " interlaced DCT comparison function\n - encoding: Set by user.\n - decoding: unused"]
6705 pub ildct_cmp: ::std::os::raw::c_int,
6706 #[doc = " ME diamond size & shape\n - encoding: Set by user.\n - decoding: unused"]
6707 pub dia_size: ::std::os::raw::c_int,
6708 #[doc = " amount of previous MV predictors (2a+1 x 2a+1 square)\n - encoding: Set by user.\n - decoding: unused"]
6709 pub last_predictor_count: ::std::os::raw::c_int,
6710 #[doc = " motion estimation prepass comparison function\n - encoding: Set by user.\n - decoding: unused"]
6711 pub me_pre_cmp: ::std::os::raw::c_int,
6712 #[doc = " ME prepass diamond size & shape\n - encoding: Set by user.\n - decoding: unused"]
6713 pub pre_dia_size: ::std::os::raw::c_int,
6714 #[doc = " subpel ME quality\n - encoding: Set by user.\n - decoding: unused"]
6715 pub me_subpel_quality: ::std::os::raw::c_int,
6716 #[doc = " maximum motion estimation search range in subpel units\n If 0 then no limit.\n\n - encoding: Set by user.\n - decoding: unused"]
6717 pub me_range: ::std::os::raw::c_int,
6718 #[doc = " macroblock decision mode\n - encoding: Set by user.\n - decoding: unused"]
6719 pub mb_decision: ::std::os::raw::c_int,
6720 #[doc = " custom intra quantization matrix\n Must be allocated with the av_malloc() family of functions, and will be freed in\n avcodec_free_context().\n - encoding: Set/allocated by user, freed by libavcodec. Can be NULL.\n - decoding: Set/allocated/freed by libavcodec."]
6721 pub intra_matrix: *mut u16,
6722 #[doc = " custom inter quantization matrix\n Must be allocated with the av_malloc() family of functions, and will be freed in\n avcodec_free_context().\n - encoding: Set/allocated by user, freed by libavcodec. Can be NULL.\n - decoding: Set/allocated/freed by libavcodec."]
6723 pub inter_matrix: *mut u16,
6724 #[doc = " custom intra quantization matrix\n - encoding: Set by user, can be NULL.\n - decoding: unused."]
6725 pub chroma_intra_matrix: *mut u16,
6726 #[doc = " precision of the intra DC coefficient - 8\n - encoding: Set by user.\n - decoding: Set by libavcodec"]
6727 pub intra_dc_precision: ::std::os::raw::c_int,
6728 #[doc = " minimum MB Lagrange multiplier\n - encoding: Set by user.\n - decoding: unused"]
6729 pub mb_lmin: ::std::os::raw::c_int,
6730 #[doc = " maximum MB Lagrange multiplier\n - encoding: Set by user.\n - decoding: unused"]
6731 pub mb_lmax: ::std::os::raw::c_int,
6732 #[doc = " - encoding: Set by user.\n - decoding: unused"]
6733 pub bidir_refine: ::std::os::raw::c_int,
6734 #[doc = " minimum GOP size\n - encoding: Set by user.\n - decoding: unused"]
6735 pub keyint_min: ::std::os::raw::c_int,
6736 #[doc = " the number of pictures in a group of pictures, or 0 for intra_only\n - encoding: Set by user.\n - decoding: unused"]
6737 pub gop_size: ::std::os::raw::c_int,
6738 #[doc = " Note: Value depends upon the compare function used for fullpel ME.\n - encoding: Set by user.\n - decoding: unused"]
6739 pub mv0_threshold: ::std::os::raw::c_int,
6740 #[doc = " Number of slices.\n Indicates number of picture subdivisions. Used for parallelized\n decoding.\n - encoding: Set by user\n - decoding: unused"]
6741 pub slices: ::std::os::raw::c_int,
6742 #[doc = "< samples per second"]
6743 pub sample_rate: ::std::os::raw::c_int,
6744 #[doc = "< sample format"]
6745 pub sample_fmt: AVSampleFormat,
6746 #[doc = " Audio channel layout.\n - encoding: must be set by the caller, to one of AVCodec.ch_layouts.\n - decoding: may be set by the caller if known e.g. from the container.\n The decoder can then override during decoding as needed."]
6747 pub ch_layout: AVChannelLayout,
6748 #[doc = " Number of samples per channel in an audio frame.\n\n - encoding: set by libavcodec in avcodec_open2(). Each submitted frame\n except the last must contain exactly frame_size samples per channel.\n May be 0 when the codec has AV_CODEC_CAP_VARIABLE_FRAME_SIZE set, then the\n frame size is not restricted.\n - decoding: may be set by some decoders to indicate constant frame size"]
6749 pub frame_size: ::std::os::raw::c_int,
6750 #[doc = " number of bytes per packet if constant and known or 0\n Used by some WAV based audio codecs."]
6751 pub block_align: ::std::os::raw::c_int,
6752 #[doc = " Audio cutoff bandwidth (0 means \"automatic\")\n - encoding: Set by user.\n - decoding: unused"]
6753 pub cutoff: ::std::os::raw::c_int,
6754 #[doc = " Type of service that the audio stream conveys.\n - encoding: Set by user.\n - decoding: Set by libavcodec."]
6755 pub audio_service_type: AVAudioServiceType,
6756 #[doc = " desired sample format\n - encoding: Not used.\n - decoding: Set by user.\n Decoder will decode to this format if it can."]
6757 pub request_sample_fmt: AVSampleFormat,
6758 #[doc = " Audio only. The number of \"priming\" samples (padding) inserted by the\n encoder at the beginning of the audio. I.e. this number of leading\n decoded samples must be discarded by the caller to get the original audio\n without leading padding.\n\n - decoding: unused\n - encoding: Set by libavcodec. The timestamps on the output packets are\n adjusted by the encoder so that they always refer to the\n first sample of the data actually contained in the packet,\n including any added padding. E.g. if the timebase is\n 1/samplerate and the timestamp of the first input sample is\n 0, the timestamp of the first output packet will be\n -initial_padding."]
6759 pub initial_padding: ::std::os::raw::c_int,
6760 #[doc = " Audio only. The amount of padding (in samples) appended by the encoder to\n the end of the audio. I.e. this number of decoded samples must be\n discarded by the caller from the end of the stream to get the original\n audio without any trailing padding.\n\n - decoding: unused\n - encoding: unused"]
6761 pub trailing_padding: ::std::os::raw::c_int,
6762 #[doc = " Number of samples to skip after a discontinuity\n - decoding: unused\n - encoding: set by libavcodec"]
6763 pub seek_preroll: ::std::os::raw::c_int,
6764 #[doc = " This callback is called at the beginning of each frame to get data\n buffer(s) for it. There may be one contiguous buffer for all the data or\n there may be a buffer per each data plane or anything in between. What\n this means is, you may set however many entries in buf[] you feel necessary.\n Each buffer must be reference-counted using the AVBuffer API (see description\n of buf[] below).\n\n The following fields will be set in the frame before this callback is\n called:\n - format\n - width, height (video only)\n - sample_rate, channel_layout, nb_samples (audio only)\n Their values may differ from the corresponding values in\n AVCodecContext. This callback must use the frame values, not the codec\n context values, to calculate the required buffer size.\n\n This callback must fill the following fields in the frame:\n - data[]\n - linesize[]\n - extended_data:\n * if the data is planar audio with more than 8 channels, then this\n callback must allocate and fill extended_data to contain all pointers\n to all data planes. data[] must hold as many pointers as it can.\n extended_data must be allocated with av_malloc() and will be freed in\n av_frame_unref().\n * otherwise extended_data must point to data\n - buf[] must contain one or more pointers to AVBufferRef structures. Each of\n the frame's data and extended_data pointers must be contained in these. That\n is, one AVBufferRef for each allocated chunk of memory, not necessarily one\n AVBufferRef per data[] entry. See: av_buffer_create(), av_buffer_alloc(),\n and av_buffer_ref().\n - extended_buf and nb_extended_buf must be allocated with av_malloc() by\n this callback and filled with the extra buffers if there are more\n buffers than buf[] can hold. extended_buf will be freed in\n av_frame_unref().\n\n If AV_CODEC_CAP_DR1 is not set then get_buffer2() must call\n avcodec_default_get_buffer2() instead of providing buffers allocated by\n some other means.\n\n Each data plane must be aligned to the maximum required by the target\n CPU.\n\n @see avcodec_default_get_buffer2()\n\n Video:\n\n If AV_GET_BUFFER_FLAG_REF is set in flags then the frame may be reused\n (read and/or written to if it is writable) later by libavcodec.\n\n avcodec_align_dimensions2() should be used to find the required width and\n height, as they normally need to be rounded up to the next multiple of 16.\n\n Some decoders do not support linesizes changing between frames.\n\n If frame multithreading is used, this callback may be called from a\n different thread, but not from more than one at once. Does not need to be\n reentrant.\n\n @see avcodec_align_dimensions2()\n\n Audio:\n\n Decoders request a buffer of a particular size by setting\n AVFrame.nb_samples prior to calling get_buffer2(). The decoder may,\n however, utilize only part of the buffer by setting AVFrame.nb_samples\n to a smaller value in the output frame.\n\n As a convenience, av_samples_get_buffer_size() and\n av_samples_fill_arrays() in libavutil may be used by custom get_buffer2()\n functions to find the required data size and to fill data pointers and\n linesize. In AVFrame.linesize, only linesize[0] may be set for audio\n since all planes must be the same size.\n\n @see av_samples_get_buffer_size(), av_samples_fill_arrays()\n\n - encoding: unused\n - decoding: Set by libavcodec, user can override."]
6765 pub get_buffer2: ::std::option::Option<
6766 unsafe extern "C" fn(
6767 s: *mut AVCodecContext,
6768 frame: *mut AVFrame,
6769 flags: ::std::os::raw::c_int,
6770 ) -> ::std::os::raw::c_int,
6771 >,
6772 #[doc = " number of bits the bitstream is allowed to diverge from the reference.\n the reference can be CBR (for CBR pass1) or VBR (for pass2)\n - encoding: Set by user; unused for constant quantizer encoding.\n - decoding: unused"]
6773 pub bit_rate_tolerance: ::std::os::raw::c_int,
6774 #[doc = " Global quality for codecs which cannot change it per frame.\n This should be proportional to MPEG-1/2/4 qscale.\n - encoding: Set by user.\n - decoding: unused"]
6775 pub global_quality: ::std::os::raw::c_int,
6776 #[doc = " - encoding: Set by user.\n - decoding: unused"]
6777 pub compression_level: ::std::os::raw::c_int,
6778 #[doc = "< amount of qscale change between easy & hard scenes (0.0-1.0)"]
6779 pub qcompress: f32,
6780 #[doc = "< amount of qscale smoothing over time (0.0-1.0)"]
6781 pub qblur: f32,
6782 #[doc = " minimum quantizer\n - encoding: Set by user.\n - decoding: unused"]
6783 pub qmin: ::std::os::raw::c_int,
6784 #[doc = " maximum quantizer\n - encoding: Set by user.\n - decoding: unused"]
6785 pub qmax: ::std::os::raw::c_int,
6786 #[doc = " maximum quantizer difference between frames\n - encoding: Set by user.\n - decoding: unused"]
6787 pub max_qdiff: ::std::os::raw::c_int,
6788 #[doc = " decoder bitstream buffer size\n - encoding: Set by user.\n - decoding: May be set by libavcodec."]
6789 pub rc_buffer_size: ::std::os::raw::c_int,
6790 #[doc = " ratecontrol override, see RcOverride\n - encoding: Allocated/set/freed by user.\n - decoding: unused"]
6791 pub rc_override_count: ::std::os::raw::c_int,
6792 pub rc_override: *mut RcOverride,
6793 #[doc = " maximum bitrate\n - encoding: Set by user.\n - decoding: Set by user, may be overwritten by libavcodec."]
6794 pub rc_max_rate: i64,
6795 #[doc = " minimum bitrate\n - encoding: Set by user.\n - decoding: unused"]
6796 pub rc_min_rate: i64,
6797 #[doc = " Ratecontrol attempt to use, at maximum, <value> of what can be used without an underflow.\n - encoding: Set by user.\n - decoding: unused."]
6798 pub rc_max_available_vbv_use: f32,
6799 #[doc = " Ratecontrol attempt to use, at least, <value> times the amount needed to prevent a vbv overflow.\n - encoding: Set by user.\n - decoding: unused."]
6800 pub rc_min_vbv_overflow_use: f32,
6801 #[doc = " Number of bits which should be loaded into the rc buffer before decoding starts.\n - encoding: Set by user.\n - decoding: unused"]
6802 pub rc_initial_buffer_occupancy: ::std::os::raw::c_int,
6803 #[doc = " trellis RD quantization\n - encoding: Set by user.\n - decoding: unused"]
6804 pub trellis: ::std::os::raw::c_int,
6805 #[doc = " pass1 encoding statistics output buffer\n - encoding: Set by libavcodec.\n - decoding: unused"]
6806 pub stats_out: *mut ::std::os::raw::c_char,
6807 #[doc = " pass2 encoding statistics input buffer\n Concatenated stuff from stats_out of pass1 should be placed here.\n - encoding: Allocated/set/freed by user.\n - decoding: unused"]
6808 pub stats_in: *mut ::std::os::raw::c_char,
6809 #[doc = " Work around bugs in encoders which sometimes cannot be detected automatically.\n - encoding: Set by user\n - decoding: Set by user"]
6810 pub workaround_bugs: ::std::os::raw::c_int,
6811 #[doc = " strictly follow the standard (MPEG-4, ...).\n - encoding: Set by user.\n - decoding: Set by user.\n Setting this to STRICT or higher means the encoder and decoder will\n generally do stupid things, whereas setting it to unofficial or lower\n will mean the encoder might produce output that is not supported by all\n spec-compliant decoders. Decoders don't differentiate between normal,\n unofficial and experimental (that is, they always try to decode things\n when they can) unless they are explicitly asked to behave stupidly\n (=strictly conform to the specs)\n This may only be set to one of the FF_COMPLIANCE_* values in defs.h."]
6812 pub strict_std_compliance: ::std::os::raw::c_int,
6813 #[doc = " error concealment flags\n - encoding: unused\n - decoding: Set by user."]
6814 pub error_concealment: ::std::os::raw::c_int,
6815 #[doc = " debug\n - encoding: Set by user.\n - decoding: Set by user."]
6816 pub debug: ::std::os::raw::c_int,
6817 #[doc = " Error recognition; may misdetect some more or less valid parts as errors.\n This is a bitfield of the AV_EF_* values defined in defs.h.\n\n - encoding: Set by user.\n - decoding: Set by user."]
6818 pub err_recognition: ::std::os::raw::c_int,
6819 #[doc = " Hardware accelerator in use\n - encoding: unused.\n - decoding: Set by libavcodec"]
6820 pub hwaccel: *const AVHWAccel,
6821 #[doc = " Legacy hardware accelerator context.\n\n For some hardware acceleration methods, the caller may use this field to\n signal hwaccel-specific data to the codec. The struct pointed to by this\n pointer is hwaccel-dependent and defined in the respective header. Please\n refer to the FFmpeg HW accelerator documentation to know how to fill\n this.\n\n In most cases this field is optional - the necessary information may also\n be provided to libavcodec through @ref hw_frames_ctx or @ref\n hw_device_ctx (see avcodec_get_hw_config()). However, in some cases it\n may be the only method of signalling some (optional) information.\n\n The struct and its contents are owned by the caller.\n\n - encoding: May be set by the caller before avcodec_open2(). Must remain\n valid until avcodec_free_context().\n - decoding: May be set by the caller in the get_format() callback.\n Must remain valid until the next get_format() call,\n or avcodec_free_context() (whichever comes first)."]
6822 pub hwaccel_context: *mut ::std::os::raw::c_void,
6823 #[doc = " A reference to the AVHWFramesContext describing the input (for encoding)\n or output (decoding) frames. The reference is set by the caller and\n afterwards owned (and freed) by libavcodec - it should never be read by\n the caller after being set.\n\n - decoding: This field should be set by the caller from the get_format()\n callback. The previous reference (if any) will always be\n unreffed by libavcodec before the get_format() call.\n\n If the default get_buffer2() is used with a hwaccel pixel\n format, then this AVHWFramesContext will be used for\n allocating the frame buffers.\n\n - encoding: For hardware encoders configured to use a hwaccel pixel\n format, this field should be set by the caller to a reference\n to the AVHWFramesContext describing input frames.\n AVHWFramesContext.format must be equal to\n AVCodecContext.pix_fmt.\n\n This field should be set before avcodec_open2() is called."]
6824 pub hw_frames_ctx: *mut AVBufferRef,
6825 #[doc = " A reference to the AVHWDeviceContext describing the device which will\n be used by a hardware encoder/decoder. The reference is set by the\n caller and afterwards owned (and freed) by libavcodec.\n\n This should be used if either the codec device does not require\n hardware frames or any that are used are to be allocated internally by\n libavcodec. If the user wishes to supply any of the frames used as\n encoder input or decoder output then hw_frames_ctx should be used\n instead. When hw_frames_ctx is set in get_format() for a decoder, this\n field will be ignored while decoding the associated stream segment, but\n may again be used on a following one after another get_format() call.\n\n For both encoders and decoders this field should be set before\n avcodec_open2() is called and must not be written to thereafter.\n\n Note that some decoders may require this field to be set initially in\n order to support hw_frames_ctx at all - in that case, all frames\n contexts used must be created on the same device."]
6826 pub hw_device_ctx: *mut AVBufferRef,
6827 #[doc = " Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated\n decoding (if active).\n - encoding: unused\n - decoding: Set by user (either before avcodec_open2(), or in the\n AVCodecContext.get_format callback)"]
6828 pub hwaccel_flags: ::std::os::raw::c_int,
6829 #[doc = " Video decoding only. Sets the number of extra hardware frames which\n the decoder will allocate for use by the caller. This must be set\n before avcodec_open2() is called.\n\n Some hardware decoders require all frames that they will use for\n output to be defined in advance before decoding starts. For such\n decoders, the hardware frame pool must therefore be of a fixed size.\n The extra frames set here are on top of any number that the decoder\n needs internally in order to operate normally (for example, frames\n used as reference pictures)."]
6830 pub extra_hw_frames: ::std::os::raw::c_int,
6831 #[doc = " error\n - encoding: Set by libavcodec if flags & AV_CODEC_FLAG_PSNR.\n - decoding: unused"]
6832 pub error: [u64; 8usize],
6833 #[doc = " DCT algorithm, see FF_DCT_* below\n - encoding: Set by user.\n - decoding: unused"]
6834 pub dct_algo: ::std::os::raw::c_int,
6835 #[doc = " IDCT algorithm, see FF_IDCT_* below.\n - encoding: Set by user.\n - decoding: Set by user."]
6836 pub idct_algo: ::std::os::raw::c_int,
6837 #[doc = " bits per sample/pixel from the demuxer (needed for huffyuv).\n - encoding: Set by libavcodec.\n - decoding: Set by user."]
6838 pub bits_per_coded_sample: ::std::os::raw::c_int,
6839 #[doc = " Bits per sample/pixel of internal libavcodec pixel/sample format.\n - encoding: set by user.\n - decoding: set by libavcodec."]
6840 pub bits_per_raw_sample: ::std::os::raw::c_int,
6841 #[doc = " thread count\n is used to decide how many independent tasks should be passed to execute()\n - encoding: Set by user.\n - decoding: Set by user."]
6842 pub thread_count: ::std::os::raw::c_int,
6843 #[doc = " Which multithreading methods to use.\n Use of FF_THREAD_FRAME will increase decoding delay by one frame per thread,\n so clients which cannot provide future frames should not use it.\n\n - encoding: Set by user, otherwise the default is used.\n - decoding: Set by user, otherwise the default is used."]
6844 pub thread_type: ::std::os::raw::c_int,
6845 #[doc = " Which multithreading methods are in use by the codec.\n - encoding: Set by libavcodec.\n - decoding: Set by libavcodec."]
6846 pub active_thread_type: ::std::os::raw::c_int,
6847 #[doc = " The codec may call this to execute several independent things.\n It will return only after finishing all tasks.\n The user may replace this with some multithreaded implementation,\n the default implementation will execute the parts serially.\n @param count the number of things to execute\n - encoding: Set by libavcodec, user can override.\n - decoding: Set by libavcodec, user can override."]
6848 pub execute: ::std::option::Option<
6849 unsafe extern "C" fn(
6850 c: *mut AVCodecContext,
6851 func: ::std::option::Option<
6852 unsafe extern "C" fn(
6853 c2: *mut AVCodecContext,
6854 arg: *mut ::std::os::raw::c_void,
6855 ) -> ::std::os::raw::c_int,
6856 >,
6857 arg2: *mut ::std::os::raw::c_void,
6858 ret: *mut ::std::os::raw::c_int,
6859 count: ::std::os::raw::c_int,
6860 size: ::std::os::raw::c_int,
6861 ) -> ::std::os::raw::c_int,
6862 >,
6863 #[doc = " The codec may call this to execute several independent things.\n It will return only after finishing all tasks.\n The user may replace this with some multithreaded implementation,\n the default implementation will execute the parts serially.\n @param c context passed also to func\n @param count the number of things to execute\n @param arg2 argument passed unchanged to func\n @param ret return values of executed functions, must have space for \"count\" values. May be NULL.\n @param func function that will be called count times, with jobnr from 0 to count-1.\n threadnr will be in the range 0 to c->thread_count-1 < MAX_THREADS and so that no\n two instances of func executing at the same time will have the same threadnr.\n @return always 0 currently, but code should handle a future improvement where when any call to func\n returns < 0 no further calls to func may be done and < 0 is returned.\n - encoding: Set by libavcodec, user can override.\n - decoding: Set by libavcodec, user can override."]
6864 pub execute2: ::std::option::Option<
6865 unsafe extern "C" fn(
6866 c: *mut AVCodecContext,
6867 func: ::std::option::Option<
6868 unsafe extern "C" fn(
6869 c2: *mut AVCodecContext,
6870 arg: *mut ::std::os::raw::c_void,
6871 jobnr: ::std::os::raw::c_int,
6872 threadnr: ::std::os::raw::c_int,
6873 ) -> ::std::os::raw::c_int,
6874 >,
6875 arg2: *mut ::std::os::raw::c_void,
6876 ret: *mut ::std::os::raw::c_int,
6877 count: ::std::os::raw::c_int,
6878 ) -> ::std::os::raw::c_int,
6879 >,
6880 #[doc = " profile\n - encoding: Set by user.\n - decoding: Set by libavcodec.\n See the AV_PROFILE_* defines in defs.h."]
6881 pub profile: ::std::os::raw::c_int,
6882 #[doc = " Encoding level descriptor.\n - encoding: Set by user, corresponds to a specific level defined by the\n codec, usually corresponding to the profile level, if not specified it\n is set to FF_LEVEL_UNKNOWN.\n - decoding: Set by libavcodec.\n See AV_LEVEL_* in defs.h."]
6883 pub level: ::std::os::raw::c_int,
6884 #[doc = " Properties of the stream that gets decoded\n - encoding: unused\n - decoding: set by libavcodec"]
6885 pub properties: ::std::os::raw::c_uint,
6886 #[doc = " Skip loop filtering for selected frames.\n - encoding: unused\n - decoding: Set by user."]
6887 pub skip_loop_filter: AVDiscard,
6888 #[doc = " Skip IDCT/dequantization for selected frames.\n - encoding: unused\n - decoding: Set by user."]
6889 pub skip_idct: AVDiscard,
6890 #[doc = " Skip decoding for selected frames.\n - encoding: unused\n - decoding: Set by user."]
6891 pub skip_frame: AVDiscard,
6892 #[doc = " Skip processing alpha if supported by codec.\n Note that if the format uses pre-multiplied alpha (common with VP6,\n and recommended due to better video quality/compression)\n the image will look as if alpha-blended onto a black background.\n However for formats that do not use pre-multiplied alpha\n there might be serious artefacts (though e.g. libswscale currently\n assumes pre-multiplied alpha anyway).\n\n - decoding: set by user\n - encoding: unused"]
6893 pub skip_alpha: ::std::os::raw::c_int,
6894 #[doc = " Number of macroblock rows at the top which are skipped.\n - encoding: unused\n - decoding: Set by user."]
6895 pub skip_top: ::std::os::raw::c_int,
6896 #[doc = " Number of macroblock rows at the bottom which are skipped.\n - encoding: unused\n - decoding: Set by user."]
6897 pub skip_bottom: ::std::os::raw::c_int,
6898 #[doc = " low resolution decoding, 1-> 1/2 size, 2->1/4 size\n - encoding: unused\n - decoding: Set by user."]
6899 pub lowres: ::std::os::raw::c_int,
6900 #[doc = " AVCodecDescriptor\n - encoding: unused.\n - decoding: set by libavcodec."]
6901 pub codec_descriptor: *const AVCodecDescriptor,
6902 #[doc = " Character encoding of the input subtitles file.\n - decoding: set by user\n - encoding: unused"]
6903 pub sub_charenc: *mut ::std::os::raw::c_char,
6904 #[doc = " Subtitles character encoding mode. Formats or codecs might be adjusting\n this setting (if they are doing the conversion themselves for instance).\n - decoding: set by libavcodec\n - encoding: unused"]
6905 pub sub_charenc_mode: ::std::os::raw::c_int,
6906 #[doc = " Header containing style information for text subtitles.\n For SUBTITLE_ASS subtitle type, it should contain the whole ASS\n [Script Info] and [V4+ Styles] section, plus the [Events] line and\n the Format line following. It shouldn't include any Dialogue line.\n - encoding: Set/allocated/freed by user (before avcodec_open2())\n - decoding: Set/allocated/freed by libavcodec (by avcodec_open2())"]
6907 pub subtitle_header_size: ::std::os::raw::c_int,
6908 pub subtitle_header: *mut u8,
6909 #[doc = " dump format separator.\n can be \", \" or \"\\n \" or anything else\n - encoding: Set by user.\n - decoding: Set by user."]
6910 pub dump_separator: *mut u8,
6911 #[doc = " ',' separated list of allowed decoders.\n If NULL then all are allowed\n - encoding: unused\n - decoding: set by user"]
6912 pub codec_whitelist: *mut ::std::os::raw::c_char,
6913 #[doc = " Additional data associated with the entire coded stream.\n\n - decoding: may be set by user before calling avcodec_open2().\n - encoding: may be set by libavcodec after avcodec_open2()."]
6914 pub coded_side_data: *mut AVPacketSideData,
6915 pub nb_coded_side_data: ::std::os::raw::c_int,
6916 #[doc = " Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of\n metadata exported in frame, packet, or coded stream side data by\n decoders and encoders.\n\n - decoding: set by user\n - encoding: set by user"]
6917 pub export_side_data: ::std::os::raw::c_int,
6918 #[doc = " The number of pixels per image to maximally accept.\n\n - decoding: set by user\n - encoding: set by user"]
6919 pub max_pixels: i64,
6920 #[doc = " Video decoding only. Certain video codecs support cropping, meaning that\n only a sub-rectangle of the decoded frame is intended for display. This\n option controls how cropping is handled by libavcodec.\n\n When set to 1 (the default), libavcodec will apply cropping internally.\n I.e. it will modify the output frame width/height fields and offset the\n data pointers (only by as much as possible while preserving alignment, or\n by the full amount if the AV_CODEC_FLAG_UNALIGNED flag is set) so that\n the frames output by the decoder refer only to the cropped area. The\n crop_* fields of the output frames will be zero.\n\n When set to 0, the width/height fields of the output frames will be set\n to the coded dimensions and the crop_* fields will describe the cropping\n rectangle. Applying the cropping is left to the caller.\n\n @warning When hardware acceleration with opaque output frames is used,\n libavcodec is unable to apply cropping from the top/left border.\n\n @note when this option is set to zero, the width/height fields of the\n AVCodecContext and output AVFrames have different meanings. The codec\n context fields store display dimensions (with the coded dimensions in\n coded_width/height), while the frame fields store the coded dimensions\n (with the display dimensions being determined by the crop_* fields)."]
6921 pub apply_cropping: ::std::os::raw::c_int,
6922 #[doc = " The percentage of damaged samples to discard a frame.\n\n - decoding: set by user\n - encoding: unused"]
6923 pub discard_damaged_percentage: ::std::os::raw::c_int,
6924 #[doc = " The number of samples per frame to maximally accept.\n\n - decoding: set by user\n - encoding: set by user"]
6925 pub max_samples: i64,
6926 #[doc = " This callback is called at the beginning of each packet to get a data\n buffer for it.\n\n The following field will be set in the packet before this callback is\n called:\n - size\n This callback must use the above value to calculate the required buffer size,\n which must padded by at least AV_INPUT_BUFFER_PADDING_SIZE bytes.\n\n In some specific cases, the encoder may not use the entire buffer allocated by this\n callback. This will be reflected in the size value in the packet once returned by\n avcodec_receive_packet().\n\n This callback must fill the following fields in the packet:\n - data: alignment requirements for AVPacket apply, if any. Some architectures and\n encoders may benefit from having aligned data.\n - buf: must contain a pointer to an AVBufferRef structure. The packet's\n data pointer must be contained in it. See: av_buffer_create(), av_buffer_alloc(),\n and av_buffer_ref().\n\n If AV_CODEC_CAP_DR1 is not set then get_encode_buffer() must call\n avcodec_default_get_encode_buffer() instead of providing a buffer allocated by\n some other means.\n\n The flags field may contain a combination of AV_GET_ENCODE_BUFFER_FLAG_ flags.\n They may be used for example to hint what use the buffer may get after being\n created.\n Implementations of this callback may ignore flags they don't understand.\n If AV_GET_ENCODE_BUFFER_FLAG_REF is set in flags then the packet may be reused\n (read and/or written to if it is writable) later by libavcodec.\n\n This callback must be thread-safe, as when frame threading is used, it may\n be called from multiple threads simultaneously.\n\n @see avcodec_default_get_encode_buffer()\n\n - encoding: Set by libavcodec, user can override.\n - decoding: unused"]
6927 pub get_encode_buffer: ::std::option::Option<
6928 unsafe extern "C" fn(
6929 s: *mut AVCodecContext,
6930 pkt: *mut AVPacket,
6931 flags: ::std::os::raw::c_int,
6932 ) -> ::std::os::raw::c_int,
6933 >,
6934 #[doc = " Frame counter, set by libavcodec.\n\n - decoding: total number of frames returned from the decoder so far.\n - encoding: total number of frames passed to the encoder so far.\n\n @note the counter is not incremented if encoding/decoding resulted in\n an error."]
6935 pub frame_num: i64,
6936 #[doc = " Decoding only. May be set by the caller before avcodec_open2() to an\n av_malloc()'ed array (or via AVOptions). Owned and freed by the decoder\n afterwards.\n\n Side data attached to decoded frames may come from several sources:\n 1. coded_side_data, which the decoder will for certain types translate\n from packet-type to frame-type and attach to frames;\n 2. side data attached to an AVPacket sent for decoding (same\n considerations as above);\n 3. extracted from the coded bytestream.\n The first two cases are supplied by the caller and typically come from a\n container.\n\n This array configures decoder behaviour in cases when side data of the\n same type is present both in the coded bytestream and in the\n user-supplied side data (items 1. and 2. above). In all cases, at most\n one instance of each side data type will be attached to output frames. By\n default it will be the bytestream side data. Adding an\n AVPacketSideDataType value to this array will flip the preference for\n this type, thus making the decoder prefer user-supplied side data over\n bytestream. In case side data of the same type is present both in\n coded_data and attacked to a packet, the packet instance always has\n priority.\n\n The array may also contain a single -1, in which case the preference is\n switched for all side data types."]
6937 pub side_data_prefer_packet: *mut ::std::os::raw::c_int,
6938 #[doc = " Number of entries in side_data_prefer_packet."]
6939 pub nb_side_data_prefer_packet: ::std::os::raw::c_uint,
6940 #[doc = " Array containing static side data, such as HDR10 CLL / MDCV structures.\n Side data entries should be allocated by usage of helpers defined in\n libavutil/frame.h.\n\n - encoding: may be set by user before calling avcodec_open2() for\n encoder configuration. Afterwards owned and freed by the\n encoder.\n - decoding: may be set by libavcodec in avcodec_open2()."]
6941 pub decoded_side_data: *mut *mut AVFrameSideData,
6942 pub nb_decoded_side_data: ::std::os::raw::c_int,
6943}
6944impl Default for AVCodecContext {
6945 fn default() -> Self {
6946 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6947 unsafe {
6948 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6949 s.assume_init()
6950 }
6951 }
6952}
6953#[doc = " @defgroup lavc_hwaccel AVHWAccel\n\n @note Nothing in this structure should be accessed by the user. At some\n point in future it will not be externally visible at all.\n\n @{"]
6954#[repr(C)]
6955#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6956pub struct AVHWAccel {
6957 #[doc = " Name of the hardware accelerated codec.\n The name is globally unique among encoders and among decoders (but an\n encoder and a decoder can share the same name)."]
6958 pub name: *const ::std::os::raw::c_char,
6959 #[doc = " Type of codec implemented by the hardware accelerator.\n\n See AVMEDIA_TYPE_xxx"]
6960 pub type_: AVMediaType,
6961 #[doc = " Codec implemented by the hardware accelerator.\n\n See AV_CODEC_ID_xxx"]
6962 pub id: AVCodecID,
6963 #[doc = " Supported pixel format.\n\n Only hardware accelerated formats are supported here."]
6964 pub pix_fmt: AVPixelFormat,
6965 #[doc = " Hardware accelerated codec capabilities.\n see AV_HWACCEL_CODEC_CAP_*"]
6966 pub capabilities: ::std::os::raw::c_int,
6967}
6968impl Default for AVHWAccel {
6969 fn default() -> Self {
6970 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6971 unsafe {
6972 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6973 s.assume_init()
6974 }
6975 }
6976}
6977pub const AVSubtitleType_SUBTITLE_NONE: AVSubtitleType = 0;
6978#[doc = "< A bitmap, pict will be set"]
6979pub const AVSubtitleType_SUBTITLE_BITMAP: AVSubtitleType = 1;
6980#[doc = " Plain text, the text field must be set by the decoder and is\n authoritative. ass and pict fields may contain approximations."]
6981pub const AVSubtitleType_SUBTITLE_TEXT: AVSubtitleType = 2;
6982#[doc = " Formatted text, the ass field must be set by the decoder and is\n authoritative. pict and text fields may contain approximations."]
6983pub const AVSubtitleType_SUBTITLE_ASS: AVSubtitleType = 3;
6984#[doc = " @}"]
6985pub type AVSubtitleType = ::std::os::raw::c_uint;
6986#[repr(C)]
6987#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
6988pub struct AVSubtitleRect {
6989 #[doc = "< top left corner of pict, undefined when pict is not set"]
6990 pub x: ::std::os::raw::c_int,
6991 #[doc = "< top left corner of pict, undefined when pict is not set"]
6992 pub y: ::std::os::raw::c_int,
6993 #[doc = "< width of pict, undefined when pict is not set"]
6994 pub w: ::std::os::raw::c_int,
6995 #[doc = "< height of pict, undefined when pict is not set"]
6996 pub h: ::std::os::raw::c_int,
6997 #[doc = "< number of colors in pict, undefined when pict is not set"]
6998 pub nb_colors: ::std::os::raw::c_int,
6999 #[doc = " data+linesize for the bitmap of this subtitle.\n Can be set for text/ass as well once they are rendered."]
7000 pub data: [*mut u8; 4usize],
7001 pub linesize: [::std::os::raw::c_int; 4usize],
7002 pub flags: ::std::os::raw::c_int,
7003 pub type_: AVSubtitleType,
7004 #[doc = "< 0 terminated plain UTF-8 text"]
7005 pub text: *mut ::std::os::raw::c_char,
7006 #[doc = " 0 terminated ASS/SSA compatible event line.\n The presentation of this is unaffected by the other values in this\n struct."]
7007 pub ass: *mut ::std::os::raw::c_char,
7008}
7009impl Default for AVSubtitleRect {
7010 fn default() -> Self {
7011 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7012 unsafe {
7013 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7014 s.assume_init()
7015 }
7016 }
7017}
7018#[repr(C)]
7019#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
7020pub struct AVSubtitle {
7021 pub format: u16,
7022 pub start_display_time: u32,
7023 pub end_display_time: u32,
7024 pub num_rects: ::std::os::raw::c_uint,
7025 pub rects: *mut *mut AVSubtitleRect,
7026 #[doc = "< Same as packet pts, in AV_TIME_BASE"]
7027 pub pts: i64,
7028}
7029impl Default for AVSubtitle {
7030 fn default() -> Self {
7031 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7032 unsafe {
7033 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7034 s.assume_init()
7035 }
7036 }
7037}
7038extern "C" {
7039 #[doc = " Return the LIBAVCODEC_VERSION_INT constant."]
7040 pub fn avcodec_version() -> ::std::os::raw::c_uint;
7041}
7042extern "C" {
7043 #[doc = " Return the libavcodec build-time configuration."]
7044 pub fn avcodec_configuration() -> *const ::std::os::raw::c_char;
7045}
7046extern "C" {
7047 #[doc = " Return the libavcodec license."]
7048 pub fn avcodec_license() -> *const ::std::os::raw::c_char;
7049}
7050extern "C" {
7051 #[doc = " Allocate an AVCodecContext and set its fields to default values. The\n resulting struct should be freed with avcodec_free_context().\n\n @param codec if non-NULL, allocate private data and initialize defaults\n for the given codec. It is illegal to then call avcodec_open2()\n with a different codec.\n If NULL, then the codec-specific defaults won't be initialized,\n which may result in suboptimal default settings (this is\n important mainly for encoders, e.g. libx264).\n\n @return An AVCodecContext filled with default values or NULL on failure."]
7052 pub fn avcodec_alloc_context3(codec: *const AVCodec) -> *mut AVCodecContext;
7053}
7054extern "C" {
7055 #[doc = " Free the codec context and everything associated with it and write NULL to\n the provided pointer."]
7056 pub fn avcodec_free_context(avctx: *mut *mut AVCodecContext);
7057}
7058extern "C" {
7059 #[doc = " Get the AVClass for AVCodecContext. It can be used in combination with\n AV_OPT_SEARCH_FAKE_OBJ for examining options.\n\n @see av_opt_find()."]
7060 pub fn avcodec_get_class() -> *const AVClass;
7061}
7062extern "C" {
7063 #[doc = " Get the AVClass for AVSubtitleRect. It can be used in combination with\n AV_OPT_SEARCH_FAKE_OBJ for examining options.\n\n @see av_opt_find()."]
7064 pub fn avcodec_get_subtitle_rect_class() -> *const AVClass;
7065}
7066extern "C" {
7067 #[doc = " Fill the parameters struct based on the values from the supplied codec\n context. Any allocated fields in par are freed and replaced with duplicates\n of the corresponding fields in codec.\n\n @return >= 0 on success, a negative AVERROR code on failure"]
7068 pub fn avcodec_parameters_from_context(
7069 par: *mut AVCodecParameters,
7070 codec: *const AVCodecContext,
7071 ) -> ::std::os::raw::c_int;
7072}
7073extern "C" {
7074 #[doc = " Fill the codec context based on the values from the supplied codec\n parameters. Any allocated fields in codec that have a corresponding field in\n par are freed and replaced with duplicates of the corresponding field in par.\n Fields in codec that do not have a counterpart in par are not touched.\n\n @return >= 0 on success, a negative AVERROR code on failure."]
7075 pub fn avcodec_parameters_to_context(
7076 codec: *mut AVCodecContext,
7077 par: *const AVCodecParameters,
7078 ) -> ::std::os::raw::c_int;
7079}
7080extern "C" {
7081 #[doc = " Initialize the AVCodecContext to use the given AVCodec. Prior to using this\n function the context has to be allocated with avcodec_alloc_context3().\n\n The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(),\n avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for\n retrieving a codec.\n\n Depending on the codec, you might need to set options in the codec context\n also for decoding (e.g. width, height, or the pixel or audio sample format in\n the case the information is not available in the bitstream, as when decoding\n raw audio or video).\n\n Options in the codec context can be set either by setting them in the options\n AVDictionary, or by setting the values in the context itself, directly or by\n using the av_opt_set() API before calling this function.\n\n Example:\n @code\n av_dict_set(&opts, \"b\", \"2.5M\", 0);\n codec = avcodec_find_decoder(AV_CODEC_ID_H264);\n if (!codec)\n exit(1);\n\n context = avcodec_alloc_context3(codec);\n\n if (avcodec_open2(context, codec, opts) < 0)\n exit(1);\n @endcode\n\n In the case AVCodecParameters are available (e.g. when demuxing a stream\n using libavformat, and accessing the AVStream contained in the demuxer), the\n codec parameters can be copied to the codec context using\n avcodec_parameters_to_context(), as in the following example:\n\n @code\n AVStream *stream = ...;\n context = avcodec_alloc_context3(codec);\n if (avcodec_parameters_to_context(context, stream->codecpar) < 0)\n exit(1);\n if (avcodec_open2(context, codec, NULL) < 0)\n exit(1);\n @endcode\n\n @note Always call this function before using decoding routines (such as\n @ref avcodec_receive_frame()).\n\n @param avctx The context to initialize.\n @param codec The codec to open this context for. If a non-NULL codec has been\n previously passed to avcodec_alloc_context3() or\n for this context, then this parameter MUST be either NULL or\n equal to the previously passed codec.\n @param options A dictionary filled with AVCodecContext and codec-private\n options, which are set on top of the options already set in\n avctx, can be NULL. On return this object will be filled with\n options that were not found in the avctx codec context.\n\n @return zero on success, a negative value on error\n @see avcodec_alloc_context3(), avcodec_find_decoder(), avcodec_find_encoder(),\n av_dict_set(), av_opt_set(), av_opt_find(), avcodec_parameters_to_context()"]
7082 pub fn avcodec_open2(
7083 avctx: *mut AVCodecContext,
7084 codec: *const AVCodec,
7085 options: *mut *mut AVDictionary,
7086 ) -> ::std::os::raw::c_int;
7087}
7088extern "C" {
7089 #[doc = " Close a given AVCodecContext and free all the data associated with it\n (but not the AVCodecContext itself).\n\n Calling this function on an AVCodecContext that hasn't been opened will free\n the codec-specific data allocated in avcodec_alloc_context3() with a non-NULL\n codec. Subsequent calls will do nothing.\n\n @deprecated Do not use this function. Use avcodec_free_context() to destroy a\n codec context (either open or closed). Opening and closing a codec context\n multiple times is not supported anymore -- use multiple codec contexts\n instead."]
7090 pub fn avcodec_close(avctx: *mut AVCodecContext) -> ::std::os::raw::c_int;
7091}
7092extern "C" {
7093 #[doc = " Free all allocated data in the given subtitle struct.\n\n @param sub AVSubtitle to free."]
7094 pub fn avsubtitle_free(sub: *mut AVSubtitle);
7095}
7096extern "C" {
7097 #[doc = " The default callback for AVCodecContext.get_buffer2(). It is made public so\n it can be called by custom get_buffer2() implementations for decoders without\n AV_CODEC_CAP_DR1 set."]
7098 pub fn avcodec_default_get_buffer2(
7099 s: *mut AVCodecContext,
7100 frame: *mut AVFrame,
7101 flags: ::std::os::raw::c_int,
7102 ) -> ::std::os::raw::c_int;
7103}
7104extern "C" {
7105 #[doc = " The default callback for AVCodecContext.get_encode_buffer(). It is made public so\n it can be called by custom get_encode_buffer() implementations for encoders without\n AV_CODEC_CAP_DR1 set."]
7106 pub fn avcodec_default_get_encode_buffer(
7107 s: *mut AVCodecContext,
7108 pkt: *mut AVPacket,
7109 flags: ::std::os::raw::c_int,
7110 ) -> ::std::os::raw::c_int;
7111}
7112extern "C" {
7113 #[doc = " Modify width and height values so that they will result in a memory\n buffer that is acceptable for the codec if you do not use any horizontal\n padding.\n\n May only be used if a codec with AV_CODEC_CAP_DR1 has been opened."]
7114 pub fn avcodec_align_dimensions(
7115 s: *mut AVCodecContext,
7116 width: *mut ::std::os::raw::c_int,
7117 height: *mut ::std::os::raw::c_int,
7118 );
7119}
7120extern "C" {
7121 #[doc = " Modify width and height values so that they will result in a memory\n buffer that is acceptable for the codec if you also ensure that all\n line sizes are a multiple of the respective linesize_align[i].\n\n May only be used if a codec with AV_CODEC_CAP_DR1 has been opened."]
7122 pub fn avcodec_align_dimensions2(
7123 s: *mut AVCodecContext,
7124 width: *mut ::std::os::raw::c_int,
7125 height: *mut ::std::os::raw::c_int,
7126 linesize_align: *mut ::std::os::raw::c_int,
7127 );
7128}
7129extern "C" {
7130 #[doc = " Decode a subtitle message.\n Return a negative value on error, otherwise return the number of bytes used.\n If no subtitle could be decompressed, got_sub_ptr is zero.\n Otherwise, the subtitle is stored in *sub.\n Note that AV_CODEC_CAP_DR1 is not available for subtitle codecs. This is for\n simplicity, because the performance difference is expected to be negligible\n and reusing a get_buffer written for video codecs would probably perform badly\n due to a potentially very different allocation pattern.\n\n Some decoders (those marked with AV_CODEC_CAP_DELAY) have a delay between input\n and output. This means that for some packets they will not immediately\n produce decoded output and need to be flushed at the end of decoding to get\n all the decoded data. Flushing is done by calling this function with packets\n with avpkt->data set to NULL and avpkt->size set to 0 until it stops\n returning subtitles. It is safe to flush even those decoders that are not\n marked with AV_CODEC_CAP_DELAY, then no subtitles will be returned.\n\n @note The AVCodecContext MUST have been opened with @ref avcodec_open2()\n before packets may be fed to the decoder.\n\n @param avctx the codec context\n @param[out] sub The preallocated AVSubtitle in which the decoded subtitle will be stored,\n must be freed with avsubtitle_free if *got_sub_ptr is set.\n @param[in,out] got_sub_ptr Zero if no subtitle could be decompressed, otherwise, it is nonzero.\n @param[in] avpkt The input AVPacket containing the input buffer."]
7131 pub fn avcodec_decode_subtitle2(
7132 avctx: *mut AVCodecContext,
7133 sub: *mut AVSubtitle,
7134 got_sub_ptr: *mut ::std::os::raw::c_int,
7135 avpkt: *const AVPacket,
7136 ) -> ::std::os::raw::c_int;
7137}
7138extern "C" {
7139 #[doc = " Supply raw packet data as input to a decoder.\n\n Internally, this call will copy relevant AVCodecContext fields, which can\n influence decoding per-packet, and apply them when the packet is actually\n decoded. (For example AVCodecContext.skip_frame, which might direct the\n decoder to drop the frame contained by the packet sent with this function.)\n\n @warning The input buffer, avpkt->data must be AV_INPUT_BUFFER_PADDING_SIZE\n larger than the actual read bytes because some optimized bitstream\n readers read 32 or 64 bits at once and could read over the end.\n\n @note The AVCodecContext MUST have been opened with @ref avcodec_open2()\n before packets may be fed to the decoder.\n\n @param avctx codec context\n @param[in] avpkt The input AVPacket. Usually, this will be a single video\n frame, or several complete audio frames.\n Ownership of the packet remains with the caller, and the\n decoder will not write to the packet. The decoder may create\n a reference to the packet data (or copy it if the packet is\n not reference-counted).\n Unlike with older APIs, the packet is always fully consumed,\n and if it contains multiple frames (e.g. some audio codecs),\n will require you to call avcodec_receive_frame() multiple\n times afterwards before you can send a new packet.\n It can be NULL (or an AVPacket with data set to NULL and\n size set to 0); in this case, it is considered a flush\n packet, which signals the end of the stream. Sending the\n first flush packet will return success. Subsequent ones are\n unnecessary and will return AVERROR_EOF. If the decoder\n still has frames buffered, it will return them after sending\n a flush packet.\n\n @retval 0 success\n @retval AVERROR(EAGAIN) input is not accepted in the current state - user\n must read output with avcodec_receive_frame() (once\n all output is read, the packet should be resent,\n and the call will not fail with EAGAIN).\n @retval AVERROR_EOF the decoder has been flushed, and no new packets can be\n sent to it (also returned if more than 1 flush\n packet is sent)\n @retval AVERROR(EINVAL) codec not opened, it is an encoder, or requires flush\n @retval AVERROR(ENOMEM) failed to add packet to internal queue, or similar\n @retval \"another negative error code\" legitimate decoding errors"]
7140 pub fn avcodec_send_packet(
7141 avctx: *mut AVCodecContext,
7142 avpkt: *const AVPacket,
7143 ) -> ::std::os::raw::c_int;
7144}
7145extern "C" {
7146 #[doc = " Return decoded output data from a decoder or encoder (when the\n @ref AV_CODEC_FLAG_RECON_FRAME flag is used).\n\n @param avctx codec context\n @param frame This will be set to a reference-counted video or audio\n frame (depending on the decoder type) allocated by the\n codec. Note that the function will always call\n av_frame_unref(frame) before doing anything else.\n\n @retval 0 success, a frame was returned\n @retval AVERROR(EAGAIN) output is not available in this state - user must\n try to send new input\n @retval AVERROR_EOF the codec has been fully flushed, and there will be\n no more output frames\n @retval AVERROR(EINVAL) codec not opened, or it is an encoder without the\n @ref AV_CODEC_FLAG_RECON_FRAME flag enabled\n @retval \"other negative error code\" legitimate decoding errors"]
7147 pub fn avcodec_receive_frame(
7148 avctx: *mut AVCodecContext,
7149 frame: *mut AVFrame,
7150 ) -> ::std::os::raw::c_int;
7151}
7152extern "C" {
7153 #[doc = " Supply a raw video or audio frame to the encoder. Use avcodec_receive_packet()\n to retrieve buffered output packets.\n\n @param avctx codec context\n @param[in] frame AVFrame containing the raw audio or video frame to be encoded.\n Ownership of the frame remains with the caller, and the\n encoder will not write to the frame. The encoder may create\n a reference to the frame data (or copy it if the frame is\n not reference-counted).\n It can be NULL, in which case it is considered a flush\n packet. This signals the end of the stream. If the encoder\n still has packets buffered, it will return them after this\n call. Once flushing mode has been entered, additional flush\n packets are ignored, and sending frames will return\n AVERROR_EOF.\n\n For audio:\n If AV_CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame\n can have any number of samples.\n If it is not set, frame->nb_samples must be equal to\n avctx->frame_size for all frames except the last.\n The final frame may be smaller than avctx->frame_size.\n @retval 0 success\n @retval AVERROR(EAGAIN) input is not accepted in the current state - user must\n read output with avcodec_receive_packet() (once all\n output is read, the packet should be resent, and the\n call will not fail with EAGAIN).\n @retval AVERROR_EOF the encoder has been flushed, and no new frames can\n be sent to it\n @retval AVERROR(EINVAL) codec not opened, it is a decoder, or requires flush\n @retval AVERROR(ENOMEM) failed to add packet to internal queue, or similar\n @retval \"another negative error code\" legitimate encoding errors"]
7154 pub fn avcodec_send_frame(
7155 avctx: *mut AVCodecContext,
7156 frame: *const AVFrame,
7157 ) -> ::std::os::raw::c_int;
7158}
7159extern "C" {
7160 #[doc = " Read encoded data from the encoder.\n\n @param avctx codec context\n @param avpkt This will be set to a reference-counted packet allocated by the\n encoder. Note that the function will always call\n av_packet_unref(avpkt) before doing anything else.\n @retval 0 success\n @retval AVERROR(EAGAIN) output is not available in the current state - user must\n try to send input\n @retval AVERROR_EOF the encoder has been fully flushed, and there will be no\n more output packets\n @retval AVERROR(EINVAL) codec not opened, or it is a decoder\n @retval \"another negative error code\" legitimate encoding errors"]
7161 pub fn avcodec_receive_packet(
7162 avctx: *mut AVCodecContext,
7163 avpkt: *mut AVPacket,
7164 ) -> ::std::os::raw::c_int;
7165}
7166extern "C" {
7167 #[doc = " Create and return a AVHWFramesContext with values adequate for hardware\n decoding. This is meant to get called from the get_format callback, and is\n a helper for preparing a AVHWFramesContext for AVCodecContext.hw_frames_ctx.\n This API is for decoding with certain hardware acceleration modes/APIs only.\n\n The returned AVHWFramesContext is not initialized. The caller must do this\n with av_hwframe_ctx_init().\n\n Calling this function is not a requirement, but makes it simpler to avoid\n codec or hardware API specific details when manually allocating frames.\n\n Alternatively to this, an API user can set AVCodecContext.hw_device_ctx,\n which sets up AVCodecContext.hw_frames_ctx fully automatically, and makes\n it unnecessary to call this function or having to care about\n AVHWFramesContext initialization at all.\n\n There are a number of requirements for calling this function:\n\n - It must be called from get_format with the same avctx parameter that was\n passed to get_format. Calling it outside of get_format is not allowed, and\n can trigger undefined behavior.\n - The function is not always supported (see description of return values).\n Even if this function returns successfully, hwaccel initialization could\n fail later. (The degree to which implementations check whether the stream\n is actually supported varies. Some do this check only after the user's\n get_format callback returns.)\n - The hw_pix_fmt must be one of the choices suggested by get_format. If the\n user decides to use a AVHWFramesContext prepared with this API function,\n the user must return the same hw_pix_fmt from get_format.\n - The device_ref passed to this function must support the given hw_pix_fmt.\n - After calling this API function, it is the user's responsibility to\n initialize the AVHWFramesContext (returned by the out_frames_ref parameter),\n and to set AVCodecContext.hw_frames_ctx to it. If done, this must be done\n before returning from get_format (this is implied by the normal\n AVCodecContext.hw_frames_ctx API rules).\n - The AVHWFramesContext parameters may change every time time get_format is\n called. Also, AVCodecContext.hw_frames_ctx is reset before get_format. So\n you are inherently required to go through this process again on every\n get_format call.\n - It is perfectly possible to call this function without actually using\n the resulting AVHWFramesContext. One use-case might be trying to reuse a\n previously initialized AVHWFramesContext, and calling this API function\n only to test whether the required frame parameters have changed.\n - Fields that use dynamically allocated values of any kind must not be set\n by the user unless setting them is explicitly allowed by the documentation.\n If the user sets AVHWFramesContext.free and AVHWFramesContext.user_opaque,\n the new free callback must call the potentially set previous free callback.\n This API call may set any dynamically allocated fields, including the free\n callback.\n\n The function will set at least the following fields on AVHWFramesContext\n (potentially more, depending on hwaccel API):\n\n - All fields set by av_hwframe_ctx_alloc().\n - Set the format field to hw_pix_fmt.\n - Set the sw_format field to the most suited and most versatile format. (An\n implication is that this will prefer generic formats over opaque formats\n with arbitrary restrictions, if possible.)\n - Set the width/height fields to the coded frame size, rounded up to the\n API-specific minimum alignment.\n - Only _if_ the hwaccel requires a pre-allocated pool: set the initial_pool_size\n field to the number of maximum reference surfaces possible with the codec,\n plus 1 surface for the user to work (meaning the user can safely reference\n at most 1 decoded surface at a time), plus additional buffering introduced\n by frame threading. If the hwaccel does not require pre-allocation, the\n field is left to 0, and the decoder will allocate new surfaces on demand\n during decoding.\n - Possibly AVHWFramesContext.hwctx fields, depending on the underlying\n hardware API.\n\n Essentially, out_frames_ref returns the same as av_hwframe_ctx_alloc(), but\n with basic frame parameters set.\n\n The function is stateless, and does not change the AVCodecContext or the\n device_ref AVHWDeviceContext.\n\n @param avctx The context which is currently calling get_format, and which\n implicitly contains all state needed for filling the returned\n AVHWFramesContext properly.\n @param device_ref A reference to the AVHWDeviceContext describing the device\n which will be used by the hardware decoder.\n @param hw_pix_fmt The hwaccel format you are going to return from get_format.\n @param out_frames_ref On success, set to a reference to an _uninitialized_\n AVHWFramesContext, created from the given device_ref.\n Fields will be set to values required for decoding.\n Not changed if an error is returned.\n @return zero on success, a negative value on error. The following error codes\n have special semantics:\n AVERROR(ENOENT): the decoder does not support this functionality. Setup\n is always manual, or it is a decoder which does not\n support setting AVCodecContext.hw_frames_ctx at all,\n or it is a software format.\n AVERROR(EINVAL): it is known that hardware decoding is not supported for\n this configuration, or the device_ref is not supported\n for the hwaccel referenced by hw_pix_fmt."]
7168 pub fn avcodec_get_hw_frames_parameters(
7169 avctx: *mut AVCodecContext,
7170 device_ref: *mut AVBufferRef,
7171 hw_pix_fmt: AVPixelFormat,
7172 out_frames_ref: *mut *mut AVBufferRef,
7173 ) -> ::std::os::raw::c_int;
7174}
7175#[doc = "< unknown"]
7176pub const AVPictureStructure_AV_PICTURE_STRUCTURE_UNKNOWN: AVPictureStructure = 0;
7177#[doc = "< coded as top field"]
7178pub const AVPictureStructure_AV_PICTURE_STRUCTURE_TOP_FIELD: AVPictureStructure = 1;
7179#[doc = "< coded as bottom field"]
7180pub const AVPictureStructure_AV_PICTURE_STRUCTURE_BOTTOM_FIELD: AVPictureStructure = 2;
7181#[doc = "< coded as frame"]
7182pub const AVPictureStructure_AV_PICTURE_STRUCTURE_FRAME: AVPictureStructure = 3;
7183#[doc = " @defgroup lavc_parsing Frame parsing\n @{"]
7184pub type AVPictureStructure = ::std::os::raw::c_uint;
7185#[repr(C)]
7186#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
7187pub struct AVCodecParserContext {
7188 pub priv_data: *mut ::std::os::raw::c_void,
7189 pub parser: *const AVCodecParser,
7190 pub frame_offset: i64,
7191 pub cur_offset: i64,
7192 pub next_frame_offset: i64,
7193 pub pict_type: ::std::os::raw::c_int,
7194 #[doc = " This field is used for proper frame duration computation in lavf.\n It signals, how much longer the frame duration of the current frame\n is compared to normal frame duration.\n\n frame_duration = (1 + repeat_pict) * time_base\n\n It is used by codecs like H.264 to display telecined material."]
7195 pub repeat_pict: ::std::os::raw::c_int,
7196 pub pts: i64,
7197 pub dts: i64,
7198 pub last_pts: i64,
7199 pub last_dts: i64,
7200 pub fetch_timestamp: ::std::os::raw::c_int,
7201 pub cur_frame_start_index: ::std::os::raw::c_int,
7202 pub cur_frame_offset: [i64; 4usize],
7203 pub cur_frame_pts: [i64; 4usize],
7204 pub cur_frame_dts: [i64; 4usize],
7205 pub flags: ::std::os::raw::c_int,
7206 #[doc = "< byte offset from starting packet start"]
7207 pub offset: i64,
7208 pub cur_frame_end: [i64; 4usize],
7209 #[doc = " Set by parser to 1 for key frames and 0 for non-key frames.\n It is initialized to -1, so if the parser doesn't set this flag,\n old-style fallback using AV_PICTURE_TYPE_I picture type as key frames\n will be used."]
7210 pub key_frame: ::std::os::raw::c_int,
7211 #[doc = " Synchronization point for start of timestamp generation.\n\n Set to >0 for sync point, 0 for no sync point and <0 for undefined\n (default).\n\n For example, this corresponds to presence of H.264 buffering period\n SEI message."]
7212 pub dts_sync_point: ::std::os::raw::c_int,
7213 #[doc = " Offset of the current timestamp against last timestamp sync point in\n units of AVCodecContext.time_base.\n\n Set to INT_MIN when dts_sync_point unused. Otherwise, it must\n contain a valid timestamp offset.\n\n Note that the timestamp of sync point has usually a nonzero\n dts_ref_dts_delta, which refers to the previous sync point. Offset of\n the next frame after timestamp sync point will be usually 1.\n\n For example, this corresponds to H.264 cpb_removal_delay."]
7214 pub dts_ref_dts_delta: ::std::os::raw::c_int,
7215 #[doc = " Presentation delay of current frame in units of AVCodecContext.time_base.\n\n Set to INT_MIN when dts_sync_point unused. Otherwise, it must\n contain valid non-negative timestamp delta (presentation time of a frame\n must not lie in the past).\n\n This delay represents the difference between decoding and presentation\n time of the frame.\n\n For example, this corresponds to H.264 dpb_output_delay."]
7216 pub pts_dts_delta: ::std::os::raw::c_int,
7217 #[doc = " Position of the packet in file.\n\n Analogous to cur_frame_pts/dts"]
7218 pub cur_frame_pos: [i64; 4usize],
7219 #[doc = " Byte position of currently parsed frame in stream."]
7220 pub pos: i64,
7221 #[doc = " Previous frame byte position."]
7222 pub last_pos: i64,
7223 #[doc = " Duration of the current frame.\n For audio, this is in units of 1 / AVCodecContext.sample_rate.\n For all other types, this is in units of AVCodecContext.time_base."]
7224 pub duration: ::std::os::raw::c_int,
7225 pub field_order: AVFieldOrder,
7226 #[doc = " Indicate whether a picture is coded as a frame, top field or bottom field.\n\n For example, H.264 field_pic_flag equal to 0 corresponds to\n AV_PICTURE_STRUCTURE_FRAME. An H.264 picture with field_pic_flag\n equal to 1 and bottom_field_flag equal to 0 corresponds to\n AV_PICTURE_STRUCTURE_TOP_FIELD."]
7227 pub picture_structure: AVPictureStructure,
7228 #[doc = " Picture number incremented in presentation or output order.\n This field may be reinitialized at the first picture of a new sequence.\n\n For example, this corresponds to H.264 PicOrderCnt."]
7229 pub output_picture_number: ::std::os::raw::c_int,
7230 #[doc = " Dimensions of the decoded video intended for presentation."]
7231 pub width: ::std::os::raw::c_int,
7232 pub height: ::std::os::raw::c_int,
7233 #[doc = " Dimensions of the coded video."]
7234 pub coded_width: ::std::os::raw::c_int,
7235 pub coded_height: ::std::os::raw::c_int,
7236 #[doc = " The format of the coded data, corresponds to enum AVPixelFormat for video\n and for enum AVSampleFormat for audio.\n\n Note that a decoder can have considerable freedom in how exactly it\n decodes the data, so the format reported here might be different from the\n one returned by a decoder."]
7237 pub format: ::std::os::raw::c_int,
7238}
7239impl Default for AVCodecParserContext {
7240 fn default() -> Self {
7241 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7242 unsafe {
7243 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7244 s.assume_init()
7245 }
7246 }
7247}
7248#[repr(C)]
7249#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
7250pub struct AVCodecParser {
7251 pub codec_ids: [::std::os::raw::c_int; 7usize],
7252 pub priv_data_size: ::std::os::raw::c_int,
7253 pub parser_init: ::std::option::Option<
7254 unsafe extern "C" fn(s: *mut AVCodecParserContext) -> ::std::os::raw::c_int,
7255 >,
7256 pub parser_parse: ::std::option::Option<
7257 unsafe extern "C" fn(
7258 s: *mut AVCodecParserContext,
7259 avctx: *mut AVCodecContext,
7260 poutbuf: *mut *const u8,
7261 poutbuf_size: *mut ::std::os::raw::c_int,
7262 buf: *const u8,
7263 buf_size: ::std::os::raw::c_int,
7264 ) -> ::std::os::raw::c_int,
7265 >,
7266 pub parser_close: ::std::option::Option<unsafe extern "C" fn(s: *mut AVCodecParserContext)>,
7267 pub split: ::std::option::Option<
7268 unsafe extern "C" fn(
7269 avctx: *mut AVCodecContext,
7270 buf: *const u8,
7271 buf_size: ::std::os::raw::c_int,
7272 ) -> ::std::os::raw::c_int,
7273 >,
7274}
7275extern "C" {
7276 #[doc = " Iterate over all registered codec parsers.\n\n @param opaque a pointer where libavcodec will store the iteration state. Must\n point to NULL to start the iteration.\n\n @return the next registered codec parser or NULL when the iteration is\n finished"]
7277 pub fn av_parser_iterate(opaque: *mut *mut ::std::os::raw::c_void) -> *const AVCodecParser;
7278}
7279extern "C" {
7280 pub fn av_parser_init(codec_id: ::std::os::raw::c_int) -> *mut AVCodecParserContext;
7281}
7282extern "C" {
7283 #[doc = " Parse a packet.\n\n @param s parser context.\n @param avctx codec context.\n @param poutbuf set to pointer to parsed buffer or NULL if not yet finished.\n @param poutbuf_size set to size of parsed buffer or zero if not yet finished.\n @param buf input buffer.\n @param buf_size buffer size in bytes without the padding. I.e. the full buffer\nsize is assumed to be buf_size + AV_INPUT_BUFFER_PADDING_SIZE.\nTo signal EOF, this should be 0 (so that the last frame\ncan be output).\n @param pts input presentation timestamp.\n @param dts input decoding timestamp.\n @param pos input byte position in stream.\n @return the number of bytes of the input bitstream used.\n\n Example:\n @code\n while(in_len){\n len = av_parser_parse2(myparser, AVCodecContext, &data, &size,\n in_data, in_len,\n pts, dts, pos);\n in_data += len;\n in_len -= len;\n\n if(size)\n decode_frame(data, size);\n }\n @endcode"]
7284 pub fn av_parser_parse2(
7285 s: *mut AVCodecParserContext,
7286 avctx: *mut AVCodecContext,
7287 poutbuf: *mut *mut u8,
7288 poutbuf_size: *mut ::std::os::raw::c_int,
7289 buf: *const u8,
7290 buf_size: ::std::os::raw::c_int,
7291 pts: i64,
7292 dts: i64,
7293 pos: i64,
7294 ) -> ::std::os::raw::c_int;
7295}
7296extern "C" {
7297 pub fn av_parser_close(s: *mut AVCodecParserContext);
7298}
7299extern "C" {
7300 #[doc = " @addtogroup lavc_encoding\n @{"]
7301 pub fn avcodec_encode_subtitle(
7302 avctx: *mut AVCodecContext,
7303 buf: *mut u8,
7304 buf_size: ::std::os::raw::c_int,
7305 sub: *const AVSubtitle,
7306 ) -> ::std::os::raw::c_int;
7307}
7308extern "C" {
7309 #[doc = " Return a value representing the fourCC code associated to the\n pixel format pix_fmt, or 0 if no associated fourCC code can be\n found."]
7310 pub fn avcodec_pix_fmt_to_codec_tag(pix_fmt: AVPixelFormat) -> ::std::os::raw::c_uint;
7311}
7312extern "C" {
7313 #[doc = " Find the best pixel format to convert to given a certain source pixel\n format. When converting from one pixel format to another, information loss\n may occur. For example, when converting from RGB24 to GRAY, the color\n information will be lost. Similarly, other losses occur when converting from\n some formats to other formats. avcodec_find_best_pix_fmt_of_2() searches which of\n the given pixel formats should be used to suffer the least amount of loss.\n The pixel formats from which it chooses one, are determined by the\n pix_fmt_list parameter.\n\n\n @param[in] pix_fmt_list AV_PIX_FMT_NONE terminated array of pixel formats to choose from\n @param[in] src_pix_fmt source pixel format\n @param[in] has_alpha Whether the source pixel format alpha channel is used.\n @param[out] loss_ptr Combination of flags informing you what kind of losses will occur.\n @return The best pixel format to convert to or -1 if none was found."]
7314 pub fn avcodec_find_best_pix_fmt_of_list(
7315 pix_fmt_list: *const AVPixelFormat,
7316 src_pix_fmt: AVPixelFormat,
7317 has_alpha: ::std::os::raw::c_int,
7318 loss_ptr: *mut ::std::os::raw::c_int,
7319 ) -> AVPixelFormat;
7320}
7321extern "C" {
7322 pub fn avcodec_default_get_format(
7323 s: *mut AVCodecContext,
7324 fmt: *const AVPixelFormat,
7325 ) -> AVPixelFormat;
7326}
7327extern "C" {
7328 #[doc = " @}"]
7329 pub fn avcodec_string(
7330 buf: *mut ::std::os::raw::c_char,
7331 buf_size: ::std::os::raw::c_int,
7332 enc: *mut AVCodecContext,
7333 encode: ::std::os::raw::c_int,
7334 );
7335}
7336extern "C" {
7337 pub fn avcodec_default_execute(
7338 c: *mut AVCodecContext,
7339 func: ::std::option::Option<
7340 unsafe extern "C" fn(
7341 c2: *mut AVCodecContext,
7342 arg2: *mut ::std::os::raw::c_void,
7343 ) -> ::std::os::raw::c_int,
7344 >,
7345 arg: *mut ::std::os::raw::c_void,
7346 ret: *mut ::std::os::raw::c_int,
7347 count: ::std::os::raw::c_int,
7348 size: ::std::os::raw::c_int,
7349 ) -> ::std::os::raw::c_int;
7350}
7351extern "C" {
7352 pub fn avcodec_default_execute2(
7353 c: *mut AVCodecContext,
7354 func: ::std::option::Option<
7355 unsafe extern "C" fn(
7356 c2: *mut AVCodecContext,
7357 arg2: *mut ::std::os::raw::c_void,
7358 arg1: ::std::os::raw::c_int,
7359 arg2: ::std::os::raw::c_int,
7360 ) -> ::std::os::raw::c_int,
7361 >,
7362 arg: *mut ::std::os::raw::c_void,
7363 ret: *mut ::std::os::raw::c_int,
7364 count: ::std::os::raw::c_int,
7365 ) -> ::std::os::raw::c_int;
7366}
7367extern "C" {
7368 #[doc = " Fill AVFrame audio data and linesize pointers.\n\n The buffer buf must be a preallocated buffer with a size big enough\n to contain the specified samples amount. The filled AVFrame data\n pointers will point to this buffer.\n\n AVFrame extended_data channel pointers are allocated if necessary for\n planar audio.\n\n @param frame the AVFrame\n frame->nb_samples must be set prior to calling the\n function. This function fills in frame->data,\n frame->extended_data, frame->linesize[0].\n @param nb_channels channel count\n @param sample_fmt sample format\n @param buf buffer to use for frame data\n @param buf_size size of buffer\n @param align plane size sample alignment (0 = default)\n @return >=0 on success, negative error code on failure\n @todo return the size in bytes required to store the samples in\n case of success, at the next libavutil bump"]
7369 pub fn avcodec_fill_audio_frame(
7370 frame: *mut AVFrame,
7371 nb_channels: ::std::os::raw::c_int,
7372 sample_fmt: AVSampleFormat,
7373 buf: *const u8,
7374 buf_size: ::std::os::raw::c_int,
7375 align: ::std::os::raw::c_int,
7376 ) -> ::std::os::raw::c_int;
7377}
7378extern "C" {
7379 #[doc = " Reset the internal codec state / flush internal buffers. Should be called\n e.g. when seeking or when switching to a different stream.\n\n @note for decoders, this function just releases any references the decoder\n might keep internally, but the caller's references remain valid.\n\n @note for encoders, this function will only do something if the encoder\n declares support for AV_CODEC_CAP_ENCODER_FLUSH. When called, the encoder\n will drain any remaining packets, and can then be re-used for a different\n stream (as opposed to sending a null frame which will leave the encoder\n in a permanent EOF state after draining). This can be desirable if the\n cost of tearing down and replacing the encoder instance is high."]
7380 pub fn avcodec_flush_buffers(avctx: *mut AVCodecContext);
7381}
7382extern "C" {
7383 #[doc = " Return audio frame duration.\n\n @param avctx codec context\n @param frame_bytes size of the frame, or 0 if unknown\n @return frame duration, in samples, if known. 0 if not able to\n determine."]
7384 pub fn av_get_audio_frame_duration(
7385 avctx: *mut AVCodecContext,
7386 frame_bytes: ::std::os::raw::c_int,
7387 ) -> ::std::os::raw::c_int;
7388}
7389extern "C" {
7390 #[doc = " Same behaviour av_fast_malloc but the buffer has additional\n AV_INPUT_BUFFER_PADDING_SIZE at the end which will always be 0.\n\n In addition the whole buffer will initially and after resizes\n be 0-initialized so that no uninitialized data will ever appear."]
7391 pub fn av_fast_padded_malloc(
7392 ptr: *mut ::std::os::raw::c_void,
7393 size: *mut ::std::os::raw::c_uint,
7394 min_size: usize,
7395 );
7396}
7397extern "C" {
7398 #[doc = " Same behaviour av_fast_padded_malloc except that buffer will always\n be 0-initialized after call."]
7399 pub fn av_fast_padded_mallocz(
7400 ptr: *mut ::std::os::raw::c_void,
7401 size: *mut ::std::os::raw::c_uint,
7402 min_size: usize,
7403 );
7404}
7405extern "C" {
7406 #[doc = " @return a positive value if s is open (i.e. avcodec_open2() was called on it\n with no corresponding avcodec_close()), 0 otherwise."]
7407 pub fn avcodec_is_open(s: *mut AVCodecContext) -> ::std::os::raw::c_int;
7408}
7409pub type __builtin_va_list = *mut ::std::os::raw::c_void;
7410#[doc = " a pointer to the first option specified in the class if any or NULL\n\n @see av_set_default_options()"]
7411#[repr(C)]
7412#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
7413pub struct AVOption {
7414 pub _address: u8,
7415}
7416#[doc = " Private context used for internal data.\n\n Unlike priv_data, this is not codec-specific. It is used in general\n libavcodec functions."]
7417#[repr(C)]
7418#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
7419pub struct AVCodecInternal {
7420 pub _address: u8,
7421}