1 // This header was generated from the FFMPEG headers
2 #pragma once
3
4 #include <errno.h>
5 #include <time.h>
6 #include <stdint.h>
7 #include <stdlib.h>
8 #include <limits.h>
9 #include <stddef.h>
10 #include <math.h>
11 #include <stdarg.h>
12 #include <inttypes.h>
13 #include <stdio.h>
14 #include <string.h>
15
16 #define AVCODEC_AVCODEC_H
17
18 #define AVUTIL_SAMPLEFMT_H
19
20 #define AVUTIL_AVUTIL_H
21
22 unsigned avutil_version(void);
23
24 const char *avutil_configuration(void);
25
26 const char *avutil_license(void);
27
28 enum AVMediaType {
29 AVMEDIA_TYPE_UNKNOWN = -1,
30 AVMEDIA_TYPE_VIDEO,
31 AVMEDIA_TYPE_AUDIO,
32 AVMEDIA_TYPE_DATA,
33 AVMEDIA_TYPE_SUBTITLE,
34 AVMEDIA_TYPE_ATTACHMENT,
35 AVMEDIA_TYPE_NB
36 };
37
38 const char *av_get_media_type_string(enum AVMediaType media_type);
39
40 #define FF_LAMBDA_SHIFT 7
41 #define FF_LAMBDA_SCALE (1<<FF_LAMBDA_SHIFT)
42 #define FF_QP2LAMBDA 118
43 #define FF_LAMBDA_MAX (256*128-1)
44
45 #define FF_QUALITY_SCALE FF_LAMBDA_SCALE
46
47 #define AV_NOPTS_VALUE ((int64_t)UINT64_C(0x8000000000000000))
48
49 #define AV_TIME_BASE 1000000
50
51 #define AV_TIME_BASE_Q (AVRational){1, AV_TIME_BASE}
52
53 enum AVPictureType {
54 AV_PICTURE_TYPE_NONE = 0,
55 AV_PICTURE_TYPE_I,
56 AV_PICTURE_TYPE_P,
57 AV_PICTURE_TYPE_B,
58 AV_PICTURE_TYPE_S,
59 AV_PICTURE_TYPE_SI,
60 AV_PICTURE_TYPE_SP,
61 AV_PICTURE_TYPE_BI,
62 };
63
64 char av_get_picture_type_char(enum AVPictureType pict_type);
65
66 #define AVUTIL_COMMON_H
67
68 #define AVUTIL_ATTRIBUTES_H
69
70 # define AV_GCC_VERSION_AT_LEAST(x,y) 0
71
72 # define av_always_inline inline
73
74 # define av_extern_inline inline
75
76 # define av_noinline
77
78 # define av_pure
79
80 # define av_const
81
82 # define av_cold
83
84 # define av_flatten
85
86 # define attribute_deprecated
87
88 # define AV_NOWARN_DEPRECATED(code) code
89
90 # define av_unused
91
92 # define av_used
93
94 # define av_alias
95
96 # define av_uninit(x) x
97
98 # define av_builtin_constant_p(x) 0
99 # define av_printf_format(fmtpos, attrpos)
100
101 # define av_noreturn
102
103 #define AVUTIL_VERSION_H
104
105 #define AVUTIL_MACROS_H
106
107 #define AV_STRINGIFY(s) AV_TOSTRING(s)
108 #define AV_TOSTRING(s) #s
109
110 #define AV_GLUE(a, b) a ## b
111 #define AV_JOIN(a, b) AV_GLUE(a, b)
112
113 #define AV_PRAGMA(s) _Pragma(#s)
114
115 #define AV_VERSION_INT(a, b, c) (a<<16 | b<<8 | c)
116 #define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c
117 #define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)
118
119 #define LIBAVUTIL_VERSION_MAJOR 52
120 #define LIBAVUTIL_VERSION_MINOR 92
121 #define LIBAVUTIL_VERSION_MICRO 100
122
123 #define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
124 LIBAVUTIL_VERSION_MINOR, \
125 LIBAVUTIL_VERSION_MICRO)
126 #define LIBAVUTIL_VERSION AV_VERSION(LIBAVUTIL_VERSION_MAJOR, \
127 LIBAVUTIL_VERSION_MINOR, \
128 LIBAVUTIL_VERSION_MICRO)
129 #define LIBAVUTIL_BUILD LIBAVUTIL_VERSION_INT
130
131 #define LIBAVUTIL_IDENT "Lavu" AV_STRINGIFY(LIBAVUTIL_VERSION)
132
133 #define FF_API_GET_BITS_PER_SAMPLE_FMT (LIBAVUTIL_VERSION_MAJOR < 54)
134 #define FF_API_FIND_OPT (LIBAVUTIL_VERSION_MAJOR < 54)
135 #define FF_API_OLD_AVOPTIONS (LIBAVUTIL_VERSION_MAJOR < 54)
136 #define FF_API_PIX_FMT (LIBAVUTIL_VERSION_MAJOR < 54)
137 #define FF_API_CONTEXT_SIZE (LIBAVUTIL_VERSION_MAJOR < 54)
138 #define FF_API_PIX_FMT_DESC (LIBAVUTIL_VERSION_MAJOR < 54)
139 #define FF_API_AV_REVERSE (LIBAVUTIL_VERSION_MAJOR < 54)
140 #define FF_API_AUDIOCONVERT (LIBAVUTIL_VERSION_MAJOR < 54)
141 #define FF_API_CPU_FLAG_MMX2 (LIBAVUTIL_VERSION_MAJOR < 54)
142 #define FF_API_SAMPLES_UTILS_RETURN_ZERO (LIBAVUTIL_VERSION_MAJOR < 54)
143 #define FF_API_LLS_PRIVATE (LIBAVUTIL_VERSION_MAJOR < 54)
144 #define FF_API_LLS1 (LIBAVUTIL_VERSION_MAJOR < 54)
145 #define FF_API_AVFRAME_LAVC (LIBAVUTIL_VERSION_MAJOR < 54)
146 #define FF_API_VDPAU (LIBAVUTIL_VERSION_MAJOR < 54)
147 #define FF_API_GET_CHANNEL_LAYOUT_COMPAT (LIBAVUTIL_VERSION_MAJOR < 54)
148 #define FF_API_OLD_OPENCL (LIBAVUTIL_VERSION_MAJOR < 54)
149 #define FF_API_XVMC (LIBAVUTIL_VERSION_MAJOR < 54)
150 #define FF_API_INTFLOAT (LIBAVUTIL_VERSION_MAJOR < 54)
151 #define FF_API_OPT_TYPE_METADATA (LIBAVUTIL_VERSION_MAJOR < 54)
152 #define FF_API_AVFRAME_COLORSPACE (LIBAVUTIL_VERSION_MAJOR >= 52)
153
154 #define FF_CONST_AVUTIL53
155
156 # define AV_NE(be, le) (le)
157
158 #define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))
159
160 #define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
161
162 #define FF_CEIL_RSHIFT(a,b) (!av_builtin_constant_p(b) ? -((-(a)) >> (b)) \
163 : ((a) + (1<<(b)) - 1) >> (b))
164 #define FFUDIV(a,b) (((a)>0 ?(a):(a)-(b)+1) / (b))
165 #define FFUMOD(a,b) ((a)-(b)*FFUDIV(a,b))
166 #define FFABS(a) ((a) >= 0 ? (a) : (-(a)))
167 #define FFSIGN(a) ((a) > 0 ? 1 : -1)
168
169 #define FFMAX(a,b) ((a) > (b) ? (a) : (b))
170 #define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
171 #define FFMIN(a,b) ((a) > (b) ? (b) : (a))
172 #define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
173
174 #define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
175 #define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
176 #define FFALIGN(x, a) (((x)+(a)-1)&~((a)-1))
177
178 extern attribute_deprecated const uint8_t av_reverse[256];
179
180 # define av_ceil_log2 av_ceil_log2_c
181 # define av_clip av_clip_c
182 # define av_clip64 av_clip64_c
183 # define av_clip_uint8 av_clip_uint8_c
184 # define av_clip_int8 av_clip_int8_c
185 # define av_clip_uint16 av_clip_uint16_c
186 # define av_clip_int16 av_clip_int16_c
187 # define av_clipl_int32 av_clipl_int32_c
188 # define av_clip_uintp2 av_clip_uintp2_c
189 # define av_sat_add32 av_sat_add32_c
190 # define av_sat_dadd32 av_sat_dadd32_c
191 # define av_clipf av_clipf_c
192 # define av_clipd av_clipd_c
193 # define av_popcount av_popcount_c
194 # define av_popcount64 av_popcount64_c
195
196 av_const int av_log2(unsigned v);
197
198 av_const int av_log2_16bit(unsigned v);
199
av_clip_c(int a,int amin,int amax)200 static av_always_inline av_const int av_clip_c(int a, int amin, int amax)
201 {
202 if (a < amin) return amin;
203 else if (a > amax) return amax;
204 else return a;
205 }
206
av_clip64_c(int64_t a,int64_t amin,int64_t amax)207 static av_always_inline av_const int64_t av_clip64_c(int64_t a, int64_t amin, int64_t amax)
208 {
209 if (a < amin) return amin;
210 else if (a > amax) return amax;
211 else return a;
212 }
213
av_clip_uint8_c(int a)214 static av_always_inline av_const uint8_t av_clip_uint8_c(int a)
215 {
216 if (a&(~0xFF)) return (-a)>>31;
217 else return a;
218 }
219
av_clip_int8_c(int a)220 static av_always_inline av_const int8_t av_clip_int8_c(int a)
221 {
222 if ((a+0x80) & ~0xFF) return (a>>31) ^ 0x7F;
223 else return a;
224 }
225
av_clip_uint16_c(int a)226 static av_always_inline av_const uint16_t av_clip_uint16_c(int a)
227 {
228 if (a&(~0xFFFF)) return (-a)>>31;
229 else return a;
230 }
231
av_clip_int16_c(int a)232 static av_always_inline av_const int16_t av_clip_int16_c(int a)
233 {
234 if ((a+0x8000) & ~0xFFFF) return (a>>31) ^ 0x7FFF;
235 else return a;
236 }
237
av_clipl_int32_c(int64_t a)238 static av_always_inline av_const int32_t av_clipl_int32_c(int64_t a)
239 {
240 if ((a+0x80000000u) & ~UINT64_C(0xFFFFFFFF)) return (int32_t)((a>>63) ^ 0x7FFFFFFF);
241 else return (int32_t)a;
242 }
243
av_clip_uintp2_c(int a,int p)244 static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
245 {
246 if (a & ~((1<<p) - 1)) return -a >> 31 & ((1<<p) - 1);
247 else return a;
248 }
249
av_sat_add32_c(int a,int b)250 static av_always_inline int av_sat_add32_c(int a, int b)
251 {
252 return av_clipl_int32((int64_t)a + b);
253 }
254
av_sat_dadd32_c(int a,int b)255 static av_always_inline int av_sat_dadd32_c(int a, int b)
256 {
257 return av_sat_add32(a, av_sat_add32(b, b));
258 }
259
av_clipf_c(float a,float amin,float amax)260 static av_always_inline av_const float av_clipf_c(float a, float amin, float amax)
261 {
262 if (a < amin) return amin;
263 else if (a > amax) return amax;
264 else return a;
265 }
266
av_clipd_c(double a,double amin,double amax)267 static av_always_inline av_const double av_clipd_c(double a, double amin, double amax)
268 {
269 if (a < amin) return amin;
270 else if (a > amax) return amax;
271 else return a;
272 }
273
av_ceil_log2_c(int x)274 static av_always_inline av_const int av_ceil_log2_c(int x)
275 {
276 return av_log2((x - 1) << 1);
277 }
278
av_popcount_c(uint32_t x)279 static av_always_inline av_const int av_popcount_c(uint32_t x)
280 {
281 x -= (x >> 1) & 0x55555555;
282 x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
283 x = (x + (x >> 4)) & 0x0F0F0F0F;
284 x += x >> 8;
285 return (x + (x >> 16)) & 0x3F;
286 }
287
av_popcount64_c(uint64_t x)288 static av_always_inline av_const int av_popcount64_c(uint64_t x)
289 {
290 return av_popcount((uint32_t)x) + av_popcount((uint32_t)(x >> 32));
291 }
292
293 #define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
294 #define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
295
296 #define GET_UTF8(val, GET_BYTE, ERROR)\
297 val= GET_BYTE;\
298 {\
299 uint32_t top = (val & 128) >> 1;\
300 if ((val & 0xc0) == 0x80 || val >= 0xFE)\
301 ERROR\
302 while (val & top) {\
303 int tmp= GET_BYTE - 128;\
304 if(tmp>>6)\
305 ERROR\
306 val= (val<<6) + tmp;\
307 top <<= 5;\
308 }\
309 val &= (top << 1) - 1;\
310 }
311
312 #define GET_UTF16(val, GET_16BIT, ERROR)\
313 val = GET_16BIT;\
314 {\
315 unsigned int hi = val - 0xD800;\
316 if (hi < 0x800) {\
317 val = GET_16BIT - 0xDC00;\
318 if (val > 0x3FFU || hi > 0x3FFU)\
319 ERROR\
320 val += (hi<<10) + 0x10000;\
321 }\
322 }\
323
324 #define PUT_UTF8(val, tmp, PUT_BYTE)\
325 {\
326 int bytes, shift;\
327 uint32_t in = val;\
328 if (in < 0x80) {\
329 tmp = in;\
330 PUT_BYTE\
331 } else {\
332 bytes = (av_log2(in) + 4) / 5;\
333 shift = (bytes - 1) * 6;\
334 tmp = (256 - (256 >> bytes)) | (in >> shift);\
335 PUT_BYTE\
336 while (shift >= 6) {\
337 shift -= 6;\
338 tmp = 0x80 | ((in >> shift) & 0x3f);\
339 PUT_BYTE\
340 }\
341 }\
342 }
343
344 #define PUT_UTF16(val, tmp, PUT_16BIT)\
345 {\
346 uint32_t in = val;\
347 if (in < 0x10000) {\
348 tmp = in;\
349 PUT_16BIT\
350 } else {\
351 tmp = 0xD800 | ((in - 0x10000) >> 10);\
352 PUT_16BIT\
353 tmp = 0xDC00 | ((in - 0x10000) & 0x3FF);\
354 PUT_16BIT\
355 }\
356 }\
357
358 #define AVUTIL_MEM_H
359
360 #define AVUTIL_ERROR_H
361
362 #define AVERROR(e) (e)
363 #define AVUNERROR(e) (e)
364
365 #define FFERRTAG(a, b, c, d) (-(int)MKTAG(a, b, c, d))
366
367 #define AVERROR_BSF_NOT_FOUND FFERRTAG(0xF8,'B','S','F')
368 #define AVERROR_BUG FFERRTAG( 'B','U','G','!')
369 #define AVERROR_BUFFER_TOO_SMALL FFERRTAG( 'B','U','F','S')
370 #define AVERROR_DECODER_NOT_FOUND FFERRTAG(0xF8,'D','E','C')
371 #define AVERROR_DEMUXER_NOT_FOUND FFERRTAG(0xF8,'D','E','M')
372 #define AVERROR_ENCODER_NOT_FOUND FFERRTAG(0xF8,'E','N','C')
373 #define AVERROR_EOF FFERRTAG( 'E','O','F',' ')
374 #define AVERROR_EXIT FFERRTAG( 'E','X','I','T')
375 #define AVERROR_EXTERNAL FFERRTAG( 'E','X','T',' ')
376 #define AVERROR_FILTER_NOT_FOUND FFERRTAG(0xF8,'F','I','L')
377 #define AVERROR_INVALIDDATA FFERRTAG( 'I','N','D','A')
378 #define AVERROR_MUXER_NOT_FOUND FFERRTAG(0xF8,'M','U','X')
379 #define AVERROR_OPTION_NOT_FOUND FFERRTAG(0xF8,'O','P','T')
380 #define AVERROR_PATCHWELCOME FFERRTAG( 'P','A','W','E')
381 #define AVERROR_PROTOCOL_NOT_FOUND FFERRTAG(0xF8,'P','R','O')
382
383 #define AVERROR_STREAM_NOT_FOUND FFERRTAG(0xF8,'S','T','R')
384
385 #define AVERROR_BUG2 FFERRTAG( 'B','U','G',' ')
386 #define AVERROR_UNKNOWN FFERRTAG( 'U','N','K','N')
387 #define AVERROR_EXPERIMENTAL (-0x2bb2afa8)
388
389 #define AV_ERROR_MAX_STRING_SIZE 64
390
391 int av_strerror(int errnum, char *errbuf, size_t errbuf_size);
392
av_make_error_string(char * errbuf,size_t errbuf_size,int errnum)393 static inline char *av_make_error_string(char *errbuf, size_t errbuf_size, int errnum)
394 {
395 av_strerror(errnum, errbuf, errbuf_size);
396 return errbuf;
397 }
398
399 #define av_err2str(errnum) \
400 av_make_error_string((char[AV_ERROR_MAX_STRING_SIZE]){0}, AV_ERROR_MAX_STRING_SIZE, errnum)
401
402 #define DECLARE_ALIGNED(n,t,v) t v
403 #define DECLARE_ASM_CONST(n,t,v) static const t v
404
405 #define av_malloc_attrib
406
407 #define av_alloc_size(...)
408
409 void *av_malloc(size_t size) av_malloc_attrib av_alloc_size(1);
410
av_malloc_array(size_t nmemb,size_t size)411 av_alloc_size(1, 2) static inline void *av_malloc_array(size_t nmemb, size_t size)
412 {
413 if (!size || nmemb >= INT_MAX / size)
414 return NULL;
415 return av_malloc(nmemb * size);
416 }
417
418 void *av_realloc(void *ptr, size_t size) av_alloc_size(2);
419
420 void *av_realloc_f(void *ptr, size_t nelem, size_t elsize);
421
422 int av_reallocp(void *ptr, size_t size);
423
424 av_alloc_size(2, 3) void *av_realloc_array(void *ptr, size_t nmemb, size_t size);
425
426 av_alloc_size(2, 3) int av_reallocp_array(void *ptr, size_t nmemb, size_t size);
427
428 void av_free(void *ptr);
429
430 void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1);
431
432 void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib;
433
av_mallocz_array(size_t nmemb,size_t size)434 av_alloc_size(1, 2) static inline void *av_mallocz_array(size_t nmemb, size_t size)
435 {
436 if (!size || nmemb >= INT_MAX / size)
437 return NULL;
438 return av_mallocz(nmemb * size);
439 }
440
441 char *av_strdup(const char *s) av_malloc_attrib;
442
443 void *av_memdup(const void *p, size_t size);
444
445 void av_freep(void *ptr);
446
447 void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem);
448
449 int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem);
450
451 void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
452 const uint8_t *elem_data);
453
av_size_mult(size_t a,size_t b,size_t * r)454 static inline int av_size_mult(size_t a, size_t b, size_t *r)
455 {
456 size_t t = a * b;
457
458 if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
459 return AVERROR(EINVAL);
460 *r = t;
461 return 0;
462 }
463
464 void av_max_alloc(size_t max);
465
466 void av_memcpy_backptr(uint8_t *dst, int back, int cnt);
467
468 void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size);
469
470 void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size);
471
472 #define AVUTIL_RATIONAL_H
473
474 typedef struct AVRational{
475 int num;
476 int den;
477 } AVRational;
478
av_make_q(int num,int den)479 static inline AVRational av_make_q(int num, int den)
480 {
481 AVRational r = { num, den };
482 return r;
483 }
484
av_cmp_q(AVRational a,AVRational b)485 static inline int av_cmp_q(AVRational a, AVRational b){
486 const int64_t tmp= a.num * (int64_t)b.den - b.num * (int64_t)a.den;
487
488 if(tmp) return (int)((tmp ^ a.den ^ b.den)>>63)|1;
489 else if(b.den && a.den) return 0;
490 else if(a.num && b.num) return (a.num>>31) - (b.num>>31);
491 else return INT_MIN;
492 }
493
av_q2d(AVRational a)494 static inline double av_q2d(AVRational a){
495 return a.num / (double) a.den;
496 }
497
498 int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max);
499
500 AVRational av_mul_q(AVRational b, AVRational c) av_const;
501
502 AVRational av_div_q(AVRational b, AVRational c) av_const;
503
504 AVRational av_add_q(AVRational b, AVRational c) av_const;
505
506 AVRational av_sub_q(AVRational b, AVRational c) av_const;
507
av_inv_q(AVRational q)508 static av_always_inline AVRational av_inv_q(AVRational q)
509 {
510 AVRational r = { q.den, q.num };
511 return r;
512 }
513
514 AVRational av_d2q(double d, int max) av_const;
515
516 int av_nearer_q(AVRational q, AVRational q1, AVRational q2);
517
518 int av_find_nearest_q_idx(AVRational q, const AVRational* q_list);
519
520 #define AVUTIL_MATHEMATICS_H
521
522 #define AVUTIL_INTFLOAT_H
523
524 union av_intfloat32 {
525 uint32_t i;
526 float f;
527 };
528
529 union av_intfloat64 {
530 uint64_t i;
531 double f;
532 };
533
av_int2float(uint32_t i)534 static av_always_inline float av_int2float(uint32_t i)
535 {
536 union av_intfloat32 v;
537 v.i = i;
538 return v.f;
539 }
540
av_float2int(float f)541 static av_always_inline uint32_t av_float2int(float f)
542 {
543 union av_intfloat32 v;
544 v.f = f;
545 return v.i;
546 }
547
av_int2double(uint64_t i)548 static av_always_inline double av_int2double(uint64_t i)
549 {
550 union av_intfloat64 v;
551 v.i = i;
552 return v.f;
553 }
554
av_double2int(double f)555 static av_always_inline uint64_t av_double2int(double f)
556 {
557 union av_intfloat64 v;
558 v.f = f;
559 return v.i;
560 }
561
562 #define M_E 2.7182818284590452354
563 #define M_LN2 0.69314718055994530942
564 #define M_LN10 2.30258509299404568402
565 #define M_LOG2_10 3.32192809488736234787
566 #define M_PHI 1.61803398874989484820
567 #define M_PI 3.14159265358979323846
568 #define M_PI_2 1.57079632679489661923
569 #define M_SQRT1_2 0.70710678118654752440
570 #define M_SQRT2 1.41421356237309504880
571 #define NAN av_int2float(0x7fc00000)
572 #define INFINITY av_int2float(0x7f800000)
573
574 enum AVRounding {
575 AV_ROUND_ZERO = 0,
576 AV_ROUND_INF = 1,
577 AV_ROUND_DOWN = 2,
578 AV_ROUND_UP = 3,
579 AV_ROUND_NEAR_INF = 5,
580 AV_ROUND_PASS_MINMAX = 8192,
581 };
582
583 int64_t av_const av_gcd(int64_t a, int64_t b);
584
585 int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const;
586
587 int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding) av_const;
588
589 int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const;
590
591 int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq,
592 enum AVRounding) av_const;
593
594 int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b);
595
596 int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod);
597
598 int64_t av_rescale_delta(AVRational in_tb, int64_t in_ts, AVRational fs_tb, int duration, int64_t *last, AVRational out_tb);
599
600 int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc);
601
602 #define AVUTIL_LOG_H
603
604 typedef enum {
605 AV_CLASS_CATEGORY_NA = 0,
606 AV_CLASS_CATEGORY_INPUT,
607 AV_CLASS_CATEGORY_OUTPUT,
608 AV_CLASS_CATEGORY_MUXER,
609 AV_CLASS_CATEGORY_DEMUXER,
610 AV_CLASS_CATEGORY_ENCODER,
611 AV_CLASS_CATEGORY_DECODER,
612 AV_CLASS_CATEGORY_FILTER,
613 AV_CLASS_CATEGORY_BITSTREAM_FILTER,
614 AV_CLASS_CATEGORY_SWSCALER,
615 AV_CLASS_CATEGORY_SWRESAMPLER,
616 AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT = 40,
617 AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
618 AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT,
619 AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT,
620 AV_CLASS_CATEGORY_DEVICE_OUTPUT,
621 AV_CLASS_CATEGORY_DEVICE_INPUT,
622 AV_CLASS_CATEGORY_NB,
623 }AVClassCategory;
624
625 struct AVOptionRanges;
626
627 typedef struct AVClass {
628
629 const char* class_name;
630
631 const char* (*item_name)(void* ctx);
632
633 const struct AVOption *option;
634
635 int version;
636
637 int log_level_offset_offset;
638
639 int parent_log_context_offset;
640
641 void* (*child_next)(void *obj, void *prev);
642
643 const struct AVClass* (*child_class_next)(const struct AVClass *prev);
644
645 AVClassCategory category;
646
647 AVClassCategory (*get_category)(void* ctx);
648
649 int (*query_ranges)(struct AVOptionRanges **, void *obj, const char *key, int flags);
650 } AVClass;
651
652 #define AV_LOG_QUIET -8
653
654 #define AV_LOG_PANIC 0
655
656 #define AV_LOG_FATAL 8
657
658 #define AV_LOG_ERROR 16
659
660 #define AV_LOG_WARNING 24
661
662 #define AV_LOG_INFO 32
663
664 #define AV_LOG_VERBOSE 40
665
666 #define AV_LOG_DEBUG 48
667
668 #define AV_LOG_MAX_OFFSET (AV_LOG_DEBUG - AV_LOG_QUIET)
669
670 #define AV_LOG_C(x) (x << 8)
671
672 void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4);
673
674 void av_vlog(void *avcl, int level, const char *fmt, va_list vl);
675
676 int av_log_get_level(void);
677
678 void av_log_set_level(int level);
679
680 void av_log_set_callback(void (*callback)(void*, int, const char*, va_list));
681
682 void av_log_default_callback(void *avcl, int level, const char *fmt,
683 va_list vl);
684
685 const char* av_default_item_name(void* ctx);
686 AVClassCategory av_default_get_category(void *ptr);
687
688 void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl,
689 char *line, int line_size, int *print_prefix);
690
691 # define av_dlog(pctx, ...) do { if (0) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__); } while (0)
692
693 #define AV_LOG_SKIP_REPEATED 1
694
695 #define AV_LOG_PRINT_LEVEL 2
696
697 void av_log_set_flags(int arg);
698 int av_log_get_flags(void);
699
700 #define AVUTIL_PIXFMT_H
701
702 #define AVPALETTE_SIZE 1024
703 #define AVPALETTE_COUNT 256
704
705 enum AVPixelFormat {
706 AV_PIX_FMT_NONE = -1,
707 AV_PIX_FMT_YUV420P,
708 AV_PIX_FMT_YUYV422,
709 AV_PIX_FMT_RGB24,
710 AV_PIX_FMT_BGR24,
711 AV_PIX_FMT_YUV422P,
712 AV_PIX_FMT_YUV444P,
713 AV_PIX_FMT_YUV410P,
714 AV_PIX_FMT_YUV411P,
715 AV_PIX_FMT_GRAY8,
716 AV_PIX_FMT_MONOWHITE,
717 AV_PIX_FMT_MONOBLACK,
718 AV_PIX_FMT_PAL8,
719 AV_PIX_FMT_YUVJ420P,
720 AV_PIX_FMT_YUVJ422P,
721 AV_PIX_FMT_YUVJ444P,
722 AV_PIX_FMT_XVMC_MPEG2_MC,
723 AV_PIX_FMT_XVMC_MPEG2_IDCT,
724 #define AV_PIX_FMT_XVMC AV_PIX_FMT_XVMC_MPEG2_IDCT
725 AV_PIX_FMT_UYVY422,
726 AV_PIX_FMT_UYYVYY411,
727 AV_PIX_FMT_BGR8,
728 AV_PIX_FMT_BGR4,
729 AV_PIX_FMT_BGR4_BYTE,
730 AV_PIX_FMT_RGB8,
731 AV_PIX_FMT_RGB4,
732 AV_PIX_FMT_RGB4_BYTE,
733 AV_PIX_FMT_NV12,
734 AV_PIX_FMT_NV21,
735
736 AV_PIX_FMT_ARGB,
737 AV_PIX_FMT_RGBA,
738 AV_PIX_FMT_ABGR,
739 AV_PIX_FMT_BGRA,
740
741 AV_PIX_FMT_GRAY16BE,
742 AV_PIX_FMT_GRAY16LE,
743 AV_PIX_FMT_YUV440P,
744 AV_PIX_FMT_YUVJ440P,
745 AV_PIX_FMT_YUVA420P,
746 AV_PIX_FMT_VDPAU_H264,
747 AV_PIX_FMT_VDPAU_MPEG1,
748 AV_PIX_FMT_VDPAU_MPEG2,
749 AV_PIX_FMT_VDPAU_WMV3,
750 AV_PIX_FMT_VDPAU_VC1,
751 AV_PIX_FMT_RGB48BE,
752 AV_PIX_FMT_RGB48LE,
753
754 AV_PIX_FMT_RGB565BE,
755 AV_PIX_FMT_RGB565LE,
756 AV_PIX_FMT_RGB555BE,
757 AV_PIX_FMT_RGB555LE,
758
759 AV_PIX_FMT_BGR565BE,
760 AV_PIX_FMT_BGR565LE,
761 AV_PIX_FMT_BGR555BE,
762 AV_PIX_FMT_BGR555LE,
763
764 AV_PIX_FMT_VAAPI_MOCO,
765 AV_PIX_FMT_VAAPI_IDCT,
766 AV_PIX_FMT_VAAPI_VLD,
767
768 AV_PIX_FMT_YUV420P16LE,
769 AV_PIX_FMT_YUV420P16BE,
770 AV_PIX_FMT_YUV422P16LE,
771 AV_PIX_FMT_YUV422P16BE,
772 AV_PIX_FMT_YUV444P16LE,
773 AV_PIX_FMT_YUV444P16BE,
774 AV_PIX_FMT_VDPAU_MPEG4,
775 AV_PIX_FMT_DXVA2_VLD,
776
777 AV_PIX_FMT_RGB444LE,
778 AV_PIX_FMT_RGB444BE,
779 AV_PIX_FMT_BGR444LE,
780 AV_PIX_FMT_BGR444BE,
781 AV_PIX_FMT_GRAY8A,
782 AV_PIX_FMT_BGR48BE,
783 AV_PIX_FMT_BGR48LE,
784
785 AV_PIX_FMT_YUV420P9BE,
786 AV_PIX_FMT_YUV420P9LE,
787 AV_PIX_FMT_YUV420P10BE,
788 AV_PIX_FMT_YUV420P10LE,
789 AV_PIX_FMT_YUV422P10BE,
790 AV_PIX_FMT_YUV422P10LE,
791 AV_PIX_FMT_YUV444P9BE,
792 AV_PIX_FMT_YUV444P9LE,
793 AV_PIX_FMT_YUV444P10BE,
794 AV_PIX_FMT_YUV444P10LE,
795 AV_PIX_FMT_YUV422P9BE,
796 AV_PIX_FMT_YUV422P9LE,
797 AV_PIX_FMT_VDA_VLD,
798
799 AV_PIX_FMT_GBRP,
800 AV_PIX_FMT_GBRP9BE,
801 AV_PIX_FMT_GBRP9LE,
802 AV_PIX_FMT_GBRP10BE,
803 AV_PIX_FMT_GBRP10LE,
804 AV_PIX_FMT_GBRP16BE,
805 AV_PIX_FMT_GBRP16LE,
806
807 AV_PIX_FMT_YUVA422P_LIBAV,
808 AV_PIX_FMT_YUVA444P_LIBAV,
809
810 AV_PIX_FMT_YUVA420P9BE,
811 AV_PIX_FMT_YUVA420P9LE,
812 AV_PIX_FMT_YUVA422P9BE,
813 AV_PIX_FMT_YUVA422P9LE,
814 AV_PIX_FMT_YUVA444P9BE,
815 AV_PIX_FMT_YUVA444P9LE,
816 AV_PIX_FMT_YUVA420P10BE,
817 AV_PIX_FMT_YUVA420P10LE,
818 AV_PIX_FMT_YUVA422P10BE,
819 AV_PIX_FMT_YUVA422P10LE,
820 AV_PIX_FMT_YUVA444P10BE,
821 AV_PIX_FMT_YUVA444P10LE,
822 AV_PIX_FMT_YUVA420P16BE,
823 AV_PIX_FMT_YUVA420P16LE,
824 AV_PIX_FMT_YUVA422P16BE,
825 AV_PIX_FMT_YUVA422P16LE,
826 AV_PIX_FMT_YUVA444P16BE,
827 AV_PIX_FMT_YUVA444P16LE,
828
829 AV_PIX_FMT_VDPAU,
830
831 AV_PIX_FMT_XYZ12LE,
832 AV_PIX_FMT_XYZ12BE,
833 AV_PIX_FMT_NV16,
834 AV_PIX_FMT_NV20LE,
835 AV_PIX_FMT_NV20BE,
836
837 AV_PIX_FMT_RGBA64BE_LIBAV,
838 AV_PIX_FMT_RGBA64LE_LIBAV,
839 AV_PIX_FMT_BGRA64BE_LIBAV,
840 AV_PIX_FMT_BGRA64LE_LIBAV,
841
842 AV_PIX_FMT_YVYU422,
843
844 AV_PIX_FMT_VDA,
845
846 AV_PIX_FMT_RGBA64BE=0x123,
847 AV_PIX_FMT_RGBA64LE,
848 AV_PIX_FMT_BGRA64BE,
849 AV_PIX_FMT_BGRA64LE,
850 AV_PIX_FMT_0RGB=0x123+4,
851 AV_PIX_FMT_RGB0,
852 AV_PIX_FMT_0BGR,
853 AV_PIX_FMT_BGR0,
854 AV_PIX_FMT_YUVA444P,
855 AV_PIX_FMT_YUVA422P,
856
857 AV_PIX_FMT_YUV420P12BE,
858 AV_PIX_FMT_YUV420P12LE,
859 AV_PIX_FMT_YUV420P14BE,
860 AV_PIX_FMT_YUV420P14LE,
861 AV_PIX_FMT_YUV422P12BE,
862 AV_PIX_FMT_YUV422P12LE,
863 AV_PIX_FMT_YUV422P14BE,
864 AV_PIX_FMT_YUV422P14LE,
865 AV_PIX_FMT_YUV444P12BE,
866 AV_PIX_FMT_YUV444P12LE,
867 AV_PIX_FMT_YUV444P14BE,
868 AV_PIX_FMT_YUV444P14LE,
869 AV_PIX_FMT_GBRP12BE,
870 AV_PIX_FMT_GBRP12LE,
871 AV_PIX_FMT_GBRP14BE,
872 AV_PIX_FMT_GBRP14LE,
873 AV_PIX_FMT_GBRAP,
874 AV_PIX_FMT_GBRAP16BE,
875 AV_PIX_FMT_GBRAP16LE,
876 AV_PIX_FMT_YUVJ411P,
877
878 AV_PIX_FMT_BAYER_BGGR8,
879 AV_PIX_FMT_BAYER_RGGB8,
880 AV_PIX_FMT_BAYER_GBRG8,
881 AV_PIX_FMT_BAYER_GRBG8,
882 AV_PIX_FMT_BAYER_BGGR16LE,
883 AV_PIX_FMT_BAYER_BGGR16BE,
884 AV_PIX_FMT_BAYER_RGGB16LE,
885 AV_PIX_FMT_BAYER_RGGB16BE,
886 AV_PIX_FMT_BAYER_GBRG16LE,
887 AV_PIX_FMT_BAYER_GBRG16BE,
888 AV_PIX_FMT_BAYER_GRBG16LE,
889 AV_PIX_FMT_BAYER_GRBG16BE,
890
891 AV_PIX_FMT_NB,
892
893 #define AVUTIL_OLD_PIX_FMTS_H
894
895 PIX_FMT_NONE = AV_PIX_FMT_NONE,
896 PIX_FMT_YUV420P,
897 PIX_FMT_YUYV422,
898 PIX_FMT_RGB24,
899 PIX_FMT_BGR24,
900 PIX_FMT_YUV422P,
901 PIX_FMT_YUV444P,
902 PIX_FMT_YUV410P,
903 PIX_FMT_YUV411P,
904 PIX_FMT_GRAY8,
905 PIX_FMT_MONOWHITE,
906 PIX_FMT_MONOBLACK,
907 PIX_FMT_PAL8,
908 PIX_FMT_YUVJ420P,
909 PIX_FMT_YUVJ422P,
910 PIX_FMT_YUVJ444P,
911 PIX_FMT_XVMC_MPEG2_MC,
912 PIX_FMT_XVMC_MPEG2_IDCT,
913 PIX_FMT_UYVY422,
914 PIX_FMT_UYYVYY411,
915 PIX_FMT_BGR8,
916 PIX_FMT_BGR4,
917 PIX_FMT_BGR4_BYTE,
918 PIX_FMT_RGB8,
919 PIX_FMT_RGB4,
920 PIX_FMT_RGB4_BYTE,
921 PIX_FMT_NV12,
922 PIX_FMT_NV21,
923
924 PIX_FMT_ARGB,
925 PIX_FMT_RGBA,
926 PIX_FMT_ABGR,
927 PIX_FMT_BGRA,
928
929 PIX_FMT_GRAY16BE,
930 PIX_FMT_GRAY16LE,
931 PIX_FMT_YUV440P,
932 PIX_FMT_YUVJ440P,
933 PIX_FMT_YUVA420P,
934 PIX_FMT_VDPAU_H264,
935 PIX_FMT_VDPAU_MPEG1,
936 PIX_FMT_VDPAU_MPEG2,
937 PIX_FMT_VDPAU_WMV3,
938 PIX_FMT_VDPAU_VC1,
939 PIX_FMT_RGB48BE,
940 PIX_FMT_RGB48LE,
941
942 PIX_FMT_RGB565BE,
943 PIX_FMT_RGB565LE,
944 PIX_FMT_RGB555BE,
945 PIX_FMT_RGB555LE,
946
947 PIX_FMT_BGR565BE,
948 PIX_FMT_BGR565LE,
949 PIX_FMT_BGR555BE,
950 PIX_FMT_BGR555LE,
951
952 PIX_FMT_VAAPI_MOCO,
953 PIX_FMT_VAAPI_IDCT,
954 PIX_FMT_VAAPI_VLD,
955
956 PIX_FMT_YUV420P16LE,
957 PIX_FMT_YUV420P16BE,
958 PIX_FMT_YUV422P16LE,
959 PIX_FMT_YUV422P16BE,
960 PIX_FMT_YUV444P16LE,
961 PIX_FMT_YUV444P16BE,
962 PIX_FMT_VDPAU_MPEG4,
963 PIX_FMT_DXVA2_VLD,
964
965 PIX_FMT_RGB444LE,
966 PIX_FMT_RGB444BE,
967 PIX_FMT_BGR444LE,
968 PIX_FMT_BGR444BE,
969 PIX_FMT_GRAY8A,
970 PIX_FMT_BGR48BE,
971 PIX_FMT_BGR48LE,
972
973 PIX_FMT_YUV420P9BE,
974 PIX_FMT_YUV420P9LE,
975 PIX_FMT_YUV420P10BE,
976 PIX_FMT_YUV420P10LE,
977 PIX_FMT_YUV422P10BE,
978 PIX_FMT_YUV422P10LE,
979 PIX_FMT_YUV444P9BE,
980 PIX_FMT_YUV444P9LE,
981 PIX_FMT_YUV444P10BE,
982 PIX_FMT_YUV444P10LE,
983 PIX_FMT_YUV422P9BE,
984 PIX_FMT_YUV422P9LE,
985 PIX_FMT_VDA_VLD,
986
987 PIX_FMT_GBRP,
988 PIX_FMT_GBRP9BE,
989 PIX_FMT_GBRP9LE,
990 PIX_FMT_GBRP10BE,
991 PIX_FMT_GBRP10LE,
992 PIX_FMT_GBRP16BE,
993 PIX_FMT_GBRP16LE,
994
995 PIX_FMT_RGBA64BE=0x123,
996 PIX_FMT_RGBA64LE,
997 PIX_FMT_BGRA64BE,
998 PIX_FMT_BGRA64LE,
999 PIX_FMT_0RGB=0x123+4,
1000 PIX_FMT_RGB0,
1001 PIX_FMT_0BGR,
1002 PIX_FMT_BGR0,
1003 PIX_FMT_YUVA444P,
1004 PIX_FMT_YUVA422P,
1005
1006 PIX_FMT_YUV420P12BE,
1007 PIX_FMT_YUV420P12LE,
1008 PIX_FMT_YUV420P14BE,
1009 PIX_FMT_YUV420P14LE,
1010 PIX_FMT_YUV422P12BE,
1011 PIX_FMT_YUV422P12LE,
1012 PIX_FMT_YUV422P14BE,
1013 PIX_FMT_YUV422P14LE,
1014 PIX_FMT_YUV444P12BE,
1015 PIX_FMT_YUV444P12LE,
1016 PIX_FMT_YUV444P14BE,
1017 PIX_FMT_YUV444P14LE,
1018 PIX_FMT_GBRP12BE,
1019 PIX_FMT_GBRP12LE,
1020 PIX_FMT_GBRP14BE,
1021 PIX_FMT_GBRP14LE,
1022
1023 PIX_FMT_NB,
1024 };
1025
1026 #define AV_PIX_FMT_Y400A AV_PIX_FMT_GRAY8A
1027 #define AV_PIX_FMT_GBR24P AV_PIX_FMT_GBRP
1028
1029 # define AV_PIX_FMT_NE(be, le) AV_PIX_FMT_##le
1030
1031 #define AV_PIX_FMT_RGB32 AV_PIX_FMT_NE(ARGB, BGRA)
1032 #define AV_PIX_FMT_RGB32_1 AV_PIX_FMT_NE(RGBA, ABGR)
1033 #define AV_PIX_FMT_BGR32 AV_PIX_FMT_NE(ABGR, RGBA)
1034 #define AV_PIX_FMT_BGR32_1 AV_PIX_FMT_NE(BGRA, ARGB)
1035 #define AV_PIX_FMT_0RGB32 AV_PIX_FMT_NE(0RGB, BGR0)
1036 #define AV_PIX_FMT_0BGR32 AV_PIX_FMT_NE(0BGR, RGB0)
1037
1038 #define AV_PIX_FMT_GRAY16 AV_PIX_FMT_NE(GRAY16BE, GRAY16LE)
1039 #define AV_PIX_FMT_RGB48 AV_PIX_FMT_NE(RGB48BE, RGB48LE)
1040 #define AV_PIX_FMT_RGB565 AV_PIX_FMT_NE(RGB565BE, RGB565LE)
1041 #define AV_PIX_FMT_RGB555 AV_PIX_FMT_NE(RGB555BE, RGB555LE)
1042 #define AV_PIX_FMT_RGB444 AV_PIX_FMT_NE(RGB444BE, RGB444LE)
1043 #define AV_PIX_FMT_RGBA64 AV_PIX_FMT_NE(RGBA64BE, RGBA64LE)
1044 #define AV_PIX_FMT_BGR48 AV_PIX_FMT_NE(BGR48BE, BGR48LE)
1045 #define AV_PIX_FMT_BGR565 AV_PIX_FMT_NE(BGR565BE, BGR565LE)
1046 #define AV_PIX_FMT_BGR555 AV_PIX_FMT_NE(BGR555BE, BGR555LE)
1047 #define AV_PIX_FMT_BGR444 AV_PIX_FMT_NE(BGR444BE, BGR444LE)
1048 #define AV_PIX_FMT_BGRA64 AV_PIX_FMT_NE(BGRA64BE, BGRA64LE)
1049
1050 #define AV_PIX_FMT_YUV420P9 AV_PIX_FMT_NE(YUV420P9BE , YUV420P9LE)
1051 #define AV_PIX_FMT_YUV422P9 AV_PIX_FMT_NE(YUV422P9BE , YUV422P9LE)
1052 #define AV_PIX_FMT_YUV444P9 AV_PIX_FMT_NE(YUV444P9BE , YUV444P9LE)
1053 #define AV_PIX_FMT_YUV420P10 AV_PIX_FMT_NE(YUV420P10BE, YUV420P10LE)
1054 #define AV_PIX_FMT_YUV422P10 AV_PIX_FMT_NE(YUV422P10BE, YUV422P10LE)
1055 #define AV_PIX_FMT_YUV444P10 AV_PIX_FMT_NE(YUV444P10BE, YUV444P10LE)
1056 #define AV_PIX_FMT_YUV420P12 AV_PIX_FMT_NE(YUV420P12BE, YUV420P12LE)
1057 #define AV_PIX_FMT_YUV422P12 AV_PIX_FMT_NE(YUV422P12BE, YUV422P12LE)
1058 #define AV_PIX_FMT_YUV444P12 AV_PIX_FMT_NE(YUV444P12BE, YUV444P12LE)
1059 #define AV_PIX_FMT_YUV420P14 AV_PIX_FMT_NE(YUV420P14BE, YUV420P14LE)
1060 #define AV_PIX_FMT_YUV422P14 AV_PIX_FMT_NE(YUV422P14BE, YUV422P14LE)
1061 #define AV_PIX_FMT_YUV444P14 AV_PIX_FMT_NE(YUV444P14BE, YUV444P14LE)
1062 #define AV_PIX_FMT_YUV420P16 AV_PIX_FMT_NE(YUV420P16BE, YUV420P16LE)
1063 #define AV_PIX_FMT_YUV422P16 AV_PIX_FMT_NE(YUV422P16BE, YUV422P16LE)
1064 #define AV_PIX_FMT_YUV444P16 AV_PIX_FMT_NE(YUV444P16BE, YUV444P16LE)
1065
1066 #define AV_PIX_FMT_GBRP9 AV_PIX_FMT_NE(GBRP9BE , GBRP9LE)
1067 #define AV_PIX_FMT_GBRP10 AV_PIX_FMT_NE(GBRP10BE, GBRP10LE)
1068 #define AV_PIX_FMT_GBRP12 AV_PIX_FMT_NE(GBRP12BE, GBRP12LE)
1069 #define AV_PIX_FMT_GBRP14 AV_PIX_FMT_NE(GBRP14BE, GBRP14LE)
1070 #define AV_PIX_FMT_GBRP16 AV_PIX_FMT_NE(GBRP16BE, GBRP16LE)
1071 #define AV_PIX_FMT_GBRAP16 AV_PIX_FMT_NE(GBRAP16BE, GBRAP16LE)
1072
1073 #define AV_PIX_FMT_BAYER_BGGR16 AV_PIX_FMT_NE(BAYER_BGGR16BE, BAYER_BGGR16LE)
1074 #define AV_PIX_FMT_BAYER_RGGB16 AV_PIX_FMT_NE(BAYER_RGGB16BE, BAYER_RGGB16LE)
1075 #define AV_PIX_FMT_BAYER_GBRG16 AV_PIX_FMT_NE(BAYER_GBRG16BE, BAYER_GBRG16LE)
1076 #define AV_PIX_FMT_BAYER_GRBG16 AV_PIX_FMT_NE(BAYER_GRBG16BE, BAYER_GRBG16LE)
1077
1078 #define AV_PIX_FMT_YUVA420P9 AV_PIX_FMT_NE(YUVA420P9BE , YUVA420P9LE)
1079 #define AV_PIX_FMT_YUVA422P9 AV_PIX_FMT_NE(YUVA422P9BE , YUVA422P9LE)
1080 #define AV_PIX_FMT_YUVA444P9 AV_PIX_FMT_NE(YUVA444P9BE , YUVA444P9LE)
1081 #define AV_PIX_FMT_YUVA420P10 AV_PIX_FMT_NE(YUVA420P10BE, YUVA420P10LE)
1082 #define AV_PIX_FMT_YUVA422P10 AV_PIX_FMT_NE(YUVA422P10BE, YUVA422P10LE)
1083 #define AV_PIX_FMT_YUVA444P10 AV_PIX_FMT_NE(YUVA444P10BE, YUVA444P10LE)
1084 #define AV_PIX_FMT_YUVA420P16 AV_PIX_FMT_NE(YUVA420P16BE, YUVA420P16LE)
1085 #define AV_PIX_FMT_YUVA422P16 AV_PIX_FMT_NE(YUVA422P16BE, YUVA422P16LE)
1086 #define AV_PIX_FMT_YUVA444P16 AV_PIX_FMT_NE(YUVA444P16BE, YUVA444P16LE)
1087
1088 #define AV_PIX_FMT_XYZ12 AV_PIX_FMT_NE(XYZ12BE, XYZ12LE)
1089 #define AV_PIX_FMT_NV20 AV_PIX_FMT_NE(NV20BE, NV20LE)
1090
1091 #define PixelFormat AVPixelFormat
1092
1093 #define PIX_FMT_Y400A AV_PIX_FMT_Y400A
1094 #define PIX_FMT_GBR24P AV_PIX_FMT_GBR24P
1095
1096 #define PIX_FMT_NE(be, le) AV_PIX_FMT_NE(be, le)
1097
1098 #define PIX_FMT_RGB32 AV_PIX_FMT_RGB32
1099 #define PIX_FMT_RGB32_1 AV_PIX_FMT_RGB32_1
1100 #define PIX_FMT_BGR32 AV_PIX_FMT_BGR32
1101 #define PIX_FMT_BGR32_1 AV_PIX_FMT_BGR32_1
1102 #define PIX_FMT_0RGB32 AV_PIX_FMT_0RGB32
1103 #define PIX_FMT_0BGR32 AV_PIX_FMT_0BGR32
1104
1105 #define PIX_FMT_GRAY16 AV_PIX_FMT_GRAY16
1106 #define PIX_FMT_RGB48 AV_PIX_FMT_RGB48
1107 #define PIX_FMT_RGB565 AV_PIX_FMT_RGB565
1108 #define PIX_FMT_RGB555 AV_PIX_FMT_RGB555
1109 #define PIX_FMT_RGB444 AV_PIX_FMT_RGB444
1110 #define PIX_FMT_BGR48 AV_PIX_FMT_BGR48
1111 #define PIX_FMT_BGR565 AV_PIX_FMT_BGR565
1112 #define PIX_FMT_BGR555 AV_PIX_FMT_BGR555
1113 #define PIX_FMT_BGR444 AV_PIX_FMT_BGR444
1114
1115 #define PIX_FMT_YUV420P9 AV_PIX_FMT_YUV420P9
1116 #define PIX_FMT_YUV422P9 AV_PIX_FMT_YUV422P9
1117 #define PIX_FMT_YUV444P9 AV_PIX_FMT_YUV444P9
1118 #define PIX_FMT_YUV420P10 AV_PIX_FMT_YUV420P10
1119 #define PIX_FMT_YUV422P10 AV_PIX_FMT_YUV422P10
1120 #define PIX_FMT_YUV444P10 AV_PIX_FMT_YUV444P10
1121 #define PIX_FMT_YUV420P12 AV_PIX_FMT_YUV420P12
1122 #define PIX_FMT_YUV422P12 AV_PIX_FMT_YUV422P12
1123 #define PIX_FMT_YUV444P12 AV_PIX_FMT_YUV444P12
1124 #define PIX_FMT_YUV420P14 AV_PIX_FMT_YUV420P14
1125 #define PIX_FMT_YUV422P14 AV_PIX_FMT_YUV422P14
1126 #define PIX_FMT_YUV444P14 AV_PIX_FMT_YUV444P14
1127 #define PIX_FMT_YUV420P16 AV_PIX_FMT_YUV420P16
1128 #define PIX_FMT_YUV422P16 AV_PIX_FMT_YUV422P16
1129 #define PIX_FMT_YUV444P16 AV_PIX_FMT_YUV444P16
1130
1131 #define PIX_FMT_RGBA64 AV_PIX_FMT_RGBA64
1132 #define PIX_FMT_BGRA64 AV_PIX_FMT_BGRA64
1133 #define PIX_FMT_GBRP9 AV_PIX_FMT_GBRP9
1134 #define PIX_FMT_GBRP10 AV_PIX_FMT_GBRP10
1135 #define PIX_FMT_GBRP12 AV_PIX_FMT_GBRP12
1136 #define PIX_FMT_GBRP14 AV_PIX_FMT_GBRP14
1137 #define PIX_FMT_GBRP16 AV_PIX_FMT_GBRP16
1138
1139 enum AVColorPrimaries {
1140 AVCOL_PRI_BT709 = 1,
1141 AVCOL_PRI_UNSPECIFIED = 2,
1142 AVCOL_PRI_RESERVED = 3,
1143 AVCOL_PRI_BT470M = 4,
1144 AVCOL_PRI_BT470BG = 5,
1145 AVCOL_PRI_SMPTE170M = 6,
1146 AVCOL_PRI_SMPTE240M = 7,
1147 AVCOL_PRI_FILM = 8,
1148 AVCOL_PRI_BT2020 = 9,
1149 AVCOL_PRI_NB,
1150 };
1151
1152 enum AVColorTransferCharacteristic {
1153 AVCOL_TRC_BT709 = 1,
1154 AVCOL_TRC_UNSPECIFIED = 2,
1155 AVCOL_TRC_RESERVED = 3,
1156 AVCOL_TRC_GAMMA22 = 4,
1157 AVCOL_TRC_GAMMA28 = 5,
1158 AVCOL_TRC_SMPTE170M = 6,
1159 AVCOL_TRC_SMPTE240M = 7,
1160 AVCOL_TRC_LINEAR = 8,
1161 AVCOL_TRC_LOG = 9,
1162 AVCOL_TRC_LOG_SQRT = 10,
1163 AVCOL_TRC_IEC61966_2_4 = 11,
1164 AVCOL_TRC_BT1361_ECG = 12,
1165 AVCOL_TRC_IEC61966_2_1 = 13,
1166 AVCOL_TRC_BT2020_10 = 14,
1167 AVCOL_TRC_BT2020_12 = 15,
1168 AVCOL_TRC_NB,
1169 };
1170
1171 enum AVColorSpace {
1172 AVCOL_SPC_RGB = 0,
1173 AVCOL_SPC_BT709 = 1,
1174 AVCOL_SPC_UNSPECIFIED = 2,
1175 AVCOL_SPC_RESERVED = 3,
1176 AVCOL_SPC_FCC = 4,
1177 AVCOL_SPC_BT470BG = 5,
1178 AVCOL_SPC_SMPTE170M = 6,
1179 AVCOL_SPC_SMPTE240M = 7,
1180 AVCOL_SPC_YCOCG = 8,
1181 AVCOL_SPC_BT2020_NCL = 9,
1182 AVCOL_SPC_BT2020_CL = 10,
1183 AVCOL_SPC_NB,
1184 };
1185 #define AVCOL_SPC_YCGCO AVCOL_SPC_YCOCG
1186
1187 enum AVColorRange {
1188 AVCOL_RANGE_UNSPECIFIED = 0,
1189 AVCOL_RANGE_MPEG = 1,
1190 AVCOL_RANGE_JPEG = 2,
1191 AVCOL_RANGE_NB,
1192 };
1193
1194 enum AVChromaLocation {
1195 AVCHROMA_LOC_UNSPECIFIED = 0,
1196 AVCHROMA_LOC_LEFT = 1,
1197 AVCHROMA_LOC_CENTER = 2,
1198 AVCHROMA_LOC_TOPLEFT = 3,
1199 AVCHROMA_LOC_TOP = 4,
1200 AVCHROMA_LOC_BOTTOMLEFT = 5,
1201 AVCHROMA_LOC_BOTTOM = 6,
1202 AVCHROMA_LOC_NB,
1203 };
1204
av_x_if_null(const void * p,const void * x)1205 static inline void *av_x_if_null(const void *p, const void *x)
1206 {
1207 return (void *)(intptr_t)(p ? p : x);
1208 }
1209
1210 unsigned av_int_list_length_for_size(unsigned elsize,
1211 const void *list, uint64_t term) av_pure;
1212
1213 #define av_int_list_length(list, term) \
1214 av_int_list_length_for_size(sizeof(*(list)), list, term)
1215
1216 FILE *av_fopen_utf8(const char *path, const char *mode);
1217
1218 AVRational av_get_time_base_q(void);
1219
1220 enum AVSampleFormat {
1221 AV_SAMPLE_FMT_NONE = -1,
1222 AV_SAMPLE_FMT_U8,
1223 AV_SAMPLE_FMT_S16,
1224 AV_SAMPLE_FMT_S32,
1225 AV_SAMPLE_FMT_FLT,
1226 AV_SAMPLE_FMT_DBL,
1227
1228 AV_SAMPLE_FMT_U8P,
1229 AV_SAMPLE_FMT_S16P,
1230 AV_SAMPLE_FMT_S32P,
1231 AV_SAMPLE_FMT_FLTP,
1232 AV_SAMPLE_FMT_DBLP,
1233
1234 AV_SAMPLE_FMT_NB
1235 };
1236
1237 const char *av_get_sample_fmt_name(enum AVSampleFormat sample_fmt);
1238
1239 enum AVSampleFormat av_get_sample_fmt(const char *name);
1240
1241 enum AVSampleFormat av_get_alt_sample_fmt(enum AVSampleFormat sample_fmt, int planar);
1242
1243 enum AVSampleFormat av_get_packed_sample_fmt(enum AVSampleFormat sample_fmt);
1244
1245 enum AVSampleFormat av_get_planar_sample_fmt(enum AVSampleFormat sample_fmt);
1246
1247 char *av_get_sample_fmt_string(char *buf, int buf_size, enum AVSampleFormat sample_fmt);
1248
1249 attribute_deprecated
1250 int av_get_bits_per_sample_fmt(enum AVSampleFormat sample_fmt);
1251
1252 int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt);
1253
1254 int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt);
1255
1256 int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples,
1257 enum AVSampleFormat sample_fmt, int align);
1258
1259 int av_samples_fill_arrays(uint8_t **audio_data, int *linesize,
1260 const uint8_t *buf,
1261 int nb_channels, int nb_samples,
1262 enum AVSampleFormat sample_fmt, int align);
1263
1264 int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels,
1265 int nb_samples, enum AVSampleFormat sample_fmt, int align);
1266
1267 int av_samples_alloc_array_and_samples(uint8_t ***audio_data, int *linesize, int nb_channels,
1268 int nb_samples, enum AVSampleFormat sample_fmt, int align);
1269
1270 int av_samples_copy(uint8_t **dst, uint8_t * const *src, int dst_offset,
1271 int src_offset, int nb_samples, int nb_channels,
1272 enum AVSampleFormat sample_fmt);
1273
1274 int av_samples_set_silence(uint8_t **audio_data, int offset, int nb_samples,
1275 int nb_channels, enum AVSampleFormat sample_fmt);
1276
1277 #define AVUTIL_BUFFER_H
1278
1279 typedef struct AVBuffer AVBuffer;
1280
1281 typedef struct AVBufferRef {
1282 AVBuffer *buffer;
1283
1284 uint8_t *data;
1285
1286 int size;
1287 } AVBufferRef;
1288
1289 AVBufferRef *av_buffer_alloc(int size);
1290
1291 AVBufferRef *av_buffer_allocz(int size);
1292
1293 #define AV_BUFFER_FLAG_READONLY (1 << 0)
1294
1295 AVBufferRef *av_buffer_create(uint8_t *data, int size,
1296 void (*free)(void *opaque, uint8_t *data),
1297 void *opaque, int flags);
1298
1299 void av_buffer_default_free(void *opaque, uint8_t *data);
1300
1301 AVBufferRef *av_buffer_ref(AVBufferRef *buf);
1302
1303 void av_buffer_unref(AVBufferRef **buf);
1304
1305 int av_buffer_is_writable(const AVBufferRef *buf);
1306
1307 void *av_buffer_get_opaque(const AVBufferRef *buf);
1308
1309 int av_buffer_get_ref_count(const AVBufferRef *buf);
1310
1311 int av_buffer_make_writable(AVBufferRef **buf);
1312
1313 int av_buffer_realloc(AVBufferRef **buf, int size);
1314
1315 typedef struct AVBufferPool AVBufferPool;
1316
1317 AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size));
1318
1319 void av_buffer_pool_uninit(AVBufferPool **pool);
1320
1321 AVBufferRef *av_buffer_pool_get(AVBufferPool *pool);
1322
1323 #define AVUTIL_CPU_H
1324
1325 #define AV_CPU_FLAG_FORCE 0x80000000
1326
1327 #define AV_CPU_FLAG_MMX 0x0001
1328 #define AV_CPU_FLAG_MMXEXT 0x0002
1329 #define AV_CPU_FLAG_MMX2 0x0002
1330 #define AV_CPU_FLAG_3DNOW 0x0004
1331 #define AV_CPU_FLAG_SSE 0x0008
1332 #define AV_CPU_FLAG_SSE2 0x0010
1333 #define AV_CPU_FLAG_SSE2SLOW 0x40000000
1334
1335 #define AV_CPU_FLAG_3DNOWEXT 0x0020
1336 #define AV_CPU_FLAG_SSE3 0x0040
1337 #define AV_CPU_FLAG_SSE3SLOW 0x20000000
1338
1339 #define AV_CPU_FLAG_SSSE3 0x0080
1340 #define AV_CPU_FLAG_ATOM 0x10000000
1341 #define AV_CPU_FLAG_SSE4 0x0100
1342 #define AV_CPU_FLAG_SSE42 0x0200
1343 #define AV_CPU_FLAG_AVX 0x4000
1344 #define AV_CPU_FLAG_XOP 0x0400
1345 #define AV_CPU_FLAG_FMA4 0x0800
1346
1347 #define AV_CPU_FLAG_CMOV 0x1001000
1348
1349 #define AV_CPU_FLAG_AVX2 0x8000
1350 #define AV_CPU_FLAG_FMA3 0x10000
1351 #define AV_CPU_FLAG_BMI1 0x20000
1352 #define AV_CPU_FLAG_BMI2 0x40000
1353
1354 #define AV_CPU_FLAG_ALTIVEC 0x0001
1355
1356 #define AV_CPU_FLAG_ARMV5TE (1 << 0)
1357 #define AV_CPU_FLAG_ARMV6 (1 << 1)
1358 #define AV_CPU_FLAG_ARMV6T2 (1 << 2)
1359 #define AV_CPU_FLAG_VFP (1 << 3)
1360 #define AV_CPU_FLAG_VFPV3 (1 << 4)
1361 #define AV_CPU_FLAG_NEON (1 << 5)
1362 #define AV_CPU_FLAG_ARMV8 (1 << 6)
1363
1364 int av_get_cpu_flags(void);
1365
1366 void av_force_cpu_flags(int flags);
1367
1368 attribute_deprecated void av_set_cpu_flags_mask(int mask);
1369
1370 attribute_deprecated
1371 int av_parse_cpu_flags(const char *s);
1372
1373 int av_parse_cpu_caps(unsigned *flags, const char *s);
1374
1375 int av_cpu_count(void);
1376
1377 #define AVUTIL_CHANNEL_LAYOUT_H
1378
1379 #define AV_CH_FRONT_LEFT 0x00000001
1380 #define AV_CH_FRONT_RIGHT 0x00000002
1381 #define AV_CH_FRONT_CENTER 0x00000004
1382 #define AV_CH_LOW_FREQUENCY 0x00000008
1383 #define AV_CH_BACK_LEFT 0x00000010
1384 #define AV_CH_BACK_RIGHT 0x00000020
1385 #define AV_CH_FRONT_LEFT_OF_CENTER 0x00000040
1386 #define AV_CH_FRONT_RIGHT_OF_CENTER 0x00000080
1387 #define AV_CH_BACK_CENTER 0x00000100
1388 #define AV_CH_SIDE_LEFT 0x00000200
1389 #define AV_CH_SIDE_RIGHT 0x00000400
1390 #define AV_CH_TOP_CENTER 0x00000800
1391 #define AV_CH_TOP_FRONT_LEFT 0x00001000
1392 #define AV_CH_TOP_FRONT_CENTER 0x00002000
1393 #define AV_CH_TOP_FRONT_RIGHT 0x00004000
1394 #define AV_CH_TOP_BACK_LEFT 0x00008000
1395 #define AV_CH_TOP_BACK_CENTER 0x00010000
1396 #define AV_CH_TOP_BACK_RIGHT 0x00020000
1397 #define AV_CH_STEREO_LEFT 0x20000000
1398 #define AV_CH_STEREO_RIGHT 0x40000000
1399 #define AV_CH_WIDE_LEFT 0x0000000080000000ULL
1400 #define AV_CH_WIDE_RIGHT 0x0000000100000000ULL
1401 #define AV_CH_SURROUND_DIRECT_LEFT 0x0000000200000000ULL
1402 #define AV_CH_SURROUND_DIRECT_RIGHT 0x0000000400000000ULL
1403 #define AV_CH_LOW_FREQUENCY_2 0x0000000800000000ULL
1404
1405 #define AV_CH_LAYOUT_NATIVE 0x8000000000000000ULL
1406
1407 #define AV_CH_LAYOUT_MONO (AV_CH_FRONT_CENTER)
1408 #define AV_CH_LAYOUT_STEREO (AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT)
1409 #define AV_CH_LAYOUT_2POINT1 (AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY)
1410 #define AV_CH_LAYOUT_2_1 (AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER)
1411 #define AV_CH_LAYOUT_SURROUND (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER)
1412 #define AV_CH_LAYOUT_3POINT1 (AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY)
1413 #define AV_CH_LAYOUT_4POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_CENTER)
1414 #define AV_CH_LAYOUT_4POINT1 (AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY)
1415 #define AV_CH_LAYOUT_2_2 (AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
1416 #define AV_CH_LAYOUT_QUAD (AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
1417 #define AV_CH_LAYOUT_5POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
1418 #define AV_CH_LAYOUT_5POINT1 (AV_CH_LAYOUT_5POINT0|AV_CH_LOW_FREQUENCY)
1419 #define AV_CH_LAYOUT_5POINT0_BACK (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
1420 #define AV_CH_LAYOUT_5POINT1_BACK (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_LOW_FREQUENCY)
1421 #define AV_CH_LAYOUT_6POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_CENTER)
1422 #define AV_CH_LAYOUT_6POINT0_FRONT (AV_CH_LAYOUT_2_2|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
1423 #define AV_CH_LAYOUT_HEXAGONAL (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_BACK_CENTER)
1424 #define AV_CH_LAYOUT_6POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER)
1425 #define AV_CH_LAYOUT_6POINT1_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER)
1426 #define AV_CH_LAYOUT_6POINT1_FRONT (AV_CH_LAYOUT_6POINT0_FRONT|AV_CH_LOW_FREQUENCY)
1427 #define AV_CH_LAYOUT_7POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
1428 #define AV_CH_LAYOUT_7POINT0_FRONT (AV_CH_LAYOUT_5POINT0|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
1429 #define AV_CH_LAYOUT_7POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
1430 #define AV_CH_LAYOUT_7POINT1_WIDE (AV_CH_LAYOUT_5POINT1|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
1431 #define AV_CH_LAYOUT_7POINT1_WIDE_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
1432 #define AV_CH_LAYOUT_OCTAGONAL (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT)
1433 #define AV_CH_LAYOUT_STEREO_DOWNMIX (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT)
1434
1435 enum AVMatrixEncoding {
1436 AV_MATRIX_ENCODING_NONE,
1437 AV_MATRIX_ENCODING_DOLBY,
1438 AV_MATRIX_ENCODING_DPLII,
1439 AV_MATRIX_ENCODING_DPLIIX,
1440 AV_MATRIX_ENCODING_DPLIIZ,
1441 AV_MATRIX_ENCODING_DOLBYEX,
1442 AV_MATRIX_ENCODING_DOLBYHEADPHONE,
1443 AV_MATRIX_ENCODING_NB
1444 };
1445
1446 uint64_t av_get_channel_layout(const char *name);
1447
1448 void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout);
1449
1450 struct AVBPrint;
1451
1452 void av_bprint_channel_layout(struct AVBPrint *bp, int nb_channels, uint64_t channel_layout);
1453
1454 int av_get_channel_layout_nb_channels(uint64_t channel_layout);
1455
1456 int64_t av_get_default_channel_layout(int nb_channels);
1457
1458 int av_get_channel_layout_channel_index(uint64_t channel_layout,
1459 uint64_t channel);
1460
1461 uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index);
1462
1463 const char *av_get_channel_name(uint64_t channel);
1464
1465 const char *av_get_channel_description(uint64_t channel);
1466
1467 int av_get_standard_channel_layout(unsigned index, uint64_t *layout,
1468 const char **name);
1469
1470 #define AVUTIL_DICT_H
1471
1472 #define AV_DICT_MATCH_CASE 1
1473 #define AV_DICT_IGNORE_SUFFIX 2
1474
1475 #define AV_DICT_DONT_STRDUP_KEY 4
1476
1477 #define AV_DICT_DONT_STRDUP_VAL 8
1478
1479 #define AV_DICT_DONT_OVERWRITE 16
1480 #define AV_DICT_APPEND 32
1481
1482 typedef struct AVDictionaryEntry {
1483 char *key;
1484 char *value;
1485 } AVDictionaryEntry;
1486
1487 typedef struct AVDictionary AVDictionary;
1488
1489 AVDictionaryEntry *av_dict_get(FF_CONST_AVUTIL53 AVDictionary *m, const char *key,
1490 const AVDictionaryEntry *prev, int flags);
1491
1492 int av_dict_count(const AVDictionary *m);
1493
1494 int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags);
1495
1496 int av_dict_parse_string(AVDictionary **pm, const char *str,
1497 const char *key_val_sep, const char *pairs_sep,
1498 int flags);
1499
1500 void av_dict_copy(AVDictionary **dst, FF_CONST_AVUTIL53 AVDictionary *src, int flags);
1501
1502 void av_dict_free(AVDictionary **m);
1503
1504 #define AVUTIL_FRAME_H
1505
1506 enum AVFrameSideDataType {
1507
1508 AV_FRAME_DATA_PANSCAN,
1509
1510 AV_FRAME_DATA_A53_CC,
1511
1512 AV_FRAME_DATA_STEREO3D,
1513
1514 AV_FRAME_DATA_MATRIXENCODING,
1515
1516 AV_FRAME_DATA_DOWNMIX_INFO,
1517
1518 AV_FRAME_DATA_REPLAYGAIN,
1519
1520 AV_FRAME_DATA_DISPLAYMATRIX,
1521 };
1522
1523 typedef struct AVFrameSideData {
1524 enum AVFrameSideDataType type;
1525 uint8_t *data;
1526 int size;
1527 AVDictionary *metadata;
1528 } AVFrameSideData;
1529
1530 typedef struct AVFrame {
1531 #define AV_NUM_DATA_POINTERS 8
1532
1533 uint8_t *data[AV_NUM_DATA_POINTERS];
1534
1535 int linesize[AV_NUM_DATA_POINTERS];
1536
1537 uint8_t **extended_data;
1538
1539 int width, height;
1540
1541 int nb_samples;
1542
1543 int format;
1544
1545 int key_frame;
1546
1547 enum AVPictureType pict_type;
1548
1549 attribute_deprecated
1550 uint8_t *base[AV_NUM_DATA_POINTERS];
1551
1552 AVRational sample_aspect_ratio;
1553
1554 int64_t pts;
1555
1556 int64_t pkt_pts;
1557
1558 int64_t pkt_dts;
1559
1560 int coded_picture_number;
1561
1562 int display_picture_number;
1563
1564 int quality;
1565
1566 attribute_deprecated
1567 int reference;
1568
1569 attribute_deprecated
1570 int8_t *qscale_table;
1571
1572 attribute_deprecated
1573 int qstride;
1574
1575 attribute_deprecated
1576 int qscale_type;
1577
1578 attribute_deprecated
1579 uint8_t *mbskip_table;
1580
1581 int16_t (*motion_val[2])[2];
1582
1583 attribute_deprecated
1584 uint32_t *mb_type;
1585
1586 attribute_deprecated
1587 short *dct_coeff;
1588
1589 attribute_deprecated
1590 int8_t *ref_index[2];
1591
1592 void *opaque;
1593
1594 uint64_t error[AV_NUM_DATA_POINTERS];
1595
1596 attribute_deprecated
1597 int type;
1598
1599 int repeat_pict;
1600
1601 int interlaced_frame;
1602
1603 int top_field_first;
1604
1605 int palette_has_changed;
1606
1607 attribute_deprecated
1608 int buffer_hints;
1609
1610 attribute_deprecated
1611 struct AVPanScan *pan_scan;
1612
1613 int64_t reordered_opaque;
1614
1615 attribute_deprecated void *hwaccel_picture_private;
1616
1617 attribute_deprecated
1618 struct AVCodecContext *owner;
1619 attribute_deprecated
1620 void *thread_opaque;
1621
1622 uint8_t motion_subsample_log2;
1623
1624 int sample_rate;
1625
1626 uint64_t channel_layout;
1627
1628 AVBufferRef *buf[AV_NUM_DATA_POINTERS];
1629
1630 AVBufferRef **extended_buf;
1631
1632 int nb_extended_buf;
1633
1634 AVFrameSideData **side_data;
1635 int nb_side_data;
1636
1637 #define AV_FRAME_FLAG_CORRUPT (1 << 0)
1638
1639 int flags;
1640
1641 enum AVColorRange color_range;
1642
1643 enum AVColorPrimaries color_primaries;
1644
1645 enum AVColorTransferCharacteristic color_trc;
1646
1647 enum AVColorSpace colorspace;
1648
1649 enum AVChromaLocation chroma_location;
1650
1651 int64_t best_effort_timestamp;
1652
1653 int64_t pkt_pos;
1654
1655 int64_t pkt_duration;
1656
1657 AVDictionary *metadata;
1658
1659 int decode_error_flags;
1660 #define FF_DECODE_ERROR_INVALID_BITSTREAM 1
1661 #define FF_DECODE_ERROR_MISSING_REFERENCE 2
1662
1663 int channels;
1664
1665 int pkt_size;
1666
1667 AVBufferRef *qp_table_buf;
1668 } AVFrame;
1669
1670 int64_t av_frame_get_best_effort_timestamp(const AVFrame *frame);
1671 void av_frame_set_best_effort_timestamp(AVFrame *frame, int64_t val);
1672 int64_t av_frame_get_pkt_duration (const AVFrame *frame);
1673 void av_frame_set_pkt_duration (AVFrame *frame, int64_t val);
1674 int64_t av_frame_get_pkt_pos (const AVFrame *frame);
1675 void av_frame_set_pkt_pos (AVFrame *frame, int64_t val);
1676 int64_t av_frame_get_channel_layout (const AVFrame *frame);
1677 void av_frame_set_channel_layout (AVFrame *frame, int64_t val);
1678 int av_frame_get_channels (const AVFrame *frame);
1679 void av_frame_set_channels (AVFrame *frame, int val);
1680 int av_frame_get_sample_rate (const AVFrame *frame);
1681 void av_frame_set_sample_rate (AVFrame *frame, int val);
1682 AVDictionary *av_frame_get_metadata (const AVFrame *frame);
1683 void av_frame_set_metadata (AVFrame *frame, AVDictionary *val);
1684 int av_frame_get_decode_error_flags (const AVFrame *frame);
1685 void av_frame_set_decode_error_flags (AVFrame *frame, int val);
1686 int av_frame_get_pkt_size(const AVFrame *frame);
1687 void av_frame_set_pkt_size(AVFrame *frame, int val);
1688 AVDictionary **avpriv_frame_get_metadatap(AVFrame *frame);
1689 int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type);
1690 int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int type);
1691 enum AVColorSpace av_frame_get_colorspace(const AVFrame *frame);
1692 void av_frame_set_colorspace(AVFrame *frame, enum AVColorSpace val);
1693 enum AVColorRange av_frame_get_color_range(const AVFrame *frame);
1694 void av_frame_set_color_range(AVFrame *frame, enum AVColorRange val);
1695
1696 const char *av_get_colorspace_name(enum AVColorSpace val);
1697
1698 AVFrame *av_frame_alloc(void);
1699
1700 void av_frame_free(AVFrame **frame);
1701
1702 int av_frame_ref(AVFrame *dst, const AVFrame *src);
1703
1704 AVFrame *av_frame_clone(const AVFrame *src);
1705
1706 void av_frame_unref(AVFrame *frame);
1707
1708 void av_frame_move_ref(AVFrame *dst, AVFrame *src);
1709
1710 int av_frame_get_buffer(AVFrame *frame, int align);
1711
1712 int av_frame_is_writable(AVFrame *frame);
1713
1714 int av_frame_make_writable(AVFrame *frame);
1715
1716 int av_frame_copy(AVFrame *dst, const AVFrame *src);
1717
1718 int av_frame_copy_props(AVFrame *dst, const AVFrame *src);
1719
1720 AVBufferRef *av_frame_get_plane_buffer(AVFrame *frame, int plane);
1721
1722 AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
1723 enum AVFrameSideDataType type,
1724 int size);
1725
1726 AVFrameSideData *av_frame_get_side_data(const AVFrame *frame,
1727 enum AVFrameSideDataType type);
1728
1729 void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type);
1730
1731 #define AVCODEC_VERSION_H
1732
1733 #define LIBAVCODEC_VERSION_MAJOR 55
1734 #define LIBAVCODEC_VERSION_MINOR 69
1735 #define LIBAVCODEC_VERSION_MICRO 100
1736
1737 #define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
1738 LIBAVCODEC_VERSION_MINOR, \
1739 LIBAVCODEC_VERSION_MICRO)
1740 #define LIBAVCODEC_VERSION AV_VERSION(LIBAVCODEC_VERSION_MAJOR, \
1741 LIBAVCODEC_VERSION_MINOR, \
1742 LIBAVCODEC_VERSION_MICRO)
1743 #define LIBAVCODEC_BUILD LIBAVCODEC_VERSION_INT
1744
1745 #define LIBAVCODEC_IDENT "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION)
1746
1747 #define FF_API_REQUEST_CHANNELS (LIBAVCODEC_VERSION_MAJOR < 56)
1748 #define FF_API_OLD_DECODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 56)
1749 #define FF_API_OLD_ENCODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 56)
1750 #define FF_API_OLD_ENCODE_VIDEO (LIBAVCODEC_VERSION_MAJOR < 56)
1751 #define FF_API_CODEC_ID (LIBAVCODEC_VERSION_MAJOR < 56)
1752 #define FF_API_AUDIO_CONVERT (LIBAVCODEC_VERSION_MAJOR < 56)
1753 #define FF_API_AVCODEC_RESAMPLE FF_API_AUDIO_CONVERT
1754 #define FF_API_DEINTERLACE (LIBAVCODEC_VERSION_MAJOR < 56)
1755 #define FF_API_DESTRUCT_PACKET (LIBAVCODEC_VERSION_MAJOR < 56)
1756 #define FF_API_GET_BUFFER (LIBAVCODEC_VERSION_MAJOR < 56)
1757 #define FF_API_MISSING_SAMPLE (LIBAVCODEC_VERSION_MAJOR < 56)
1758 #define FF_API_LOWRES (LIBAVCODEC_VERSION_MAJOR < 56)
1759 #define FF_API_CAP_VDPAU (LIBAVCODEC_VERSION_MAJOR < 56)
1760 #define FF_API_BUFS_VDPAU (LIBAVCODEC_VERSION_MAJOR < 56)
1761 #define FF_API_VOXWARE (LIBAVCODEC_VERSION_MAJOR < 56)
1762 #define FF_API_SET_DIMENSIONS (LIBAVCODEC_VERSION_MAJOR < 56)
1763 #define FF_API_DEBUG_MV (LIBAVCODEC_VERSION_MAJOR < 56)
1764 #define FF_API_AC_VLC (LIBAVCODEC_VERSION_MAJOR < 56)
1765 #define FF_API_OLD_MSMPEG4 (LIBAVCODEC_VERSION_MAJOR < 56)
1766 #define FF_API_ASPECT_EXTENDED (LIBAVCODEC_VERSION_MAJOR < 56)
1767 #define FF_API_THREAD_OPAQUE (LIBAVCODEC_VERSION_MAJOR < 56)
1768 #define FF_API_CODEC_PKT (LIBAVCODEC_VERSION_MAJOR < 56)
1769 #define FF_API_ARCH_ALPHA (LIBAVCODEC_VERSION_MAJOR < 56)
1770 #define FF_API_ERROR_RATE (LIBAVCODEC_VERSION_MAJOR < 56)
1771 #define FF_API_QSCALE_TYPE (LIBAVCODEC_VERSION_MAJOR < 56)
1772 #define FF_API_MB_TYPE (LIBAVCODEC_VERSION_MAJOR < 56)
1773 #define FF_API_MAX_BFRAMES (LIBAVCODEC_VERSION_MAJOR < 56)
1774 #define FF_API_FAST_MALLOC (LIBAVCODEC_VERSION_MAJOR < 56)
1775 #define FF_API_NEG_LINESIZES (LIBAVCODEC_VERSION_MAJOR < 56)
1776 #define FF_API_EMU_EDGE (LIBAVCODEC_VERSION_MAJOR < 56)
1777 #define FF_API_ARCH_SH4 (LIBAVCODEC_VERSION_MAJOR < 56)
1778 #define FF_API_ARCH_SPARC (LIBAVCODEC_VERSION_MAJOR < 56)
1779 #define FF_API_INPUT_PRESERVED (LIBAVCODEC_VERSION_MAJOR < 57)
1780 #define FF_API_NORMALIZE_AQP (LIBAVCODEC_VERSION_MAJOR < 57)
1781 #define FF_API_GMC (LIBAVCODEC_VERSION_MAJOR < 57)
1782 #define FF_API_MV0 (LIBAVCODEC_VERSION_MAJOR < 57)
1783 #define FF_API_CODEC_NAME (LIBAVCODEC_VERSION_MAJOR < 57)
1784
1785 enum AVCodecID {
1786 AV_CODEC_ID_NONE,
1787
1788 AV_CODEC_ID_MPEG1VIDEO,
1789 AV_CODEC_ID_MPEG2VIDEO,
1790 AV_CODEC_ID_MPEG2VIDEO_XVMC,
1791 AV_CODEC_ID_H261,
1792 AV_CODEC_ID_H263,
1793 AV_CODEC_ID_RV10,
1794 AV_CODEC_ID_RV20,
1795 AV_CODEC_ID_MJPEG,
1796 AV_CODEC_ID_MJPEGB,
1797 AV_CODEC_ID_LJPEG,
1798 AV_CODEC_ID_SP5X,
1799 AV_CODEC_ID_JPEGLS,
1800 AV_CODEC_ID_MPEG4,
1801 AV_CODEC_ID_RAWVIDEO,
1802 AV_CODEC_ID_MSMPEG4V1,
1803 AV_CODEC_ID_MSMPEG4V2,
1804 AV_CODEC_ID_MSMPEG4V3,
1805 AV_CODEC_ID_WMV1,
1806 AV_CODEC_ID_WMV2,
1807 AV_CODEC_ID_H263P,
1808 AV_CODEC_ID_H263I,
1809 AV_CODEC_ID_FLV1,
1810 AV_CODEC_ID_SVQ1,
1811 AV_CODEC_ID_SVQ3,
1812 AV_CODEC_ID_DVVIDEO,
1813 AV_CODEC_ID_HUFFYUV,
1814 AV_CODEC_ID_CYUV,
1815 AV_CODEC_ID_H264,
1816 AV_CODEC_ID_INDEO3,
1817 AV_CODEC_ID_VP3,
1818 AV_CODEC_ID_THEORA,
1819 AV_CODEC_ID_ASV1,
1820 AV_CODEC_ID_ASV2,
1821 AV_CODEC_ID_FFV1,
1822 AV_CODEC_ID_4XM,
1823 AV_CODEC_ID_VCR1,
1824 AV_CODEC_ID_CLJR,
1825 AV_CODEC_ID_MDEC,
1826 AV_CODEC_ID_ROQ,
1827 AV_CODEC_ID_INTERPLAY_VIDEO,
1828 AV_CODEC_ID_XAN_WC3,
1829 AV_CODEC_ID_XAN_WC4,
1830 AV_CODEC_ID_RPZA,
1831 AV_CODEC_ID_CINEPAK,
1832 AV_CODEC_ID_WS_VQA,
1833 AV_CODEC_ID_MSRLE,
1834 AV_CODEC_ID_MSVIDEO1,
1835 AV_CODEC_ID_IDCIN,
1836 AV_CODEC_ID_8BPS,
1837 AV_CODEC_ID_SMC,
1838 AV_CODEC_ID_FLIC,
1839 AV_CODEC_ID_TRUEMOTION1,
1840 AV_CODEC_ID_VMDVIDEO,
1841 AV_CODEC_ID_MSZH,
1842 AV_CODEC_ID_ZLIB,
1843 AV_CODEC_ID_QTRLE,
1844 AV_CODEC_ID_TSCC,
1845 AV_CODEC_ID_ULTI,
1846 AV_CODEC_ID_QDRAW,
1847 AV_CODEC_ID_VIXL,
1848 AV_CODEC_ID_QPEG,
1849 AV_CODEC_ID_PNG,
1850 AV_CODEC_ID_PPM,
1851 AV_CODEC_ID_PBM,
1852 AV_CODEC_ID_PGM,
1853 AV_CODEC_ID_PGMYUV,
1854 AV_CODEC_ID_PAM,
1855 AV_CODEC_ID_FFVHUFF,
1856 AV_CODEC_ID_RV30,
1857 AV_CODEC_ID_RV40,
1858 AV_CODEC_ID_VC1,
1859 AV_CODEC_ID_WMV3,
1860 AV_CODEC_ID_LOCO,
1861 AV_CODEC_ID_WNV1,
1862 AV_CODEC_ID_AASC,
1863 AV_CODEC_ID_INDEO2,
1864 AV_CODEC_ID_FRAPS,
1865 AV_CODEC_ID_TRUEMOTION2,
1866 AV_CODEC_ID_BMP,
1867 AV_CODEC_ID_CSCD,
1868 AV_CODEC_ID_MMVIDEO,
1869 AV_CODEC_ID_ZMBV,
1870 AV_CODEC_ID_AVS,
1871 AV_CODEC_ID_SMACKVIDEO,
1872 AV_CODEC_ID_NUV,
1873 AV_CODEC_ID_KMVC,
1874 AV_CODEC_ID_FLASHSV,
1875 AV_CODEC_ID_CAVS,
1876 AV_CODEC_ID_JPEG2000,
1877 AV_CODEC_ID_VMNC,
1878 AV_CODEC_ID_VP5,
1879 AV_CODEC_ID_VP6,
1880 AV_CODEC_ID_VP6F,
1881 AV_CODEC_ID_TARGA,
1882 AV_CODEC_ID_DSICINVIDEO,
1883 AV_CODEC_ID_TIERTEXSEQVIDEO,
1884 AV_CODEC_ID_TIFF,
1885 AV_CODEC_ID_GIF,
1886 AV_CODEC_ID_DXA,
1887 AV_CODEC_ID_DNXHD,
1888 AV_CODEC_ID_THP,
1889 AV_CODEC_ID_SGI,
1890 AV_CODEC_ID_C93,
1891 AV_CODEC_ID_BETHSOFTVID,
1892 AV_CODEC_ID_PTX,
1893 AV_CODEC_ID_TXD,
1894 AV_CODEC_ID_VP6A,
1895 AV_CODEC_ID_AMV,
1896 AV_CODEC_ID_VB,
1897 AV_CODEC_ID_PCX,
1898 AV_CODEC_ID_SUNRAST,
1899 AV_CODEC_ID_INDEO4,
1900 AV_CODEC_ID_INDEO5,
1901 AV_CODEC_ID_MIMIC,
1902 AV_CODEC_ID_RL2,
1903 AV_CODEC_ID_ESCAPE124,
1904 AV_CODEC_ID_DIRAC,
1905 AV_CODEC_ID_BFI,
1906 AV_CODEC_ID_CMV,
1907 AV_CODEC_ID_MOTIONPIXELS,
1908 AV_CODEC_ID_TGV,
1909 AV_CODEC_ID_TGQ,
1910 AV_CODEC_ID_TQI,
1911 AV_CODEC_ID_AURA,
1912 AV_CODEC_ID_AURA2,
1913 AV_CODEC_ID_V210X,
1914 AV_CODEC_ID_TMV,
1915 AV_CODEC_ID_V210,
1916 AV_CODEC_ID_DPX,
1917 AV_CODEC_ID_MAD,
1918 AV_CODEC_ID_FRWU,
1919 AV_CODEC_ID_FLASHSV2,
1920 AV_CODEC_ID_CDGRAPHICS,
1921 AV_CODEC_ID_R210,
1922 AV_CODEC_ID_ANM,
1923 AV_CODEC_ID_BINKVIDEO,
1924 AV_CODEC_ID_IFF_ILBM,
1925 AV_CODEC_ID_IFF_BYTERUN1,
1926 AV_CODEC_ID_KGV1,
1927 AV_CODEC_ID_YOP,
1928 AV_CODEC_ID_VP8,
1929 AV_CODEC_ID_PICTOR,
1930 AV_CODEC_ID_ANSI,
1931 AV_CODEC_ID_A64_MULTI,
1932 AV_CODEC_ID_A64_MULTI5,
1933 AV_CODEC_ID_R10K,
1934 AV_CODEC_ID_MXPEG,
1935 AV_CODEC_ID_LAGARITH,
1936 AV_CODEC_ID_PRORES,
1937 AV_CODEC_ID_JV,
1938 AV_CODEC_ID_DFA,
1939 AV_CODEC_ID_WMV3IMAGE,
1940 AV_CODEC_ID_VC1IMAGE,
1941 AV_CODEC_ID_UTVIDEO,
1942 AV_CODEC_ID_BMV_VIDEO,
1943 AV_CODEC_ID_VBLE,
1944 AV_CODEC_ID_DXTORY,
1945 AV_CODEC_ID_V410,
1946 AV_CODEC_ID_XWD,
1947 AV_CODEC_ID_CDXL,
1948 AV_CODEC_ID_XBM,
1949 AV_CODEC_ID_ZEROCODEC,
1950 AV_CODEC_ID_MSS1,
1951 AV_CODEC_ID_MSA1,
1952 AV_CODEC_ID_TSCC2,
1953 AV_CODEC_ID_MTS2,
1954 AV_CODEC_ID_CLLC,
1955 AV_CODEC_ID_MSS2,
1956 AV_CODEC_ID_VP9,
1957 AV_CODEC_ID_AIC,
1958 AV_CODEC_ID_ESCAPE130_DEPRECATED,
1959 AV_CODEC_ID_G2M_DEPRECATED,
1960 AV_CODEC_ID_WEBP_DEPRECATED,
1961 AV_CODEC_ID_HNM4_VIDEO,
1962 AV_CODEC_ID_HEVC_DEPRECATED,
1963 AV_CODEC_ID_FIC,
1964 AV_CODEC_ID_ALIAS_PIX,
1965 AV_CODEC_ID_BRENDER_PIX_DEPRECATED,
1966 AV_CODEC_ID_PAF_VIDEO_DEPRECATED,
1967 AV_CODEC_ID_EXR_DEPRECATED,
1968 AV_CODEC_ID_VP7_DEPRECATED,
1969 AV_CODEC_ID_SANM_DEPRECATED,
1970 AV_CODEC_ID_SGIRLE_DEPRECATED,
1971 AV_CODEC_ID_MVC1_DEPRECATED,
1972 AV_CODEC_ID_MVC2_DEPRECATED,
1973
1974 AV_CODEC_ID_BRENDER_PIX= MKBETAG('B','P','I','X'),
1975 AV_CODEC_ID_Y41P = MKBETAG('Y','4','1','P'),
1976 AV_CODEC_ID_ESCAPE130 = MKBETAG('E','1','3','0'),
1977 AV_CODEC_ID_EXR = MKBETAG('0','E','X','R'),
1978 AV_CODEC_ID_AVRP = MKBETAG('A','V','R','P'),
1979
1980 AV_CODEC_ID_012V = MKBETAG('0','1','2','V'),
1981 AV_CODEC_ID_G2M = MKBETAG( 0 ,'G','2','M'),
1982 AV_CODEC_ID_AVUI = MKBETAG('A','V','U','I'),
1983 AV_CODEC_ID_AYUV = MKBETAG('A','Y','U','V'),
1984 AV_CODEC_ID_TARGA_Y216 = MKBETAG('T','2','1','6'),
1985 AV_CODEC_ID_V308 = MKBETAG('V','3','0','8'),
1986 AV_CODEC_ID_V408 = MKBETAG('V','4','0','8'),
1987 AV_CODEC_ID_YUV4 = MKBETAG('Y','U','V','4'),
1988 AV_CODEC_ID_SANM = MKBETAG('S','A','N','M'),
1989 AV_CODEC_ID_PAF_VIDEO = MKBETAG('P','A','F','V'),
1990 AV_CODEC_ID_AVRN = MKBETAG('A','V','R','n'),
1991 AV_CODEC_ID_CPIA = MKBETAG('C','P','I','A'),
1992 AV_CODEC_ID_XFACE = MKBETAG('X','F','A','C'),
1993 AV_CODEC_ID_SGIRLE = MKBETAG('S','G','I','R'),
1994 AV_CODEC_ID_MVC1 = MKBETAG('M','V','C','1'),
1995 AV_CODEC_ID_MVC2 = MKBETAG('M','V','C','2'),
1996 AV_CODEC_ID_SNOW = MKBETAG('S','N','O','W'),
1997 AV_CODEC_ID_WEBP = MKBETAG('W','E','B','P'),
1998 AV_CODEC_ID_SMVJPEG = MKBETAG('S','M','V','J'),
1999 AV_CODEC_ID_HEVC = MKBETAG('H','2','6','5'),
2000 #define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC
2001 AV_CODEC_ID_VP7 = MKBETAG('V','P','7','0'),
2002
2003 AV_CODEC_ID_FIRST_AUDIO = 0x10000,
2004 AV_CODEC_ID_PCM_S16LE = 0x10000,
2005 AV_CODEC_ID_PCM_S16BE,
2006 AV_CODEC_ID_PCM_U16LE,
2007 AV_CODEC_ID_PCM_U16BE,
2008 AV_CODEC_ID_PCM_S8,
2009 AV_CODEC_ID_PCM_U8,
2010 AV_CODEC_ID_PCM_MULAW,
2011 AV_CODEC_ID_PCM_ALAW,
2012 AV_CODEC_ID_PCM_S32LE,
2013 AV_CODEC_ID_PCM_S32BE,
2014 AV_CODEC_ID_PCM_U32LE,
2015 AV_CODEC_ID_PCM_U32BE,
2016 AV_CODEC_ID_PCM_S24LE,
2017 AV_CODEC_ID_PCM_S24BE,
2018 AV_CODEC_ID_PCM_U24LE,
2019 AV_CODEC_ID_PCM_U24BE,
2020 AV_CODEC_ID_PCM_S24DAUD,
2021 AV_CODEC_ID_PCM_ZORK,
2022 AV_CODEC_ID_PCM_S16LE_PLANAR,
2023 AV_CODEC_ID_PCM_DVD,
2024 AV_CODEC_ID_PCM_F32BE,
2025 AV_CODEC_ID_PCM_F32LE,
2026 AV_CODEC_ID_PCM_F64BE,
2027 AV_CODEC_ID_PCM_F64LE,
2028 AV_CODEC_ID_PCM_BLURAY,
2029 AV_CODEC_ID_PCM_LXF,
2030 AV_CODEC_ID_S302M,
2031 AV_CODEC_ID_PCM_S8_PLANAR,
2032 AV_CODEC_ID_PCM_S24LE_PLANAR_DEPRECATED,
2033 AV_CODEC_ID_PCM_S32LE_PLANAR_DEPRECATED,
2034 AV_CODEC_ID_PCM_S24LE_PLANAR = MKBETAG(24,'P','S','P'),
2035 AV_CODEC_ID_PCM_S32LE_PLANAR = MKBETAG(32,'P','S','P'),
2036 AV_CODEC_ID_PCM_S16BE_PLANAR = MKBETAG('P','S','P',16),
2037
2038 AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
2039 AV_CODEC_ID_ADPCM_IMA_WAV,
2040 AV_CODEC_ID_ADPCM_IMA_DK3,
2041 AV_CODEC_ID_ADPCM_IMA_DK4,
2042 AV_CODEC_ID_ADPCM_IMA_WS,
2043 AV_CODEC_ID_ADPCM_IMA_SMJPEG,
2044 AV_CODEC_ID_ADPCM_MS,
2045 AV_CODEC_ID_ADPCM_4XM,
2046 AV_CODEC_ID_ADPCM_XA,
2047 AV_CODEC_ID_ADPCM_ADX,
2048 AV_CODEC_ID_ADPCM_EA,
2049 AV_CODEC_ID_ADPCM_G726,
2050 AV_CODEC_ID_ADPCM_CT,
2051 AV_CODEC_ID_ADPCM_SWF,
2052 AV_CODEC_ID_ADPCM_YAMAHA,
2053 AV_CODEC_ID_ADPCM_SBPRO_4,
2054 AV_CODEC_ID_ADPCM_SBPRO_3,
2055 AV_CODEC_ID_ADPCM_SBPRO_2,
2056 AV_CODEC_ID_ADPCM_THP,
2057 AV_CODEC_ID_ADPCM_IMA_AMV,
2058 AV_CODEC_ID_ADPCM_EA_R1,
2059 AV_CODEC_ID_ADPCM_EA_R3,
2060 AV_CODEC_ID_ADPCM_EA_R2,
2061 AV_CODEC_ID_ADPCM_IMA_EA_SEAD,
2062 AV_CODEC_ID_ADPCM_IMA_EA_EACS,
2063 AV_CODEC_ID_ADPCM_EA_XAS,
2064 AV_CODEC_ID_ADPCM_EA_MAXIS_XA,
2065 AV_CODEC_ID_ADPCM_IMA_ISS,
2066 AV_CODEC_ID_ADPCM_G722,
2067 AV_CODEC_ID_ADPCM_IMA_APC,
2068 AV_CODEC_ID_ADPCM_VIMA_DEPRECATED,
2069 AV_CODEC_ID_ADPCM_VIMA = MKBETAG('V','I','M','A'),
2070 AV_CODEC_ID_VIMA = MKBETAG('V','I','M','A'),
2071 AV_CODEC_ID_ADPCM_AFC = MKBETAG('A','F','C',' '),
2072 AV_CODEC_ID_ADPCM_IMA_OKI = MKBETAG('O','K','I',' '),
2073 AV_CODEC_ID_ADPCM_DTK = MKBETAG('D','T','K',' '),
2074 AV_CODEC_ID_ADPCM_IMA_RAD = MKBETAG('R','A','D',' '),
2075 AV_CODEC_ID_ADPCM_G726LE = MKBETAG('6','2','7','G'),
2076
2077 AV_CODEC_ID_AMR_NB = 0x12000,
2078 AV_CODEC_ID_AMR_WB,
2079
2080 AV_CODEC_ID_RA_144 = 0x13000,
2081 AV_CODEC_ID_RA_288,
2082
2083 AV_CODEC_ID_ROQ_DPCM = 0x14000,
2084 AV_CODEC_ID_INTERPLAY_DPCM,
2085 AV_CODEC_ID_XAN_DPCM,
2086 AV_CODEC_ID_SOL_DPCM,
2087
2088 AV_CODEC_ID_MP2 = 0x15000,
2089 AV_CODEC_ID_MP3,
2090 AV_CODEC_ID_AAC,
2091 AV_CODEC_ID_AC3,
2092 AV_CODEC_ID_DTS,
2093 AV_CODEC_ID_VORBIS,
2094 AV_CODEC_ID_DVAUDIO,
2095 AV_CODEC_ID_WMAV1,
2096 AV_CODEC_ID_WMAV2,
2097 AV_CODEC_ID_MACE3,
2098 AV_CODEC_ID_MACE6,
2099 AV_CODEC_ID_VMDAUDIO,
2100 AV_CODEC_ID_FLAC,
2101 AV_CODEC_ID_MP3ADU,
2102 AV_CODEC_ID_MP3ON4,
2103 AV_CODEC_ID_SHORTEN,
2104 AV_CODEC_ID_ALAC,
2105 AV_CODEC_ID_WESTWOOD_SND1,
2106 AV_CODEC_ID_GSM,
2107 AV_CODEC_ID_QDM2,
2108 AV_CODEC_ID_COOK,
2109 AV_CODEC_ID_TRUESPEECH,
2110 AV_CODEC_ID_TTA,
2111 AV_CODEC_ID_SMACKAUDIO,
2112 AV_CODEC_ID_QCELP,
2113 AV_CODEC_ID_WAVPACK,
2114 AV_CODEC_ID_DSICINAUDIO,
2115 AV_CODEC_ID_IMC,
2116 AV_CODEC_ID_MUSEPACK7,
2117 AV_CODEC_ID_MLP,
2118 AV_CODEC_ID_GSM_MS,
2119 AV_CODEC_ID_ATRAC3,
2120 AV_CODEC_ID_VOXWARE,
2121 AV_CODEC_ID_APE,
2122 AV_CODEC_ID_NELLYMOSER,
2123 AV_CODEC_ID_MUSEPACK8,
2124 AV_CODEC_ID_SPEEX,
2125 AV_CODEC_ID_WMAVOICE,
2126 AV_CODEC_ID_WMAPRO,
2127 AV_CODEC_ID_WMALOSSLESS,
2128 AV_CODEC_ID_ATRAC3P,
2129 AV_CODEC_ID_EAC3,
2130 AV_CODEC_ID_SIPR,
2131 AV_CODEC_ID_MP1,
2132 AV_CODEC_ID_TWINVQ,
2133 AV_CODEC_ID_TRUEHD,
2134 AV_CODEC_ID_MP4ALS,
2135 AV_CODEC_ID_ATRAC1,
2136 AV_CODEC_ID_BINKAUDIO_RDFT,
2137 AV_CODEC_ID_BINKAUDIO_DCT,
2138 AV_CODEC_ID_AAC_LATM,
2139 AV_CODEC_ID_QDMC,
2140 AV_CODEC_ID_CELT,
2141 AV_CODEC_ID_G723_1,
2142 AV_CODEC_ID_G729,
2143 AV_CODEC_ID_8SVX_EXP,
2144 AV_CODEC_ID_8SVX_FIB,
2145 AV_CODEC_ID_BMV_AUDIO,
2146 AV_CODEC_ID_RALF,
2147 AV_CODEC_ID_IAC,
2148 AV_CODEC_ID_ILBC,
2149 AV_CODEC_ID_OPUS_DEPRECATED,
2150 AV_CODEC_ID_COMFORT_NOISE,
2151 AV_CODEC_ID_TAK_DEPRECATED,
2152 AV_CODEC_ID_METASOUND,
2153 AV_CODEC_ID_PAF_AUDIO_DEPRECATED,
2154 AV_CODEC_ID_ON2AVC,
2155 AV_CODEC_ID_FFWAVESYNTH = MKBETAG('F','F','W','S'),
2156 AV_CODEC_ID_SONIC = MKBETAG('S','O','N','C'),
2157 AV_CODEC_ID_SONIC_LS = MKBETAG('S','O','N','L'),
2158 AV_CODEC_ID_PAF_AUDIO = MKBETAG('P','A','F','A'),
2159 AV_CODEC_ID_OPUS = MKBETAG('O','P','U','S'),
2160 AV_CODEC_ID_TAK = MKBETAG('t','B','a','K'),
2161 AV_CODEC_ID_EVRC = MKBETAG('s','e','v','c'),
2162 AV_CODEC_ID_SMV = MKBETAG('s','s','m','v'),
2163 AV_CODEC_ID_DSD_LSBF = MKBETAG('D','S','D','L'),
2164 AV_CODEC_ID_DSD_MSBF = MKBETAG('D','S','D','M'),
2165 AV_CODEC_ID_DSD_LSBF_PLANAR = MKBETAG('D','S','D','1'),
2166 AV_CODEC_ID_DSD_MSBF_PLANAR = MKBETAG('D','S','D','8'),
2167
2168 AV_CODEC_ID_FIRST_SUBTITLE = 0x17000,
2169 AV_CODEC_ID_DVD_SUBTITLE = 0x17000,
2170 AV_CODEC_ID_DVB_SUBTITLE,
2171 AV_CODEC_ID_TEXT,
2172 AV_CODEC_ID_XSUB,
2173 AV_CODEC_ID_SSA,
2174 AV_CODEC_ID_MOV_TEXT,
2175 AV_CODEC_ID_HDMV_PGS_SUBTITLE,
2176 AV_CODEC_ID_DVB_TELETEXT,
2177 AV_CODEC_ID_SRT,
2178 AV_CODEC_ID_MICRODVD = MKBETAG('m','D','V','D'),
2179 AV_CODEC_ID_EIA_608 = MKBETAG('c','6','0','8'),
2180 AV_CODEC_ID_JACOSUB = MKBETAG('J','S','U','B'),
2181 AV_CODEC_ID_SAMI = MKBETAG('S','A','M','I'),
2182 AV_CODEC_ID_REALTEXT = MKBETAG('R','T','X','T'),
2183 AV_CODEC_ID_SUBVIEWER1 = MKBETAG('S','b','V','1'),
2184 AV_CODEC_ID_SUBVIEWER = MKBETAG('S','u','b','V'),
2185 AV_CODEC_ID_SUBRIP = MKBETAG('S','R','i','p'),
2186 AV_CODEC_ID_WEBVTT = MKBETAG('W','V','T','T'),
2187 AV_CODEC_ID_MPL2 = MKBETAG('M','P','L','2'),
2188 AV_CODEC_ID_VPLAYER = MKBETAG('V','P','l','r'),
2189 AV_CODEC_ID_PJS = MKBETAG('P','h','J','S'),
2190 AV_CODEC_ID_ASS = MKBETAG('A','S','S',' '),
2191
2192 AV_CODEC_ID_FIRST_UNKNOWN = 0x18000,
2193 AV_CODEC_ID_TTF = 0x18000,
2194 AV_CODEC_ID_BINTEXT = MKBETAG('B','T','X','T'),
2195 AV_CODEC_ID_XBIN = MKBETAG('X','B','I','N'),
2196 AV_CODEC_ID_IDF = MKBETAG( 0 ,'I','D','F'),
2197 AV_CODEC_ID_OTF = MKBETAG( 0 ,'O','T','F'),
2198 AV_CODEC_ID_SMPTE_KLV = MKBETAG('K','L','V','A'),
2199 AV_CODEC_ID_DVD_NAV = MKBETAG('D','N','A','V'),
2200 AV_CODEC_ID_TIMED_ID3 = MKBETAG('T','I','D','3'),
2201 AV_CODEC_ID_BIN_DATA = MKBETAG('D','A','T','A'),
2202
2203 AV_CODEC_ID_PROBE = 0x19000,
2204
2205 AV_CODEC_ID_MPEG2TS = 0x20000,
2206
2207 AV_CODEC_ID_MPEG4SYSTEMS = 0x20001,
2208
2209 AV_CODEC_ID_FFMETADATA = 0x21000,
2210
2211 #define AVCODEC_OLD_CODEC_IDS_H
2212
2213 CODEC_ID_NONE = AV_CODEC_ID_NONE,
2214
2215 CODEC_ID_MPEG1VIDEO,
2216 CODEC_ID_MPEG2VIDEO,
2217 CODEC_ID_MPEG2VIDEO_XVMC,
2218 CODEC_ID_H261,
2219 CODEC_ID_H263,
2220 CODEC_ID_RV10,
2221 CODEC_ID_RV20,
2222 CODEC_ID_MJPEG,
2223 CODEC_ID_MJPEGB,
2224 CODEC_ID_LJPEG,
2225 CODEC_ID_SP5X,
2226 CODEC_ID_JPEGLS,
2227 CODEC_ID_MPEG4,
2228 CODEC_ID_RAWVIDEO,
2229 CODEC_ID_MSMPEG4V1,
2230 CODEC_ID_MSMPEG4V2,
2231 CODEC_ID_MSMPEG4V3,
2232 CODEC_ID_WMV1,
2233 CODEC_ID_WMV2,
2234 CODEC_ID_H263P,
2235 CODEC_ID_H263I,
2236 CODEC_ID_FLV1,
2237 CODEC_ID_SVQ1,
2238 CODEC_ID_SVQ3,
2239 CODEC_ID_DVVIDEO,
2240 CODEC_ID_HUFFYUV,
2241 CODEC_ID_CYUV,
2242 CODEC_ID_H264,
2243 CODEC_ID_INDEO3,
2244 CODEC_ID_VP3,
2245 CODEC_ID_THEORA,
2246 CODEC_ID_ASV1,
2247 CODEC_ID_ASV2,
2248 CODEC_ID_FFV1,
2249 CODEC_ID_4XM,
2250 CODEC_ID_VCR1,
2251 CODEC_ID_CLJR,
2252 CODEC_ID_MDEC,
2253 CODEC_ID_ROQ,
2254 CODEC_ID_INTERPLAY_VIDEO,
2255 CODEC_ID_XAN_WC3,
2256 CODEC_ID_XAN_WC4,
2257 CODEC_ID_RPZA,
2258 CODEC_ID_CINEPAK,
2259 CODEC_ID_WS_VQA,
2260 CODEC_ID_MSRLE,
2261 CODEC_ID_MSVIDEO1,
2262 CODEC_ID_IDCIN,
2263 CODEC_ID_8BPS,
2264 CODEC_ID_SMC,
2265 CODEC_ID_FLIC,
2266 CODEC_ID_TRUEMOTION1,
2267 CODEC_ID_VMDVIDEO,
2268 CODEC_ID_MSZH,
2269 CODEC_ID_ZLIB,
2270 CODEC_ID_QTRLE,
2271 CODEC_ID_TSCC,
2272 CODEC_ID_ULTI,
2273 CODEC_ID_QDRAW,
2274 CODEC_ID_VIXL,
2275 CODEC_ID_QPEG,
2276 CODEC_ID_PNG,
2277 CODEC_ID_PPM,
2278 CODEC_ID_PBM,
2279 CODEC_ID_PGM,
2280 CODEC_ID_PGMYUV,
2281 CODEC_ID_PAM,
2282 CODEC_ID_FFVHUFF,
2283 CODEC_ID_RV30,
2284 CODEC_ID_RV40,
2285 CODEC_ID_VC1,
2286 CODEC_ID_WMV3,
2287 CODEC_ID_LOCO,
2288 CODEC_ID_WNV1,
2289 CODEC_ID_AASC,
2290 CODEC_ID_INDEO2,
2291 CODEC_ID_FRAPS,
2292 CODEC_ID_TRUEMOTION2,
2293 CODEC_ID_BMP,
2294 CODEC_ID_CSCD,
2295 CODEC_ID_MMVIDEO,
2296 CODEC_ID_ZMBV,
2297 CODEC_ID_AVS,
2298 CODEC_ID_SMACKVIDEO,
2299 CODEC_ID_NUV,
2300 CODEC_ID_KMVC,
2301 CODEC_ID_FLASHSV,
2302 CODEC_ID_CAVS,
2303 CODEC_ID_JPEG2000,
2304 CODEC_ID_VMNC,
2305 CODEC_ID_VP5,
2306 CODEC_ID_VP6,
2307 CODEC_ID_VP6F,
2308 CODEC_ID_TARGA,
2309 CODEC_ID_DSICINVIDEO,
2310 CODEC_ID_TIERTEXSEQVIDEO,
2311 CODEC_ID_TIFF,
2312 CODEC_ID_GIF,
2313 CODEC_ID_DXA,
2314 CODEC_ID_DNXHD,
2315 CODEC_ID_THP,
2316 CODEC_ID_SGI,
2317 CODEC_ID_C93,
2318 CODEC_ID_BETHSOFTVID,
2319 CODEC_ID_PTX,
2320 CODEC_ID_TXD,
2321 CODEC_ID_VP6A,
2322 CODEC_ID_AMV,
2323 CODEC_ID_VB,
2324 CODEC_ID_PCX,
2325 CODEC_ID_SUNRAST,
2326 CODEC_ID_INDEO4,
2327 CODEC_ID_INDEO5,
2328 CODEC_ID_MIMIC,
2329 CODEC_ID_RL2,
2330 CODEC_ID_ESCAPE124,
2331 CODEC_ID_DIRAC,
2332 CODEC_ID_BFI,
2333 CODEC_ID_CMV,
2334 CODEC_ID_MOTIONPIXELS,
2335 CODEC_ID_TGV,
2336 CODEC_ID_TGQ,
2337 CODEC_ID_TQI,
2338 CODEC_ID_AURA,
2339 CODEC_ID_AURA2,
2340 CODEC_ID_V210X,
2341 CODEC_ID_TMV,
2342 CODEC_ID_V210,
2343 CODEC_ID_DPX,
2344 CODEC_ID_MAD,
2345 CODEC_ID_FRWU,
2346 CODEC_ID_FLASHSV2,
2347 CODEC_ID_CDGRAPHICS,
2348 CODEC_ID_R210,
2349 CODEC_ID_ANM,
2350 CODEC_ID_BINKVIDEO,
2351 CODEC_ID_IFF_ILBM,
2352 CODEC_ID_IFF_BYTERUN1,
2353 CODEC_ID_KGV1,
2354 CODEC_ID_YOP,
2355 CODEC_ID_VP8,
2356 CODEC_ID_PICTOR,
2357 CODEC_ID_ANSI,
2358 CODEC_ID_A64_MULTI,
2359 CODEC_ID_A64_MULTI5,
2360 CODEC_ID_R10K,
2361 CODEC_ID_MXPEG,
2362 CODEC_ID_LAGARITH,
2363 CODEC_ID_PRORES,
2364 CODEC_ID_JV,
2365 CODEC_ID_DFA,
2366 CODEC_ID_WMV3IMAGE,
2367 CODEC_ID_VC1IMAGE,
2368 CODEC_ID_UTVIDEO,
2369 CODEC_ID_BMV_VIDEO,
2370 CODEC_ID_VBLE,
2371 CODEC_ID_DXTORY,
2372 CODEC_ID_V410,
2373 CODEC_ID_XWD,
2374 CODEC_ID_CDXL,
2375 CODEC_ID_XBM,
2376 CODEC_ID_ZEROCODEC,
2377 CODEC_ID_MSS1,
2378 CODEC_ID_MSA1,
2379 CODEC_ID_TSCC2,
2380 CODEC_ID_MTS2,
2381 CODEC_ID_CLLC,
2382 CODEC_ID_Y41P = MKBETAG('Y','4','1','P'),
2383 CODEC_ID_ESCAPE130 = MKBETAG('E','1','3','0'),
2384 CODEC_ID_EXR = MKBETAG('0','E','X','R'),
2385 CODEC_ID_AVRP = MKBETAG('A','V','R','P'),
2386
2387 CODEC_ID_G2M = MKBETAG( 0 ,'G','2','M'),
2388 CODEC_ID_AVUI = MKBETAG('A','V','U','I'),
2389 CODEC_ID_AYUV = MKBETAG('A','Y','U','V'),
2390 CODEC_ID_V308 = MKBETAG('V','3','0','8'),
2391 CODEC_ID_V408 = MKBETAG('V','4','0','8'),
2392 CODEC_ID_YUV4 = MKBETAG('Y','U','V','4'),
2393 CODEC_ID_SANM = MKBETAG('S','A','N','M'),
2394 CODEC_ID_PAF_VIDEO = MKBETAG('P','A','F','V'),
2395 CODEC_ID_SNOW = AV_CODEC_ID_SNOW,
2396
2397 CODEC_ID_FIRST_AUDIO = 0x10000,
2398 CODEC_ID_PCM_S16LE = 0x10000,
2399 CODEC_ID_PCM_S16BE,
2400 CODEC_ID_PCM_U16LE,
2401 CODEC_ID_PCM_U16BE,
2402 CODEC_ID_PCM_S8,
2403 CODEC_ID_PCM_U8,
2404 CODEC_ID_PCM_MULAW,
2405 CODEC_ID_PCM_ALAW,
2406 CODEC_ID_PCM_S32LE,
2407 CODEC_ID_PCM_S32BE,
2408 CODEC_ID_PCM_U32LE,
2409 CODEC_ID_PCM_U32BE,
2410 CODEC_ID_PCM_S24LE,
2411 CODEC_ID_PCM_S24BE,
2412 CODEC_ID_PCM_U24LE,
2413 CODEC_ID_PCM_U24BE,
2414 CODEC_ID_PCM_S24DAUD,
2415 CODEC_ID_PCM_ZORK,
2416 CODEC_ID_PCM_S16LE_PLANAR,
2417 CODEC_ID_PCM_DVD,
2418 CODEC_ID_PCM_F32BE,
2419 CODEC_ID_PCM_F32LE,
2420 CODEC_ID_PCM_F64BE,
2421 CODEC_ID_PCM_F64LE,
2422 CODEC_ID_PCM_BLURAY,
2423 CODEC_ID_PCM_LXF,
2424 CODEC_ID_S302M,
2425 CODEC_ID_PCM_S8_PLANAR,
2426
2427 CODEC_ID_ADPCM_IMA_QT = 0x11000,
2428 CODEC_ID_ADPCM_IMA_WAV,
2429 CODEC_ID_ADPCM_IMA_DK3,
2430 CODEC_ID_ADPCM_IMA_DK4,
2431 CODEC_ID_ADPCM_IMA_WS,
2432 CODEC_ID_ADPCM_IMA_SMJPEG,
2433 CODEC_ID_ADPCM_MS,
2434 CODEC_ID_ADPCM_4XM,
2435 CODEC_ID_ADPCM_XA,
2436 CODEC_ID_ADPCM_ADX,
2437 CODEC_ID_ADPCM_EA,
2438 CODEC_ID_ADPCM_G726,
2439 CODEC_ID_ADPCM_CT,
2440 CODEC_ID_ADPCM_SWF,
2441 CODEC_ID_ADPCM_YAMAHA,
2442 CODEC_ID_ADPCM_SBPRO_4,
2443 CODEC_ID_ADPCM_SBPRO_3,
2444 CODEC_ID_ADPCM_SBPRO_2,
2445 CODEC_ID_ADPCM_THP,
2446 CODEC_ID_ADPCM_IMA_AMV,
2447 CODEC_ID_ADPCM_EA_R1,
2448 CODEC_ID_ADPCM_EA_R3,
2449 CODEC_ID_ADPCM_EA_R2,
2450 CODEC_ID_ADPCM_IMA_EA_SEAD,
2451 CODEC_ID_ADPCM_IMA_EA_EACS,
2452 CODEC_ID_ADPCM_EA_XAS,
2453 CODEC_ID_ADPCM_EA_MAXIS_XA,
2454 CODEC_ID_ADPCM_IMA_ISS,
2455 CODEC_ID_ADPCM_G722,
2456 CODEC_ID_ADPCM_IMA_APC,
2457 CODEC_ID_VIMA = MKBETAG('V','I','M','A'),
2458
2459 CODEC_ID_AMR_NB = 0x12000,
2460 CODEC_ID_AMR_WB,
2461
2462 CODEC_ID_RA_144 = 0x13000,
2463 CODEC_ID_RA_288,
2464
2465 CODEC_ID_ROQ_DPCM = 0x14000,
2466 CODEC_ID_INTERPLAY_DPCM,
2467 CODEC_ID_XAN_DPCM,
2468 CODEC_ID_SOL_DPCM,
2469
2470 CODEC_ID_MP2 = 0x15000,
2471 CODEC_ID_MP3,
2472 CODEC_ID_AAC,
2473 CODEC_ID_AC3,
2474 CODEC_ID_DTS,
2475 CODEC_ID_VORBIS,
2476 CODEC_ID_DVAUDIO,
2477 CODEC_ID_WMAV1,
2478 CODEC_ID_WMAV2,
2479 CODEC_ID_MACE3,
2480 CODEC_ID_MACE6,
2481 CODEC_ID_VMDAUDIO,
2482 CODEC_ID_FLAC,
2483 CODEC_ID_MP3ADU,
2484 CODEC_ID_MP3ON4,
2485 CODEC_ID_SHORTEN,
2486 CODEC_ID_ALAC,
2487 CODEC_ID_WESTWOOD_SND1,
2488 CODEC_ID_GSM,
2489 CODEC_ID_QDM2,
2490 CODEC_ID_COOK,
2491 CODEC_ID_TRUESPEECH,
2492 CODEC_ID_TTA,
2493 CODEC_ID_SMACKAUDIO,
2494 CODEC_ID_QCELP,
2495 CODEC_ID_WAVPACK,
2496 CODEC_ID_DSICINAUDIO,
2497 CODEC_ID_IMC,
2498 CODEC_ID_MUSEPACK7,
2499 CODEC_ID_MLP,
2500 CODEC_ID_GSM_MS,
2501 CODEC_ID_ATRAC3,
2502 CODEC_ID_VOXWARE,
2503 CODEC_ID_APE,
2504 CODEC_ID_NELLYMOSER,
2505 CODEC_ID_MUSEPACK8,
2506 CODEC_ID_SPEEX,
2507 CODEC_ID_WMAVOICE,
2508 CODEC_ID_WMAPRO,
2509 CODEC_ID_WMALOSSLESS,
2510 CODEC_ID_ATRAC3P,
2511 CODEC_ID_EAC3,
2512 CODEC_ID_SIPR,
2513 CODEC_ID_MP1,
2514 CODEC_ID_TWINVQ,
2515 CODEC_ID_TRUEHD,
2516 CODEC_ID_MP4ALS,
2517 CODEC_ID_ATRAC1,
2518 CODEC_ID_BINKAUDIO_RDFT,
2519 CODEC_ID_BINKAUDIO_DCT,
2520 CODEC_ID_AAC_LATM,
2521 CODEC_ID_QDMC,
2522 CODEC_ID_CELT,
2523 CODEC_ID_G723_1,
2524 CODEC_ID_G729,
2525 CODEC_ID_8SVX_EXP,
2526 CODEC_ID_8SVX_FIB,
2527 CODEC_ID_BMV_AUDIO,
2528 CODEC_ID_RALF,
2529 CODEC_ID_IAC,
2530 CODEC_ID_ILBC,
2531 CODEC_ID_FFWAVESYNTH = MKBETAG('F','F','W','S'),
2532 CODEC_ID_SONIC = MKBETAG('S','O','N','C'),
2533 CODEC_ID_SONIC_LS = MKBETAG('S','O','N','L'),
2534 CODEC_ID_PAF_AUDIO = MKBETAG('P','A','F','A'),
2535 CODEC_ID_OPUS = MKBETAG('O','P','U','S'),
2536
2537 CODEC_ID_FIRST_SUBTITLE = 0x17000,
2538 CODEC_ID_DVD_SUBTITLE = 0x17000,
2539 CODEC_ID_DVB_SUBTITLE,
2540 CODEC_ID_TEXT,
2541 CODEC_ID_XSUB,
2542 CODEC_ID_SSA,
2543 CODEC_ID_MOV_TEXT,
2544 CODEC_ID_HDMV_PGS_SUBTITLE,
2545 CODEC_ID_DVB_TELETEXT,
2546 CODEC_ID_SRT,
2547 CODEC_ID_MICRODVD = MKBETAG('m','D','V','D'),
2548 CODEC_ID_EIA_608 = MKBETAG('c','6','0','8'),
2549 CODEC_ID_JACOSUB = MKBETAG('J','S','U','B'),
2550 CODEC_ID_SAMI = MKBETAG('S','A','M','I'),
2551 CODEC_ID_REALTEXT = MKBETAG('R','T','X','T'),
2552 CODEC_ID_SUBVIEWER = MKBETAG('S','u','b','V'),
2553
2554 CODEC_ID_FIRST_UNKNOWN = 0x18000,
2555 CODEC_ID_TTF = 0x18000,
2556 CODEC_ID_BINTEXT = MKBETAG('B','T','X','T'),
2557 CODEC_ID_XBIN = MKBETAG('X','B','I','N'),
2558 CODEC_ID_IDF = MKBETAG( 0 ,'I','D','F'),
2559 CODEC_ID_OTF = MKBETAG( 0 ,'O','T','F'),
2560
2561 CODEC_ID_PROBE = 0x19000,
2562
2563 CODEC_ID_MPEG2TS = 0x20000,
2564
2565 CODEC_ID_MPEG4SYSTEMS = 0x20001,
2566
2567 CODEC_ID_FFMETADATA = 0x21000,
2568
2569 };
2570
2571 typedef struct AVCodecDescriptor {
2572 enum AVCodecID id;
2573 enum AVMediaType type;
2574
2575 const char *name;
2576
2577 const char *long_name;
2578
2579 int props;
2580
2581 const char *const *mime_types;
2582 } AVCodecDescriptor;
2583
2584 #define AV_CODEC_PROP_INTRA_ONLY (1 << 0)
2585
2586 #define AV_CODEC_PROP_LOSSY (1 << 1)
2587
2588 #define AV_CODEC_PROP_LOSSLESS (1 << 2)
2589
2590 #define AV_CODEC_PROP_BITMAP_SUB (1 << 16)
2591
2592 #define AV_CODEC_PROP_TEXT_SUB (1 << 17)
2593
2594 #define FF_INPUT_BUFFER_PADDING_SIZE 32
2595
2596 #define FF_MIN_BUFFER_SIZE 16384
2597
2598 enum Motion_Est_ID {
2599 ME_ZERO = 1,
2600 ME_FULL,
2601 ME_LOG,
2602 ME_PHODS,
2603 ME_EPZS,
2604 ME_X1,
2605 ME_HEX,
2606 ME_UMH,
2607 ME_TESA,
2608 ME_ITER=50,
2609 };
2610
2611 enum AVDiscard{
2612
2613 AVDISCARD_NONE =-16,
2614 AVDISCARD_DEFAULT = 0,
2615 AVDISCARD_NONREF = 8,
2616 AVDISCARD_BIDIR = 16,
2617 AVDISCARD_NONINTRA= 24,
2618 AVDISCARD_NONKEY = 32,
2619 AVDISCARD_ALL = 48,
2620 };
2621
2622 enum AVAudioServiceType {
2623 AV_AUDIO_SERVICE_TYPE_MAIN = 0,
2624 AV_AUDIO_SERVICE_TYPE_EFFECTS = 1,
2625 AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED = 2,
2626 AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED = 3,
2627 AV_AUDIO_SERVICE_TYPE_DIALOGUE = 4,
2628 AV_AUDIO_SERVICE_TYPE_COMMENTARY = 5,
2629 AV_AUDIO_SERVICE_TYPE_EMERGENCY = 6,
2630 AV_AUDIO_SERVICE_TYPE_VOICE_OVER = 7,
2631 AV_AUDIO_SERVICE_TYPE_KARAOKE = 8,
2632 AV_AUDIO_SERVICE_TYPE_NB ,
2633 };
2634
2635 typedef struct RcOverride{
2636 int start_frame;
2637 int end_frame;
2638 int qscale;
2639 float quality_factor;
2640 } RcOverride;
2641
2642 #define FF_MAX_B_FRAMES 16
2643
2644 #define CODEC_FLAG_UNALIGNED 0x0001
2645 #define CODEC_FLAG_QSCALE 0x0002
2646 #define CODEC_FLAG_4MV 0x0004
2647 #define CODEC_FLAG_OUTPUT_CORRUPT 0x0008
2648 #define CODEC_FLAG_QPEL 0x0010
2649
2650 #define CODEC_FLAG_GMC 0x0020
2651
2652 #define CODEC_FLAG_MV0 0x0040
2653
2654 #define CODEC_FLAG_INPUT_PRESERVED 0x0100
2655 #define CODEC_FLAG_PASS1 0x0200
2656 #define CODEC_FLAG_PASS2 0x0400
2657 #define CODEC_FLAG_GRAY 0x2000
2658
2659 #define CODEC_FLAG_EMU_EDGE 0x4000
2660 #define CODEC_FLAG_PSNR 0x8000
2661 #define CODEC_FLAG_TRUNCATED 0x00010000
2662
2663 #define CODEC_FLAG_NORMALIZE_AQP 0x00020000
2664 #define CODEC_FLAG_INTERLACED_DCT 0x00040000
2665 #define CODEC_FLAG_LOW_DELAY 0x00080000
2666 #define CODEC_FLAG_GLOBAL_HEADER 0x00400000
2667 #define CODEC_FLAG_BITEXACT 0x00800000
2668
2669 #define CODEC_FLAG_AC_PRED 0x01000000
2670 #define CODEC_FLAG_LOOP_FILTER 0x00000800
2671 #define CODEC_FLAG_INTERLACED_ME 0x20000000
2672 #define CODEC_FLAG_CLOSED_GOP 0x80000000
2673 #define CODEC_FLAG2_FAST 0x00000001
2674 #define CODEC_FLAG2_NO_OUTPUT 0x00000004
2675 #define CODEC_FLAG2_LOCAL_HEADER 0x00000008
2676 #define CODEC_FLAG2_DROP_FRAME_TIMECODE 0x00002000
2677 #define CODEC_FLAG2_IGNORE_CROP 0x00010000
2678
2679 #define CODEC_FLAG2_CHUNKS 0x00008000
2680 #define CODEC_FLAG2_SHOW_ALL 0x00400000
2681
2682 #define CODEC_CAP_DRAW_HORIZ_BAND 0x0001
2683
2684 #define CODEC_CAP_DR1 0x0002
2685 #define CODEC_CAP_TRUNCATED 0x0008
2686
2687 #define CODEC_CAP_HWACCEL 0x0010
2688
2689 #define CODEC_CAP_DELAY 0x0020
2690
2691 #define CODEC_CAP_SMALL_LAST_FRAME 0x0040
2692
2693 #define CODEC_CAP_HWACCEL_VDPAU 0x0080
2694
2695 #define CODEC_CAP_SUBFRAMES 0x0100
2696
2697 #define CODEC_CAP_EXPERIMENTAL 0x0200
2698
2699 #define CODEC_CAP_CHANNEL_CONF 0x0400
2700
2701 #define CODEC_CAP_NEG_LINESIZES 0x0800
2702
2703 #define CODEC_CAP_FRAME_THREADS 0x1000
2704
2705 #define CODEC_CAP_SLICE_THREADS 0x2000
2706
2707 #define CODEC_CAP_PARAM_CHANGE 0x4000
2708
2709 #define CODEC_CAP_AUTO_THREADS 0x8000
2710
2711 #define CODEC_CAP_VARIABLE_FRAME_SIZE 0x10000
2712
2713 #define CODEC_CAP_INTRA_ONLY 0x40000000
2714
2715 #define CODEC_CAP_LOSSLESS 0x80000000
2716
2717 #define MB_TYPE_INTRA4x4 0x0001
2718 #define MB_TYPE_INTRA16x16 0x0002
2719 #define MB_TYPE_INTRA_PCM 0x0004
2720 #define MB_TYPE_16x16 0x0008
2721 #define MB_TYPE_16x8 0x0010
2722 #define MB_TYPE_8x16 0x0020
2723 #define MB_TYPE_8x8 0x0040
2724 #define MB_TYPE_INTERLACED 0x0080
2725 #define MB_TYPE_DIRECT2 0x0100
2726 #define MB_TYPE_ACPRED 0x0200
2727 #define MB_TYPE_GMC 0x0400
2728 #define MB_TYPE_SKIP 0x0800
2729 #define MB_TYPE_P0L0 0x1000
2730 #define MB_TYPE_P1L0 0x2000
2731 #define MB_TYPE_P0L1 0x4000
2732 #define MB_TYPE_P1L1 0x8000
2733 #define MB_TYPE_L0 (MB_TYPE_P0L0 | MB_TYPE_P1L0)
2734 #define MB_TYPE_L1 (MB_TYPE_P0L1 | MB_TYPE_P1L1)
2735 #define MB_TYPE_L0L1 (MB_TYPE_L0 | MB_TYPE_L1)
2736 #define MB_TYPE_QUANT 0x00010000
2737 #define MB_TYPE_CBP 0x00020000
2738
2739 typedef struct AVPanScan{
2740
2741 int id;
2742
2743 int width;
2744 int height;
2745
2746 int16_t position[3][2];
2747 }AVPanScan;
2748
2749 #define FF_QSCALE_TYPE_MPEG1 0
2750 #define FF_QSCALE_TYPE_MPEG2 1
2751 #define FF_QSCALE_TYPE_H264 2
2752 #define FF_QSCALE_TYPE_VP56 3
2753
2754 #define FF_BUFFER_TYPE_INTERNAL 1
2755 #define FF_BUFFER_TYPE_USER 2
2756 #define FF_BUFFER_TYPE_SHARED 4
2757 #define FF_BUFFER_TYPE_COPY 8
2758
2759 #define FF_BUFFER_HINTS_VALID 0x01
2760 #define FF_BUFFER_HINTS_READABLE 0x02
2761 #define FF_BUFFER_HINTS_PRESERVE 0x04
2762 #define FF_BUFFER_HINTS_REUSABLE 0x08
2763
2764 #define AV_GET_BUFFER_FLAG_REF (1 << 0)
2765
2766 enum AVPacketSideDataType {
2767 AV_PKT_DATA_PALETTE,
2768 AV_PKT_DATA_NEW_EXTRADATA,
2769
2770 AV_PKT_DATA_PARAM_CHANGE,
2771
2772 AV_PKT_DATA_H263_MB_INFO,
2773
2774 AV_PKT_DATA_REPLAYGAIN,
2775
2776 AV_PKT_DATA_DISPLAYMATRIX,
2777
2778 AV_PKT_DATA_SKIP_SAMPLES=70,
2779
2780 AV_PKT_DATA_JP_DUALMONO,
2781
2782 AV_PKT_DATA_STRINGS_METADATA,
2783
2784 AV_PKT_DATA_SUBTITLE_POSITION,
2785
2786 AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
2787
2788 AV_PKT_DATA_WEBVTT_IDENTIFIER,
2789
2790 AV_PKT_DATA_WEBVTT_SETTINGS,
2791
2792 AV_PKT_DATA_METADATA_UPDATE,
2793 };
2794
2795 typedef struct AVPacketSideData {
2796 uint8_t *data;
2797 int size;
2798 enum AVPacketSideDataType type;
2799 } AVPacketSideData;
2800
2801 typedef struct AVPacket {
2802
2803 AVBufferRef *buf;
2804
2805 int64_t pts;
2806
2807 int64_t dts;
2808 uint8_t *data;
2809 int size;
2810 int stream_index;
2811
2812 int flags;
2813
2814 AVPacketSideData *side_data;
2815 int side_data_elems;
2816
2817 int duration;
2818 attribute_deprecated
2819 void (*destruct)(struct AVPacket *);
2820 attribute_deprecated
2821 void *priv;
2822 int64_t pos;
2823
2824 int64_t convergence_duration;
2825 } AVPacket;
2826 #define AV_PKT_FLAG_KEY 0x0001
2827 #define AV_PKT_FLAG_CORRUPT 0x0002
2828
2829 enum AVSideDataParamChangeFlags {
2830 AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = 0x0001,
2831 AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002,
2832 AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004,
2833 AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008,
2834 };
2835
2836 struct AVCodecInternal;
2837
2838 enum AVFieldOrder {
2839 AV_FIELD_UNKNOWN,
2840 AV_FIELD_PROGRESSIVE,
2841 AV_FIELD_TT,
2842 AV_FIELD_BB,
2843 AV_FIELD_TB,
2844 AV_FIELD_BT,
2845 };
2846
2847 typedef struct AVCodecContext {
2848
2849 const AVClass *av_class;
2850 int log_level_offset;
2851
2852 enum AVMediaType codec_type;
2853 const struct AVCodec *codec;
2854
2855 attribute_deprecated
2856 char codec_name[32];
2857 enum AVCodecID codec_id;
2858
2859 unsigned int codec_tag;
2860
2861 unsigned int stream_codec_tag;
2862
2863 void *priv_data;
2864
2865 struct AVCodecInternal *internal;
2866
2867 void *opaque;
2868
2869 int bit_rate;
2870
2871 int bit_rate_tolerance;
2872
2873 int global_quality;
2874
2875 int compression_level;
2876 #define FF_COMPRESSION_DEFAULT -1
2877
2878 int flags;
2879
2880 int flags2;
2881
2882 uint8_t *extradata;
2883 int extradata_size;
2884
2885 AVRational time_base;
2886
2887 int ticks_per_frame;
2888
2889 int delay;
2890
2891 int width, height;
2892
2893 int coded_width, coded_height;
2894
2895 #define FF_ASPECT_EXTENDED 15
2896
2897 int gop_size;
2898
2899 enum AVPixelFormat pix_fmt;
2900
2901 int me_method;
2902
2903 void (*draw_horiz_band)(struct AVCodecContext *s,
2904 const AVFrame *src, int offset[AV_NUM_DATA_POINTERS],
2905 int y, int type, int height);
2906
2907 enum AVPixelFormat (*get_format)(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
2908
2909 int max_b_frames;
2910
2911 float b_quant_factor;
2912
2913 int rc_strategy;
2914 #define FF_RC_STRATEGY_XVID 1
2915
2916 int b_frame_strategy;
2917
2918 float b_quant_offset;
2919
2920 int has_b_frames;
2921
2922 int mpeg_quant;
2923
2924 float i_quant_factor;
2925
2926 float i_quant_offset;
2927
2928 float lumi_masking;
2929
2930 float temporal_cplx_masking;
2931
2932 float spatial_cplx_masking;
2933
2934 float p_masking;
2935
2936 float dark_masking;
2937
2938 int slice_count;
2939
2940 int prediction_method;
2941 #define FF_PRED_LEFT 0
2942 #define FF_PRED_PLANE 1
2943 #define FF_PRED_MEDIAN 2
2944
2945 int *slice_offset;
2946
2947 AVRational sample_aspect_ratio;
2948
2949 int me_cmp;
2950
2951 int me_sub_cmp;
2952
2953 int mb_cmp;
2954
2955 int ildct_cmp;
2956 #define FF_CMP_SAD 0
2957 #define FF_CMP_SSE 1
2958 #define FF_CMP_SATD 2
2959 #define FF_CMP_DCT 3
2960 #define FF_CMP_PSNR 4
2961 #define FF_CMP_BIT 5
2962 #define FF_CMP_RD 6
2963 #define FF_CMP_ZERO 7
2964 #define FF_CMP_VSAD 8
2965 #define FF_CMP_VSSE 9
2966 #define FF_CMP_NSSE 10
2967 #define FF_CMP_W53 11
2968 #define FF_CMP_W97 12
2969 #define FF_CMP_DCTMAX 13
2970 #define FF_CMP_DCT264 14
2971 #define FF_CMP_CHROMA 256
2972
2973 int dia_size;
2974
2975 int last_predictor_count;
2976
2977 int pre_me;
2978
2979 int me_pre_cmp;
2980
2981 int pre_dia_size;
2982
2983 int me_subpel_quality;
2984
2985 int dtg_active_format;
2986 #define FF_DTG_AFD_SAME 8
2987 #define FF_DTG_AFD_4_3 9
2988 #define FF_DTG_AFD_16_9 10
2989 #define FF_DTG_AFD_14_9 11
2990 #define FF_DTG_AFD_4_3_SP_14_9 13
2991 #define FF_DTG_AFD_16_9_SP_14_9 14
2992 #define FF_DTG_AFD_SP_4_3 15
2993
2994 int me_range;
2995
2996 int intra_quant_bias;
2997 #define FF_DEFAULT_QUANT_BIAS 999999
2998
2999 int inter_quant_bias;
3000
3001 int slice_flags;
3002 #define SLICE_FLAG_CODED_ORDER 0x0001
3003 #define SLICE_FLAG_ALLOW_FIELD 0x0002
3004 #define SLICE_FLAG_ALLOW_PLANE 0x0004
3005
3006 attribute_deprecated int xvmc_acceleration;
3007
3008 int mb_decision;
3009 #define FF_MB_DECISION_SIMPLE 0
3010 #define FF_MB_DECISION_BITS 1
3011 #define FF_MB_DECISION_RD 2
3012
3013 uint16_t *intra_matrix;
3014
3015 uint16_t *inter_matrix;
3016
3017 int scenechange_threshold;
3018
3019 int noise_reduction;
3020
3021 int me_threshold;
3022
3023 int mb_threshold;
3024
3025 int intra_dc_precision;
3026
3027 int skip_top;
3028
3029 int skip_bottom;
3030
3031 float border_masking;
3032
3033 int mb_lmin;
3034
3035 int mb_lmax;
3036
3037 int me_penalty_compensation;
3038
3039 int bidir_refine;
3040
3041 int brd_scale;
3042
3043 int keyint_min;
3044
3045 int refs;
3046
3047 int chromaoffset;
3048
3049 int scenechange_factor;
3050
3051 int mv0_threshold;
3052
3053 int b_sensitivity;
3054
3055 enum AVColorPrimaries color_primaries;
3056
3057 enum AVColorTransferCharacteristic color_trc;
3058
3059 enum AVColorSpace colorspace;
3060
3061 enum AVColorRange color_range;
3062
3063 enum AVChromaLocation chroma_sample_location;
3064
3065 int slices;
3066
3067 enum AVFieldOrder field_order;
3068
3069 int sample_rate;
3070 int channels;
3071
3072 enum AVSampleFormat sample_fmt;
3073
3074 int frame_size;
3075
3076 int frame_number;
3077
3078 int block_align;
3079
3080 int cutoff;
3081
3082 attribute_deprecated int request_channels;
3083
3084 uint64_t channel_layout;
3085
3086 uint64_t request_channel_layout;
3087
3088 enum AVAudioServiceType audio_service_type;
3089
3090 enum AVSampleFormat request_sample_fmt;
3091
3092 attribute_deprecated
3093 int (*get_buffer)(struct AVCodecContext *c, AVFrame *pic);
3094
3095 attribute_deprecated
3096 void (*release_buffer)(struct AVCodecContext *c, AVFrame *pic);
3097
3098 attribute_deprecated
3099 int (*reget_buffer)(struct AVCodecContext *c, AVFrame *pic);
3100
3101 int (*get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags);
3102
3103 int refcounted_frames;
3104
3105 float qcompress;
3106 float qblur;
3107
3108 int qmin;
3109
3110 int qmax;
3111
3112 int max_qdiff;
3113
3114 float rc_qsquish;
3115
3116 float rc_qmod_amp;
3117 int rc_qmod_freq;
3118
3119 int rc_buffer_size;
3120
3121 int rc_override_count;
3122 RcOverride *rc_override;
3123
3124 const char *rc_eq;
3125
3126 int rc_max_rate;
3127
3128 int rc_min_rate;
3129
3130 float rc_buffer_aggressivity;
3131
3132 float rc_initial_cplx;
3133
3134 float rc_max_available_vbv_use;
3135
3136 float rc_min_vbv_overflow_use;
3137
3138 int rc_initial_buffer_occupancy;
3139
3140 #define FF_CODER_TYPE_VLC 0
3141 #define FF_CODER_TYPE_AC 1
3142 #define FF_CODER_TYPE_RAW 2
3143 #define FF_CODER_TYPE_RLE 3
3144 #define FF_CODER_TYPE_DEFLATE 4
3145
3146 int coder_type;
3147
3148 int context_model;
3149
3150 int lmin;
3151
3152 int lmax;
3153
3154 int frame_skip_threshold;
3155
3156 int frame_skip_factor;
3157
3158 int frame_skip_exp;
3159
3160 int frame_skip_cmp;
3161
3162 int trellis;
3163
3164 int min_prediction_order;
3165
3166 int max_prediction_order;
3167
3168 int64_t timecode_frame_start;
3169
3170 void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb);
3171
3172 int rtp_payload_size;
3173
3174 int mv_bits;
3175 int header_bits;
3176 int i_tex_bits;
3177 int p_tex_bits;
3178 int i_count;
3179 int p_count;
3180 int skip_count;
3181 int misc_bits;
3182
3183 int frame_bits;
3184
3185 char *stats_out;
3186
3187 char *stats_in;
3188
3189 int workaround_bugs;
3190 #define FF_BUG_AUTODETECT 1
3191 #define FF_BUG_OLD_MSMPEG4 2
3192 #define FF_BUG_XVID_ILACE 4
3193 #define FF_BUG_UMP4 8
3194 #define FF_BUG_NO_PADDING 16
3195 #define FF_BUG_AMV 32
3196 #define FF_BUG_AC_VLC 0
3197 #define FF_BUG_QPEL_CHROMA 64
3198 #define FF_BUG_STD_QPEL 128
3199 #define FF_BUG_QPEL_CHROMA2 256
3200 #define FF_BUG_DIRECT_BLOCKSIZE 512
3201 #define FF_BUG_EDGE 1024
3202 #define FF_BUG_HPEL_CHROMA 2048
3203 #define FF_BUG_DC_CLIP 4096
3204 #define FF_BUG_MS 8192
3205 #define FF_BUG_TRUNCATED 16384
3206
3207 int strict_std_compliance;
3208 #define FF_COMPLIANCE_VERY_STRICT 2
3209 #define FF_COMPLIANCE_STRICT 1
3210 #define FF_COMPLIANCE_NORMAL 0
3211 #define FF_COMPLIANCE_UNOFFICIAL -1
3212 #define FF_COMPLIANCE_EXPERIMENTAL -2
3213
3214 int error_concealment;
3215 #define FF_EC_GUESS_MVS 1
3216 #define FF_EC_DEBLOCK 2
3217 #define FF_EC_FAVOR_INTER 256
3218
3219 int debug;
3220 #define FF_DEBUG_PICT_INFO 1
3221 #define FF_DEBUG_RC 2
3222 #define FF_DEBUG_BITSTREAM 4
3223 #define FF_DEBUG_MB_TYPE 8
3224 #define FF_DEBUG_QP 16
3225
3226 #define FF_DEBUG_MV 32
3227 #define FF_DEBUG_DCT_COEFF 0x00000040
3228 #define FF_DEBUG_SKIP 0x00000080
3229 #define FF_DEBUG_STARTCODE 0x00000100
3230 #define FF_DEBUG_PTS 0x00000200
3231 #define FF_DEBUG_ER 0x00000400
3232 #define FF_DEBUG_MMCO 0x00000800
3233 #define FF_DEBUG_BUGS 0x00001000
3234 #define FF_DEBUG_VIS_QP 0x00002000
3235 #define FF_DEBUG_VIS_MB_TYPE 0x00004000
3236 #define FF_DEBUG_BUFFERS 0x00008000
3237 #define FF_DEBUG_THREADS 0x00010000
3238 #define FF_DEBUG_NOMC 0x01000000
3239
3240 int debug_mv;
3241 #define FF_DEBUG_VIS_MV_P_FOR 0x00000001
3242 #define FF_DEBUG_VIS_MV_B_FOR 0x00000002
3243 #define FF_DEBUG_VIS_MV_B_BACK 0x00000004
3244
3245 int err_recognition;
3246
3247 #define AV_EF_CRCCHECK (1<<0)
3248 #define AV_EF_BITSTREAM (1<<1)
3249 #define AV_EF_BUFFER (1<<2)
3250 #define AV_EF_EXPLODE (1<<3)
3251
3252 #define AV_EF_IGNORE_ERR (1<<15)
3253 #define AV_EF_CAREFUL (1<<16)
3254 #define AV_EF_COMPLIANT (1<<17)
3255 #define AV_EF_AGGRESSIVE (1<<18)
3256
3257 int64_t reordered_opaque;
3258
3259 struct AVHWAccel *hwaccel;
3260
3261 void *hwaccel_context;
3262
3263 uint64_t error[AV_NUM_DATA_POINTERS];
3264
3265 int dct_algo;
3266 #define FF_DCT_AUTO 0
3267 #define FF_DCT_FASTINT 1
3268 #define FF_DCT_INT 2
3269 #define FF_DCT_MMX 3
3270 #define FF_DCT_ALTIVEC 5
3271 #define FF_DCT_FAAN 6
3272
3273 int idct_algo;
3274 #define FF_IDCT_AUTO 0
3275 #define FF_IDCT_INT 1
3276 #define FF_IDCT_SIMPLE 2
3277 #define FF_IDCT_SIMPLEMMX 3
3278 #define FF_IDCT_ARM 7
3279 #define FF_IDCT_ALTIVEC 8
3280 #define FF_IDCT_SH4 9
3281 #define FF_IDCT_SIMPLEARM 10
3282 #define FF_IDCT_IPP 13
3283 #define FF_IDCT_XVIDMMX 14
3284 #define FF_IDCT_SIMPLEARMV5TE 16
3285 #define FF_IDCT_SIMPLEARMV6 17
3286 #define FF_IDCT_SIMPLEVIS 18
3287 #define FF_IDCT_FAAN 20
3288 #define FF_IDCT_SIMPLENEON 22
3289 #define FF_IDCT_SIMPLEALPHA 23
3290 #define FF_IDCT_SIMPLEAUTO 128
3291
3292 int bits_per_coded_sample;
3293
3294 int bits_per_raw_sample;
3295
3296 int lowres;
3297
3298 AVFrame *coded_frame;
3299
3300 int thread_count;
3301
3302 int thread_type;
3303 #define FF_THREAD_FRAME 1
3304 #define FF_THREAD_SLICE 2
3305
3306 int active_thread_type;
3307
3308 int thread_safe_callbacks;
3309
3310 int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size);
3311
3312 int (*execute2)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count);
3313
3314 attribute_deprecated
3315 void *thread_opaque;
3316
3317 int nsse_weight;
3318
3319 int profile;
3320 #define FF_PROFILE_UNKNOWN -99
3321 #define FF_PROFILE_RESERVED -100
3322
3323 #define FF_PROFILE_AAC_MAIN 0
3324 #define FF_PROFILE_AAC_LOW 1
3325 #define FF_PROFILE_AAC_SSR 2
3326 #define FF_PROFILE_AAC_LTP 3
3327 #define FF_PROFILE_AAC_HE 4
3328 #define FF_PROFILE_AAC_HE_V2 28
3329 #define FF_PROFILE_AAC_LD 22
3330 #define FF_PROFILE_AAC_ELD 38
3331 #define FF_PROFILE_MPEG2_AAC_LOW 128
3332 #define FF_PROFILE_MPEG2_AAC_HE 131
3333
3334 #define FF_PROFILE_DTS 20
3335 #define FF_PROFILE_DTS_ES 30
3336 #define FF_PROFILE_DTS_96_24 40
3337 #define FF_PROFILE_DTS_HD_HRA 50
3338 #define FF_PROFILE_DTS_HD_MA 60
3339
3340 #define FF_PROFILE_MPEG2_422 0
3341 #define FF_PROFILE_MPEG2_HIGH 1
3342 #define FF_PROFILE_MPEG2_SS 2
3343 #define FF_PROFILE_MPEG2_SNR_SCALABLE 3
3344 #define FF_PROFILE_MPEG2_MAIN 4
3345 #define FF_PROFILE_MPEG2_SIMPLE 5
3346
3347 #define FF_PROFILE_H264_CONSTRAINED (1<<9)
3348 #define FF_PROFILE_H264_INTRA (1<<11)
3349
3350 #define FF_PROFILE_H264_BASELINE 66
3351 #define FF_PROFILE_H264_CONSTRAINED_BASELINE (66|FF_PROFILE_H264_CONSTRAINED)
3352 #define FF_PROFILE_H264_MAIN 77
3353 #define FF_PROFILE_H264_EXTENDED 88
3354 #define FF_PROFILE_H264_HIGH 100
3355 #define FF_PROFILE_H264_HIGH_10 110
3356 #define FF_PROFILE_H264_HIGH_10_INTRA (110|FF_PROFILE_H264_INTRA)
3357 #define FF_PROFILE_H264_HIGH_422 122
3358 #define FF_PROFILE_H264_HIGH_422_INTRA (122|FF_PROFILE_H264_INTRA)
3359 #define FF_PROFILE_H264_HIGH_444 144
3360 #define FF_PROFILE_H264_HIGH_444_PREDICTIVE 244
3361 #define FF_PROFILE_H264_HIGH_444_INTRA (244|FF_PROFILE_H264_INTRA)
3362 #define FF_PROFILE_H264_CAVLC_444 44
3363
3364 #define FF_PROFILE_VC1_SIMPLE 0
3365 #define FF_PROFILE_VC1_MAIN 1
3366 #define FF_PROFILE_VC1_COMPLEX 2
3367 #define FF_PROFILE_VC1_ADVANCED 3
3368
3369 #define FF_PROFILE_MPEG4_SIMPLE 0
3370 #define FF_PROFILE_MPEG4_SIMPLE_SCALABLE 1
3371 #define FF_PROFILE_MPEG4_CORE 2
3372 #define FF_PROFILE_MPEG4_MAIN 3
3373 #define FF_PROFILE_MPEG4_N_BIT 4
3374 #define FF_PROFILE_MPEG4_SCALABLE_TEXTURE 5
3375 #define FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION 6
3376 #define FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE 7
3377 #define FF_PROFILE_MPEG4_HYBRID 8
3378 #define FF_PROFILE_MPEG4_ADVANCED_REAL_TIME 9
3379 #define FF_PROFILE_MPEG4_CORE_SCALABLE 10
3380 #define FF_PROFILE_MPEG4_ADVANCED_CODING 11
3381 #define FF_PROFILE_MPEG4_ADVANCED_CORE 12
3382 #define FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE 13
3383 #define FF_PROFILE_MPEG4_SIMPLE_STUDIO 14
3384 #define FF_PROFILE_MPEG4_ADVANCED_SIMPLE 15
3385
3386 #define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0 0
3387 #define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1 1
3388 #define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION 2
3389 #define FF_PROFILE_JPEG2000_DCINEMA_2K 3
3390 #define FF_PROFILE_JPEG2000_DCINEMA_4K 4
3391
3392 #define FF_PROFILE_HEVC_MAIN 1
3393 #define FF_PROFILE_HEVC_MAIN_10 2
3394 #define FF_PROFILE_HEVC_MAIN_STILL_PICTURE 3
3395 #define FF_PROFILE_HEVC_REXT 4
3396
3397 int level;
3398 #define FF_LEVEL_UNKNOWN -99
3399
3400 enum AVDiscard skip_loop_filter;
3401
3402 enum AVDiscard skip_idct;
3403
3404 enum AVDiscard skip_frame;
3405
3406 uint8_t *subtitle_header;
3407 int subtitle_header_size;
3408
3409 attribute_deprecated
3410 int error_rate;
3411
3412 attribute_deprecated
3413 AVPacket *pkt;
3414
3415 uint64_t vbv_delay;
3416
3417 int side_data_only_packets;
3418
3419 AVRational pkt_timebase;
3420
3421 const AVCodecDescriptor *codec_descriptor;
3422
3423 int64_t pts_correction_num_faulty_pts;
3424 int64_t pts_correction_num_faulty_dts;
3425 int64_t pts_correction_last_pts;
3426 int64_t pts_correction_last_dts;
3427
3428 char *sub_charenc;
3429
3430 int sub_charenc_mode;
3431 #define FF_SUB_CHARENC_MODE_DO_NOTHING -1
3432 #define FF_SUB_CHARENC_MODE_AUTOMATIC 0
3433 #define FF_SUB_CHARENC_MODE_PRE_DECODER 1
3434
3435 int skip_alpha;
3436
3437 int seek_preroll;
3438
3439 uint16_t *chroma_intra_matrix;
3440 } AVCodecContext;
3441
3442 AVRational av_codec_get_pkt_timebase (const AVCodecContext *avctx);
3443 void av_codec_set_pkt_timebase (AVCodecContext *avctx, AVRational val);
3444
3445 const AVCodecDescriptor *av_codec_get_codec_descriptor(const AVCodecContext *avctx);
3446 void av_codec_set_codec_descriptor(AVCodecContext *avctx, const AVCodecDescriptor *desc);
3447
3448 int av_codec_get_lowres(const AVCodecContext *avctx);
3449 void av_codec_set_lowres(AVCodecContext *avctx, int val);
3450
3451 int av_codec_get_seek_preroll(const AVCodecContext *avctx);
3452 void av_codec_set_seek_preroll(AVCodecContext *avctx, int val);
3453
3454 uint16_t *av_codec_get_chroma_intra_matrix(const AVCodecContext *avctx);
3455 void av_codec_set_chroma_intra_matrix(AVCodecContext *avctx, uint16_t *val);
3456
3457 typedef struct AVProfile {
3458 int profile;
3459 const char *name;
3460 } AVProfile;
3461
3462 typedef struct AVCodecDefault AVCodecDefault;
3463
3464 struct AVSubtitle;
3465
3466 typedef struct AVCodec {
3467
3468 const char *name;
3469
3470 const char *long_name;
3471 enum AVMediaType type;
3472 enum AVCodecID id;
3473
3474 int capabilities;
3475 const AVRational *supported_framerates;
3476 const enum AVPixelFormat *pix_fmts;
3477 const int *supported_samplerates;
3478 const enum AVSampleFormat *sample_fmts;
3479 const uint64_t *channel_layouts;
3480 uint8_t max_lowres;
3481 const AVClass *priv_class;
3482 const AVProfile *profiles;
3483
3484 int priv_data_size;
3485 struct AVCodec *next;
3486
3487 int (*init_thread_copy)(AVCodecContext *);
3488
3489 int (*update_thread_context)(AVCodecContext *dst, const AVCodecContext *src);
3490
3491 const AVCodecDefault *defaults;
3492
3493 void (*init_static_data)(struct AVCodec *codec);
3494
3495 int (*init)(AVCodecContext *);
3496 int (*encode_sub)(AVCodecContext *, uint8_t *buf, int buf_size,
3497 const struct AVSubtitle *sub);
3498
3499 int (*encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame,
3500 int *got_packet_ptr);
3501 int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt);
3502 int (*close)(AVCodecContext *);
3503
3504 void (*flush)(AVCodecContext *);
3505 } AVCodec;
3506
3507 int av_codec_get_max_lowres(const AVCodec *codec);
3508
3509 struct MpegEncContext;
3510
3511 typedef struct AVHWAccel {
3512
3513 const char *name;
3514
3515 enum AVMediaType type;
3516
3517 enum AVCodecID id;
3518
3519 enum AVPixelFormat pix_fmt;
3520
3521 int capabilities;
3522
3523 struct AVHWAccel *next;
3524
3525 int (*alloc_frame)(AVCodecContext *avctx, AVFrame *frame);
3526
3527 int (*start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);
3528
3529 int (*decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);
3530
3531 int (*end_frame)(AVCodecContext *avctx);
3532
3533 int frame_priv_data_size;
3534
3535 void (*decode_mb)(struct MpegEncContext *s);
3536
3537 int (*init)(AVCodecContext *avctx);
3538
3539 int (*uninit)(AVCodecContext *avctx);
3540
3541 int priv_data_size;
3542 } AVHWAccel;
3543
3544 typedef struct AVPicture {
3545 uint8_t *data[AV_NUM_DATA_POINTERS];
3546 int linesize[AV_NUM_DATA_POINTERS];
3547 } AVPicture;
3548
3549 enum AVSubtitleType {
3550 SUBTITLE_NONE,
3551
3552 SUBTITLE_BITMAP,
3553
3554 SUBTITLE_TEXT,
3555
3556 SUBTITLE_ASS,
3557 };
3558
3559 #define AV_SUBTITLE_FLAG_FORCED 0x00000001
3560
3561 typedef struct AVSubtitleRect {
3562 int x;
3563 int y;
3564 int w;
3565 int h;
3566 int nb_colors;
3567
3568 AVPicture pict;
3569 enum AVSubtitleType type;
3570
3571 char *text;
3572
3573 char *ass;
3574
3575 int flags;
3576 } AVSubtitleRect;
3577
3578 typedef struct AVSubtitle {
3579 uint16_t format;
3580 uint32_t start_display_time;
3581 uint32_t end_display_time;
3582 unsigned num_rects;
3583 AVSubtitleRect **rects;
3584 int64_t pts;
3585 } AVSubtitle;
3586
3587 AVCodec *av_codec_next(const AVCodec *c);
3588
3589 unsigned avcodec_version(void);
3590
3591 const char *avcodec_configuration(void);
3592
3593 const char *avcodec_license(void);
3594
3595 void avcodec_register(AVCodec *codec);
3596
3597 void avcodec_register_all(void);
3598
3599 AVCodecContext *avcodec_alloc_context3(const AVCodec *codec);
3600
3601 void avcodec_free_context(AVCodecContext **avctx);
3602
3603 int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec);
3604
3605 const AVClass *avcodec_get_class(void);
3606
3607 const AVClass *avcodec_get_frame_class(void);
3608
3609 const AVClass *avcodec_get_subtitle_rect_class(void);
3610
3611 int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src);
3612
3613 attribute_deprecated
3614 AVFrame *avcodec_alloc_frame(void);
3615
3616 attribute_deprecated
3617 void avcodec_get_frame_defaults(AVFrame *frame);
3618
3619 attribute_deprecated
3620 void avcodec_free_frame(AVFrame **frame);
3621
3622 int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);
3623
3624 int avcodec_close(AVCodecContext *avctx);
3625
3626 void avsubtitle_free(AVSubtitle *sub);
3627
3628 attribute_deprecated
3629 void av_destruct_packet(AVPacket *pkt);
3630
3631 void av_init_packet(AVPacket *pkt);
3632
3633 int av_new_packet(AVPacket *pkt, int size);
3634
3635 void av_shrink_packet(AVPacket *pkt, int size);
3636
3637 int av_grow_packet(AVPacket *pkt, int grow_by);
3638
3639 int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);
3640
3641 int av_dup_packet(AVPacket *pkt);
3642
3643 int av_copy_packet(AVPacket *dst, const AVPacket *src);
3644
3645 int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src);
3646
3647 void av_free_packet(AVPacket *pkt);
3648
3649 uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
3650 int size);
3651
3652 int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
3653 int size);
3654
3655 uint8_t* av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
3656 int *size);
3657
3658 int av_packet_merge_side_data(AVPacket *pkt);
3659
3660 int av_packet_split_side_data(AVPacket *pkt);
3661
3662 uint8_t *av_packet_pack_dictionary(AVDictionary *dict, int *size);
3663
3664 int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict);
3665
3666 void av_packet_free_side_data(AVPacket *pkt);
3667
3668 int av_packet_ref(AVPacket *dst, const AVPacket *src);
3669
3670 void av_packet_unref(AVPacket *pkt);
3671
3672 void av_packet_move_ref(AVPacket *dst, AVPacket *src);
3673
3674 int av_packet_copy_props(AVPacket *dst, const AVPacket *src);
3675
3676 void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst);
3677
3678 AVCodec *avcodec_find_decoder(enum AVCodecID id);
3679
3680 AVCodec *avcodec_find_decoder_by_name(const char *name);
3681
3682 attribute_deprecated int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic);
3683 attribute_deprecated void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic);
3684 attribute_deprecated int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic);
3685
3686 int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags);
3687
3688 attribute_deprecated
3689 unsigned avcodec_get_edge_width(void);
3690
3691 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height);
3692
3693 void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
3694 int linesize_align[AV_NUM_DATA_POINTERS]);
3695
3696 int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos);
3697
3698 enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos);
3699
3700 attribute_deprecated int avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples,
3701 int *frame_size_ptr,
3702 AVPacket *avpkt);
3703
3704 int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame,
3705 int *got_frame_ptr, const AVPacket *avpkt);
3706
3707 int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
3708 int *got_picture_ptr,
3709 const AVPacket *avpkt);
3710
3711 int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
3712 int *got_sub_ptr,
3713 AVPacket *avpkt);
3714
3715 enum AVPictureStructure {
3716 AV_PICTURE_STRUCTURE_UNKNOWN,
3717 AV_PICTURE_STRUCTURE_TOP_FIELD,
3718 AV_PICTURE_STRUCTURE_BOTTOM_FIELD,
3719 AV_PICTURE_STRUCTURE_FRAME,
3720 };
3721
3722 typedef struct AVCodecParserContext {
3723 void *priv_data;
3724 struct AVCodecParser *parser;
3725 int64_t frame_offset;
3726 int64_t cur_offset;
3727
3728 int64_t next_frame_offset;
3729
3730 int pict_type;
3731
3732 int repeat_pict;
3733 int64_t pts;
3734 int64_t dts;
3735
3736 int64_t last_pts;
3737 int64_t last_dts;
3738 int fetch_timestamp;
3739
3740 #define AV_PARSER_PTS_NB 4
3741 int cur_frame_start_index;
3742 int64_t cur_frame_offset[AV_PARSER_PTS_NB];
3743 int64_t cur_frame_pts[AV_PARSER_PTS_NB];
3744 int64_t cur_frame_dts[AV_PARSER_PTS_NB];
3745
3746 int flags;
3747 #define PARSER_FLAG_COMPLETE_FRAMES 0x0001
3748 #define PARSER_FLAG_ONCE 0x0002
3749
3750 #define PARSER_FLAG_FETCHED_OFFSET 0x0004
3751 #define PARSER_FLAG_USE_CODEC_TS 0x1000
3752
3753 int64_t offset;
3754 int64_t cur_frame_end[AV_PARSER_PTS_NB];
3755
3756 int key_frame;
3757
3758 int64_t convergence_duration;
3759
3760 int dts_sync_point;
3761
3762 int dts_ref_dts_delta;
3763
3764 int pts_dts_delta;
3765
3766 int64_t cur_frame_pos[AV_PARSER_PTS_NB];
3767
3768 int64_t pos;
3769
3770 int64_t last_pos;
3771
3772 int duration;
3773
3774 enum AVFieldOrder field_order;
3775
3776 enum AVPictureStructure picture_structure;
3777
3778 int output_picture_number;
3779 } AVCodecParserContext;
3780
3781 typedef struct AVCodecParser {
3782 int codec_ids[5];
3783 int priv_data_size;
3784 int (*parser_init)(AVCodecParserContext *s);
3785 int (*parser_parse)(AVCodecParserContext *s,
3786 AVCodecContext *avctx,
3787 const uint8_t **poutbuf, int *poutbuf_size,
3788 const uint8_t *buf, int buf_size);
3789 void (*parser_close)(AVCodecParserContext *s);
3790 int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size);
3791 struct AVCodecParser *next;
3792 } AVCodecParser;
3793
3794 AVCodecParser *av_parser_next(AVCodecParser *c);
3795
3796 void av_register_codec_parser(AVCodecParser *parser);
3797 AVCodecParserContext *av_parser_init(int codec_id);
3798
3799 int av_parser_parse2(AVCodecParserContext *s,
3800 AVCodecContext *avctx,
3801 uint8_t **poutbuf, int *poutbuf_size,
3802 const uint8_t *buf, int buf_size,
3803 int64_t pts, int64_t dts,
3804 int64_t pos);
3805
3806 int av_parser_change(AVCodecParserContext *s,
3807 AVCodecContext *avctx,
3808 uint8_t **poutbuf, int *poutbuf_size,
3809 const uint8_t *buf, int buf_size, int keyframe);
3810 void av_parser_close(AVCodecParserContext *s);
3811
3812 AVCodec *avcodec_find_encoder(enum AVCodecID id);
3813
3814 AVCodec *avcodec_find_encoder_by_name(const char *name);
3815
3816 int attribute_deprecated avcodec_encode_audio(AVCodecContext *avctx,
3817 uint8_t *buf, int buf_size,
3818 const short *samples);
3819
3820 int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt,
3821 const AVFrame *frame, int *got_packet_ptr);
3822
3823 attribute_deprecated
3824 int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,
3825 const AVFrame *pict);
3826
3827 int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt,
3828 const AVFrame *frame, int *got_packet_ptr);
3829
3830 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
3831 const AVSubtitle *sub);
3832
3833 struct ReSampleContext;
3834 struct AVResampleContext;
3835
3836 typedef struct ReSampleContext ReSampleContext;
3837
3838 attribute_deprecated
3839 ReSampleContext *av_audio_resample_init(int output_channels, int input_channels,
3840 int output_rate, int input_rate,
3841 enum AVSampleFormat sample_fmt_out,
3842 enum AVSampleFormat sample_fmt_in,
3843 int filter_length, int log2_phase_count,
3844 int linear, double cutoff);
3845
3846 attribute_deprecated
3847 int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples);
3848
3849 attribute_deprecated
3850 void audio_resample_close(ReSampleContext *s);
3851
3852 attribute_deprecated
3853 struct AVResampleContext *av_resample_init(int out_rate, int in_rate, int filter_length, int log2_phase_count, int linear, double cutoff);
3854
3855 attribute_deprecated
3856 int av_resample(struct AVResampleContext *c, short *dst, short *src, int *consumed, int src_size, int dst_size, int update_ctx);
3857
3858 attribute_deprecated
3859 void av_resample_compensate(struct AVResampleContext *c, int sample_delta, int compensation_distance);
3860 attribute_deprecated
3861 void av_resample_close(struct AVResampleContext *c);
3862
3863 int avpicture_alloc(AVPicture *picture, enum AVPixelFormat pix_fmt, int width, int height);
3864
3865 void avpicture_free(AVPicture *picture);
3866
3867 int avpicture_fill(AVPicture *picture, const uint8_t *ptr,
3868 enum AVPixelFormat pix_fmt, int width, int height);
3869
3870 int avpicture_layout(const AVPicture *src, enum AVPixelFormat pix_fmt,
3871 int width, int height,
3872 unsigned char *dest, int dest_size);
3873
3874 int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);
3875
3876 attribute_deprecated
3877 int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
3878 enum AVPixelFormat pix_fmt, int width, int height);
3879
3880 void av_picture_copy(AVPicture *dst, const AVPicture *src,
3881 enum AVPixelFormat pix_fmt, int width, int height);
3882
3883 int av_picture_crop(AVPicture *dst, const AVPicture *src,
3884 enum AVPixelFormat pix_fmt, int top_band, int left_band);
3885
3886 int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, enum AVPixelFormat pix_fmt,
3887 int padtop, int padbottom, int padleft, int padright, int *color);
3888
3889 void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift);
3890
3891 unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt);
3892
3893 int avcodec_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt, enum AVPixelFormat src_pix_fmt,
3894 int has_alpha);
3895
3896 enum AVPixelFormat avcodec_find_best_pix_fmt_of_list(const enum AVPixelFormat *pix_fmt_list,
3897 enum AVPixelFormat src_pix_fmt,
3898 int has_alpha, int *loss_ptr);
3899
3900 enum AVPixelFormat avcodec_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
3901 enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
3902
3903 attribute_deprecated
3904 enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
3905 enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
3906
3907 enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
3908
3909 attribute_deprecated
3910 void avcodec_set_dimensions(AVCodecContext *s, int width, int height);
3911
3912 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag);
3913
3914 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode);
3915
3916 const char *av_get_profile_name(const AVCodec *codec, int profile);
3917
3918 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size);
3919 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int, int),void *arg, int *ret, int count);
3920
3921 int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
3922 enum AVSampleFormat sample_fmt, const uint8_t *buf,
3923 int buf_size, int align);
3924
3925 void avcodec_flush_buffers(AVCodecContext *avctx);
3926
3927 int av_get_bits_per_sample(enum AVCodecID codec_id);
3928
3929 enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be);
3930
3931 int av_get_exact_bits_per_sample(enum AVCodecID codec_id);
3932
3933 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes);
3934
3935 typedef struct AVBitStreamFilterContext {
3936 void *priv_data;
3937 struct AVBitStreamFilter *filter;
3938 AVCodecParserContext *parser;
3939 struct AVBitStreamFilterContext *next;
3940 } AVBitStreamFilterContext;
3941
3942 typedef struct AVBitStreamFilter {
3943 const char *name;
3944 int priv_data_size;
3945 int (*filter)(AVBitStreamFilterContext *bsfc,
3946 AVCodecContext *avctx, const char *args,
3947 uint8_t **poutbuf, int *poutbuf_size,
3948 const uint8_t *buf, int buf_size, int keyframe);
3949 void (*close)(AVBitStreamFilterContext *bsfc);
3950 struct AVBitStreamFilter *next;
3951 } AVBitStreamFilter;
3952
3953 void av_register_bitstream_filter(AVBitStreamFilter *bsf);
3954
3955 AVBitStreamFilterContext *av_bitstream_filter_init(const char *name);
3956
3957 int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc,
3958 AVCodecContext *avctx, const char *args,
3959 uint8_t **poutbuf, int *poutbuf_size,
3960 const uint8_t *buf, int buf_size, int keyframe);
3961
3962 void av_bitstream_filter_close(AVBitStreamFilterContext *bsf);
3963
3964 AVBitStreamFilter *av_bitstream_filter_next(AVBitStreamFilter *f);
3965
3966 void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size);
3967
3968 void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size);
3969
3970 unsigned int av_xiphlacing(unsigned char *s, unsigned int v);
3971
3972 attribute_deprecated
3973 void av_log_missing_feature(void *avc, const char *feature, int want_sample);
3974
3975 attribute_deprecated
3976 void av_log_ask_for_sample(void *avc, const char *msg, ...) av_printf_format(2, 3);
3977
3978 void av_register_hwaccel(AVHWAccel *hwaccel);
3979
3980 AVHWAccel *av_hwaccel_next(AVHWAccel *hwaccel);
3981
3982 enum AVLockOp {
3983 AV_LOCK_CREATE,
3984 AV_LOCK_OBTAIN,
3985 AV_LOCK_RELEASE,
3986 AV_LOCK_DESTROY,
3987 };
3988
3989 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op));
3990
3991 enum AVMediaType avcodec_get_type(enum AVCodecID codec_id);
3992
3993 const char *avcodec_get_name(enum AVCodecID id);
3994
3995 int avcodec_is_open(AVCodecContext *s);
3996
3997 int av_codec_is_encoder(const AVCodec *codec);
3998
3999 int av_codec_is_decoder(const AVCodec *codec);
4000
4001 const AVCodecDescriptor *avcodec_descriptor_get(enum AVCodecID id);
4002
4003 const AVCodecDescriptor *avcodec_descriptor_next(const AVCodecDescriptor *prev);
4004
4005 const AVCodecDescriptor *avcodec_descriptor_get_by_name(const char *name);
4006
4007 #define AVFORMAT_AVFORMAT_H
4008
4009 #define AVFORMAT_AVIO_H
4010
4011 #define AVFORMAT_VERSION_H
4012
4013 #define LIBAVFORMAT_VERSION_MAJOR 55
4014 #define LIBAVFORMAT_VERSION_MINOR 48
4015 #define LIBAVFORMAT_VERSION_MICRO 100
4016
4017 #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
4018 LIBAVFORMAT_VERSION_MINOR, \
4019 LIBAVFORMAT_VERSION_MICRO)
4020 #define LIBAVFORMAT_VERSION AV_VERSION(LIBAVFORMAT_VERSION_MAJOR, \
4021 LIBAVFORMAT_VERSION_MINOR, \
4022 LIBAVFORMAT_VERSION_MICRO)
4023 #define LIBAVFORMAT_BUILD LIBAVFORMAT_VERSION_INT
4024
4025 #define LIBAVFORMAT_IDENT "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION)
4026
4027 #define FF_API_REFERENCE_DTS (LIBAVFORMAT_VERSION_MAJOR < 56)
4028 #define FF_API_LAVF_BITEXACT (LIBAVFORMAT_VERSION_MAJOR < 56)
4029 #define FF_API_LAVF_FRAC (LIBAVFORMAT_VERSION_MAJOR < 57)
4030 #define FF_API_LAVF_CODEC_TB (LIBAVFORMAT_VERSION_MAJOR < 57)
4031
4032 #define FF_API_ALLOC_OUTPUT_CONTEXT (LIBAVFORMAT_VERSION_MAJOR < 56)
4033 #define FF_API_FORMAT_PARAMETERS (LIBAVFORMAT_VERSION_MAJOR < 56)
4034 #define FF_API_NEW_STREAM (LIBAVFORMAT_VERSION_MAJOR < 56)
4035 #define FF_API_SET_PTS_INFO (LIBAVFORMAT_VERSION_MAJOR < 56)
4036 #define FF_API_CLOSE_INPUT_FILE (LIBAVFORMAT_VERSION_MAJOR < 56)
4037 #define FF_API_READ_PACKET (LIBAVFORMAT_VERSION_MAJOR < 56)
4038 #define FF_API_ASS_SSA (LIBAVFORMAT_VERSION_MAJOR < 56)
4039 #define FF_API_R_FRAME_RATE 1
4040
4041 #define AVIO_SEEKABLE_NORMAL 0x0001
4042
4043 typedef struct AVIOInterruptCB {
4044 int (*callback)(void*);
4045 void *opaque;
4046 } AVIOInterruptCB;
4047
4048 typedef struct AVIOContext {
4049
4050 const AVClass *av_class;
4051 unsigned char *buffer;
4052 int buffer_size;
4053 unsigned char *buf_ptr;
4054 unsigned char *buf_end;
4055
4056 void *opaque;
4057
4058 int (*read_packet)(void *opaque, uint8_t *buf, int buf_size);
4059 int (*write_packet)(void *opaque, uint8_t *buf, int buf_size);
4060 int64_t (*seek)(void *opaque, int64_t offset, int whence);
4061 int64_t pos;
4062 int must_flush;
4063 int eof_reached;
4064 int write_flag;
4065 int max_packet_size;
4066 unsigned long checksum;
4067 unsigned char *checksum_ptr;
4068 unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size);
4069 int error;
4070
4071 int (*read_pause)(void *opaque, int pause);
4072
4073 int64_t (*read_seek)(void *opaque, int stream_index,
4074 int64_t timestamp, int flags);
4075
4076 int seekable;
4077
4078 int64_t maxsize;
4079
4080 int direct;
4081
4082 int64_t bytes_read;
4083
4084 int seek_count;
4085
4086 int writeout_count;
4087
4088 int orig_buffer_size;
4089 } AVIOContext;
4090
4091 const char *avio_find_protocol_name(const char *url);
4092
4093 int avio_check(const char *url, int flags);
4094
4095 AVIOContext *avio_alloc_context(
4096 unsigned char *buffer,
4097 int buffer_size,
4098 int write_flag,
4099 void *opaque,
4100 int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
4101 int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
4102 int64_t (*seek)(void *opaque, int64_t offset, int whence));
4103
4104 void avio_w8(AVIOContext *s, int b);
4105 void avio_write(AVIOContext *s, const unsigned char *buf, int size);
4106 void avio_wl64(AVIOContext *s, uint64_t val);
4107 void avio_wb64(AVIOContext *s, uint64_t val);
4108 void avio_wl32(AVIOContext *s, unsigned int val);
4109 void avio_wb32(AVIOContext *s, unsigned int val);
4110 void avio_wl24(AVIOContext *s, unsigned int val);
4111 void avio_wb24(AVIOContext *s, unsigned int val);
4112 void avio_wl16(AVIOContext *s, unsigned int val);
4113 void avio_wb16(AVIOContext *s, unsigned int val);
4114
4115 int avio_put_str(AVIOContext *s, const char *str);
4116
4117 int avio_put_str16le(AVIOContext *s, const char *str);
4118
4119 #define AVSEEK_SIZE 0x10000
4120
4121 #define AVSEEK_FORCE 0x20000
4122
4123 int64_t avio_seek(AVIOContext *s, int64_t offset, int whence);
4124
4125 int64_t avio_skip(AVIOContext *s, int64_t offset);
4126
avio_tell(AVIOContext * s)4127 static av_always_inline int64_t avio_tell(AVIOContext *s)
4128 {
4129 return avio_seek(s, 0, SEEK_CUR);
4130 }
4131
4132 int64_t avio_size(AVIOContext *s);
4133
4134 int url_feof(AVIOContext *s);
4135
4136 int avio_printf(AVIOContext *s, const char *fmt, ...) av_printf_format(2, 3);
4137
4138 void avio_flush(AVIOContext *s);
4139
4140 int avio_read(AVIOContext *s, unsigned char *buf, int size);
4141
4142 int avio_r8 (AVIOContext *s);
4143 unsigned int avio_rl16(AVIOContext *s);
4144 unsigned int avio_rl24(AVIOContext *s);
4145 unsigned int avio_rl32(AVIOContext *s);
4146 uint64_t avio_rl64(AVIOContext *s);
4147 unsigned int avio_rb16(AVIOContext *s);
4148 unsigned int avio_rb24(AVIOContext *s);
4149 unsigned int avio_rb32(AVIOContext *s);
4150 uint64_t avio_rb64(AVIOContext *s);
4151
4152 int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen);
4153
4154 int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen);
4155 int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen);
4156
4157 #define AVIO_FLAG_READ 1
4158 #define AVIO_FLAG_WRITE 2
4159 #define AVIO_FLAG_READ_WRITE (AVIO_FLAG_READ|AVIO_FLAG_WRITE)
4160
4161 #define AVIO_FLAG_NONBLOCK 8
4162
4163 #define AVIO_FLAG_DIRECT 0x8000
4164
4165 int avio_open(AVIOContext **s, const char *url, int flags);
4166
4167 int avio_open2(AVIOContext **s, const char *url, int flags,
4168 const AVIOInterruptCB *int_cb, AVDictionary **options);
4169
4170 int avio_close(AVIOContext *s);
4171
4172 int avio_closep(AVIOContext **s);
4173
4174 int avio_open_dyn_buf(AVIOContext **s);
4175
4176 int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
4177
4178 const char *avio_enum_protocols(void **opaque, int output);
4179
4180 int avio_pause(AVIOContext *h, int pause);
4181
4182 int64_t avio_seek_time(AVIOContext *h, int stream_index,
4183 int64_t timestamp, int flags);
4184
4185 struct AVFormatContext;
4186
4187 struct AVDeviceInfoList;
4188 struct AVDeviceCapabilitiesQuery;
4189
4190 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size);
4191
4192 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size);
4193
4194 typedef struct AVFrac {
4195 int64_t val, num, den;
4196 } AVFrac;
4197
4198 struct AVCodecTag;
4199
4200 typedef struct AVProbeData {
4201 const char *filename;
4202 unsigned char *buf;
4203 int buf_size;
4204 } AVProbeData;
4205
4206 #define AVPROBE_SCORE_RETRY (AVPROBE_SCORE_MAX/4)
4207 #define AVPROBE_SCORE_STREAM_RETRY (AVPROBE_SCORE_MAX/4-1)
4208
4209 #define AVPROBE_SCORE_EXTENSION 50
4210 #define AVPROBE_SCORE_MAX 100
4211
4212 #define AVPROBE_PADDING_SIZE 32
4213
4214 #define AVFMT_NOFILE 0x0001
4215 #define AVFMT_NEEDNUMBER 0x0002
4216 #define AVFMT_SHOW_IDS 0x0008
4217 #define AVFMT_RAWPICTURE 0x0020
4218
4219 #define AVFMT_GLOBALHEADER 0x0040
4220 #define AVFMT_NOTIMESTAMPS 0x0080
4221 #define AVFMT_GENERIC_INDEX 0x0100
4222 #define AVFMT_TS_DISCONT 0x0200
4223 #define AVFMT_VARIABLE_FPS 0x0400
4224 #define AVFMT_NODIMENSIONS 0x0800
4225 #define AVFMT_NOSTREAMS 0x1000
4226 #define AVFMT_NOBINSEARCH 0x2000
4227 #define AVFMT_NOGENSEARCH 0x4000
4228 #define AVFMT_NO_BYTE_SEEK 0x8000
4229 #define AVFMT_ALLOW_FLUSH 0x10000
4230 #define AVFMT_TS_NONSTRICT 0x20000
4231
4232 #define AVFMT_TS_NEGATIVE 0x40000
4233
4234 #define AVFMT_SEEK_TO_PTS 0x4000000
4235
4236 typedef struct AVOutputFormat {
4237 const char *name;
4238
4239 const char *long_name;
4240 const char *mime_type;
4241 const char *extensions;
4242
4243 enum AVCodecID audio_codec;
4244 enum AVCodecID video_codec;
4245 enum AVCodecID subtitle_codec;
4246
4247 int flags;
4248
4249 const struct AVCodecTag * const *codec_tag;
4250
4251 const AVClass *priv_class;
4252
4253 struct AVOutputFormat *next;
4254
4255 int priv_data_size;
4256
4257 int (*write_header)(struct AVFormatContext *);
4258
4259 int (*write_packet)(struct AVFormatContext *, AVPacket *pkt);
4260 int (*write_trailer)(struct AVFormatContext *);
4261
4262 int (*interleave_packet)(struct AVFormatContext *, AVPacket *out,
4263 AVPacket *in, int flush);
4264
4265 int (*query_codec)(enum AVCodecID id, int std_compliance);
4266
4267 void (*get_output_timestamp)(struct AVFormatContext *s, int stream,
4268 int64_t *dts, int64_t *wall);
4269
4270 int (*control_message)(struct AVFormatContext *s, int type,
4271 void *data, size_t data_size);
4272
4273 int (*write_uncoded_frame)(struct AVFormatContext *, int stream_index,
4274 AVFrame **frame, unsigned flags);
4275
4276 int (*get_device_list)(struct AVFormatContext *s, struct AVDeviceInfoList *device_list);
4277
4278 int (*create_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
4279
4280 int (*free_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
4281 } AVOutputFormat;
4282
4283 typedef struct AVInputFormat {
4284
4285 const char *name;
4286
4287 const char *long_name;
4288
4289 int flags;
4290
4291 const char *extensions;
4292
4293 const struct AVCodecTag * const *codec_tag;
4294
4295 const AVClass *priv_class;
4296
4297 struct AVInputFormat *next;
4298
4299 int raw_codec_id;
4300
4301 int priv_data_size;
4302
4303 int (*read_probe)(AVProbeData *);
4304
4305 int (*read_header)(struct AVFormatContext *);
4306
4307 int (*read_packet)(struct AVFormatContext *, AVPacket *pkt);
4308
4309 int (*read_close)(struct AVFormatContext *);
4310
4311 int (*read_seek)(struct AVFormatContext *,
4312 int stream_index, int64_t timestamp, int flags);
4313
4314 int64_t (*read_timestamp)(struct AVFormatContext *s, int stream_index,
4315 int64_t *pos, int64_t pos_limit);
4316
4317 int (*read_play)(struct AVFormatContext *);
4318
4319 int (*read_pause)(struct AVFormatContext *);
4320
4321 int (*read_seek2)(struct AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags);
4322
4323 int (*get_device_list)(struct AVFormatContext *s, struct AVDeviceInfoList *device_list);
4324
4325 int (*create_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
4326
4327 int (*free_device_capabilities)(struct AVFormatContext *s, struct AVDeviceCapabilitiesQuery *caps);
4328 } AVInputFormat;
4329
4330 enum AVStreamParseType {
4331 AVSTREAM_PARSE_NONE,
4332 AVSTREAM_PARSE_FULL,
4333 AVSTREAM_PARSE_HEADERS,
4334 AVSTREAM_PARSE_TIMESTAMPS,
4335 AVSTREAM_PARSE_FULL_ONCE,
4336 AVSTREAM_PARSE_FULL_RAW=MKTAG(0,'R','A','W'),
4337
4338 };
4339
4340 typedef struct AVIndexEntry {
4341 int64_t pos;
4342 int64_t timestamp;
4343
4344 #define AVINDEX_KEYFRAME 0x0001
4345 int flags:2;
4346 int size:30;
4347 int min_distance;
4348 } AVIndexEntry;
4349
4350 #define AV_DISPOSITION_DEFAULT 0x0001
4351 #define AV_DISPOSITION_DUB 0x0002
4352 #define AV_DISPOSITION_ORIGINAL 0x0004
4353 #define AV_DISPOSITION_COMMENT 0x0008
4354 #define AV_DISPOSITION_LYRICS 0x0010
4355 #define AV_DISPOSITION_KARAOKE 0x0020
4356
4357 #define AV_DISPOSITION_FORCED 0x0040
4358 #define AV_DISPOSITION_HEARING_IMPAIRED 0x0080
4359 #define AV_DISPOSITION_VISUAL_IMPAIRED 0x0100
4360 #define AV_DISPOSITION_CLEAN_EFFECTS 0x0200
4361
4362 #define AV_DISPOSITION_ATTACHED_PIC 0x0400
4363
4364 #define AV_DISPOSITION_CAPTIONS 0x10000
4365 #define AV_DISPOSITION_DESCRIPTIONS 0x20000
4366 #define AV_DISPOSITION_METADATA 0x40000
4367
4368 #define AV_PTS_WRAP_IGNORE 0
4369 #define AV_PTS_WRAP_ADD_OFFSET 1
4370 #define AV_PTS_WRAP_SUB_OFFSET -1
4371
4372 typedef struct AVStream {
4373 int index;
4374
4375 int id;
4376
4377 AVCodecContext *codec;
4378 void *priv_data;
4379
4380 attribute_deprecated
4381 struct AVFrac pts;
4382
4383 AVRational time_base;
4384
4385 int64_t start_time;
4386
4387 int64_t duration;
4388
4389 int64_t nb_frames;
4390
4391 int disposition;
4392
4393 enum AVDiscard discard;
4394
4395 AVRational sample_aspect_ratio;
4396
4397 AVDictionary *metadata;
4398
4399 AVRational avg_frame_rate;
4400
4401 AVPacket attached_pic;
4402
4403 AVPacketSideData *side_data;
4404
4405 int nb_side_data;
4406
4407 #define MAX_STD_TIMEBASES (60*12+6)
4408 struct {
4409 int64_t last_dts;
4410 int64_t duration_gcd;
4411 int duration_count;
4412 int64_t rfps_duration_sum;
4413 double (*duration_error)[2][MAX_STD_TIMEBASES];
4414 int64_t codec_info_duration;
4415 int64_t codec_info_duration_fields;
4416
4417 int found_decoder;
4418
4419 int64_t last_duration;
4420
4421 int64_t fps_first_dts;
4422 int fps_first_dts_idx;
4423 int64_t fps_last_dts;
4424 int fps_last_dts_idx;
4425
4426 } *info;
4427
4428 int pts_wrap_bits;
4429
4430 int64_t do_not_use;
4431
4432 int64_t first_dts;
4433 int64_t cur_dts;
4434 int64_t last_IP_pts;
4435 int last_IP_duration;
4436
4437 #define MAX_PROBE_PACKETS 2500
4438 int probe_packets;
4439
4440 int codec_info_nb_frames;
4441
4442 enum AVStreamParseType need_parsing;
4443 struct AVCodecParserContext *parser;
4444
4445 struct AVPacketList *last_in_packet_buffer;
4446 AVProbeData probe_data;
4447 #define MAX_REORDER_DELAY 16
4448 int64_t pts_buffer[MAX_REORDER_DELAY+1];
4449
4450 AVIndexEntry *index_entries;
4451
4452 int nb_index_entries;
4453 unsigned int index_entries_allocated_size;
4454
4455 AVRational r_frame_rate;
4456
4457 int stream_identifier;
4458
4459 int64_t interleaver_chunk_size;
4460 int64_t interleaver_chunk_duration;
4461
4462 int request_probe;
4463
4464 int skip_to_keyframe;
4465
4466 int skip_samples;
4467
4468 int nb_decoded_frames;
4469
4470 int64_t mux_ts_offset;
4471
4472 int64_t pts_wrap_reference;
4473
4474 int pts_wrap_behavior;
4475
4476 int update_initial_durations_done;
4477
4478 int64_t pts_reorder_error[MAX_REORDER_DELAY+1];
4479 uint8_t pts_reorder_error_count[MAX_REORDER_DELAY+1];
4480
4481 int64_t last_dts_for_order_check;
4482 uint8_t dts_ordered;
4483 uint8_t dts_misordered;
4484
4485 int inject_global_side_data;
4486
4487 } AVStream;
4488
4489 AVRational av_stream_get_r_frame_rate(const AVStream *s);
4490 void av_stream_set_r_frame_rate(AVStream *s, AVRational r);
4491 struct AVCodecParserContext *av_stream_get_parser(const AVStream *s);
4492
4493 int64_t av_stream_get_end_pts(const AVStream *st);
4494
4495 #define AV_PROGRAM_RUNNING 1
4496
4497 typedef struct AVProgram {
4498 int id;
4499 int flags;
4500 enum AVDiscard discard;
4501 unsigned int *stream_index;
4502 unsigned int nb_stream_indexes;
4503 AVDictionary *metadata;
4504
4505 int program_num;
4506 int pmt_pid;
4507 int pcr_pid;
4508
4509 int64_t start_time;
4510 int64_t end_time;
4511
4512 int64_t pts_wrap_reference;
4513 int pts_wrap_behavior;
4514 } AVProgram;
4515
4516 #define AVFMTCTX_NOHEADER 0x0001
4517
4518 typedef struct AVChapter {
4519 int id;
4520 AVRational time_base;
4521 int64_t start, end;
4522 AVDictionary *metadata;
4523 } AVChapter;
4524
4525 typedef int (*av_format_control_message)(struct AVFormatContext *s, int type,
4526 void *data, size_t data_size);
4527
4528 enum AVDurationEstimationMethod {
4529 AVFMT_DURATION_FROM_PTS,
4530 AVFMT_DURATION_FROM_STREAM,
4531 AVFMT_DURATION_FROM_BITRATE
4532 };
4533
4534 typedef struct AVFormatInternal AVFormatInternal;
4535
4536 typedef struct AVFormatContext {
4537
4538 const AVClass *av_class;
4539
4540 struct AVInputFormat *iformat;
4541
4542 struct AVOutputFormat *oformat;
4543
4544 void *priv_data;
4545
4546 AVIOContext *pb;
4547
4548 int ctx_flags;
4549
4550 unsigned int nb_streams;
4551
4552 AVStream **streams;
4553
4554 char filename[1024];
4555
4556 int64_t start_time;
4557
4558 int64_t duration;
4559
4560 int bit_rate;
4561
4562 unsigned int packet_size;
4563 int max_delay;
4564
4565 int flags;
4566 #define AVFMT_FLAG_GENPTS 0x0001
4567 #define AVFMT_FLAG_IGNIDX 0x0002
4568 #define AVFMT_FLAG_NONBLOCK 0x0004
4569 #define AVFMT_FLAG_IGNDTS 0x0008
4570 #define AVFMT_FLAG_NOFILLIN 0x0010
4571 #define AVFMT_FLAG_NOPARSE 0x0020
4572 #define AVFMT_FLAG_NOBUFFER 0x0040
4573 #define AVFMT_FLAG_CUSTOM_IO 0x0080
4574 #define AVFMT_FLAG_DISCARD_CORRUPT 0x0100
4575 #define AVFMT_FLAG_FLUSH_PACKETS 0x0200
4576
4577 #define AVFMT_FLAG_BITEXACT 0x0400
4578 #define AVFMT_FLAG_MP4A_LATM 0x8000
4579 #define AVFMT_FLAG_SORT_DTS 0x10000
4580 #define AVFMT_FLAG_PRIV_OPT 0x20000
4581 #define AVFMT_FLAG_KEEP_SIDE_DATA 0x40000
4582
4583 unsigned int probesize;
4584
4585 attribute_deprecated
4586 int max_analyze_duration;
4587
4588 const uint8_t *key;
4589 int keylen;
4590
4591 unsigned int nb_programs;
4592 AVProgram **programs;
4593
4594 enum AVCodecID video_codec_id;
4595
4596 enum AVCodecID audio_codec_id;
4597
4598 enum AVCodecID subtitle_codec_id;
4599
4600 unsigned int max_index_size;
4601
4602 unsigned int max_picture_buffer;
4603
4604 unsigned int nb_chapters;
4605 AVChapter **chapters;
4606
4607 AVDictionary *metadata;
4608
4609 int64_t start_time_realtime;
4610
4611 int fps_probe_size;
4612
4613 int error_recognition;
4614
4615 AVIOInterruptCB interrupt_callback;
4616
4617 int debug;
4618 #define FF_FDEBUG_TS 0x0001
4619
4620 int64_t max_interleave_delta;
4621
4622 int strict_std_compliance;
4623
4624 int ts_id;
4625
4626 int audio_preload;
4627
4628 int max_chunk_duration;
4629
4630 int max_chunk_size;
4631
4632 int use_wallclock_as_timestamps;
4633
4634 int avoid_negative_ts;
4635
4636 int avio_flags;
4637
4638 enum AVDurationEstimationMethod duration_estimation_method;
4639
4640 int64_t skip_initial_bytes;
4641
4642 unsigned int correct_ts_overflow;
4643
4644 int seek2any;
4645
4646 int flush_packets;
4647
4648 int probe_score;
4649
4650 int format_probesize;
4651
4652 struct AVPacketList *packet_buffer;
4653 struct AVPacketList *packet_buffer_end;
4654
4655 int64_t data_offset;
4656
4657 struct AVPacketList *raw_packet_buffer;
4658 struct AVPacketList *raw_packet_buffer_end;
4659
4660 struct AVPacketList *parse_queue;
4661 struct AVPacketList *parse_queue_end;
4662
4663 #define RAW_PACKET_BUFFER_SIZE 2500000
4664 int raw_packet_buffer_remaining_size;
4665
4666 int64_t offset;
4667
4668 AVRational offset_timebase;
4669
4670 AVFormatInternal *internal;
4671
4672 int io_repositioned;
4673
4674 AVCodec *video_codec;
4675
4676 AVCodec *audio_codec;
4677
4678 AVCodec *subtitle_codec;
4679
4680 int metadata_header_padding;
4681
4682 void *opaque;
4683
4684 av_format_control_message control_message_cb;
4685
4686 int64_t output_ts_offset;
4687
4688 int64_t max_analyze_duration2;
4689 } AVFormatContext;
4690
4691 int av_format_get_probe_score(const AVFormatContext *s);
4692 AVCodec * av_format_get_video_codec(const AVFormatContext *s);
4693 void av_format_set_video_codec(AVFormatContext *s, AVCodec *c);
4694 AVCodec * av_format_get_audio_codec(const AVFormatContext *s);
4695 void av_format_set_audio_codec(AVFormatContext *s, AVCodec *c);
4696 AVCodec * av_format_get_subtitle_codec(const AVFormatContext *s);
4697 void av_format_set_subtitle_codec(AVFormatContext *s, AVCodec *c);
4698 int av_format_get_metadata_header_padding(const AVFormatContext *s);
4699 void av_format_set_metadata_header_padding(AVFormatContext *s, int c);
4700 void * av_format_get_opaque(const AVFormatContext *s);
4701 void av_format_set_opaque(AVFormatContext *s, void *opaque);
4702 av_format_control_message av_format_get_control_message_cb(const AVFormatContext *s);
4703 void av_format_set_control_message_cb(AVFormatContext *s, av_format_control_message callback);
4704
4705 void av_format_inject_global_side_data(AVFormatContext *s);
4706
4707 enum AVDurationEstimationMethod av_fmt_ctx_get_duration_estimation_method(const AVFormatContext* ctx);
4708
4709 typedef struct AVPacketList {
4710 AVPacket pkt;
4711 struct AVPacketList *next;
4712 } AVPacketList;
4713
4714 unsigned avformat_version(void);
4715
4716 const char *avformat_configuration(void);
4717
4718 const char *avformat_license(void);
4719
4720 void av_register_all(void);
4721
4722 void av_register_input_format(AVInputFormat *format);
4723 void av_register_output_format(AVOutputFormat *format);
4724
4725 int avformat_network_init(void);
4726
4727 int avformat_network_deinit(void);
4728
4729 AVInputFormat *av_iformat_next(AVInputFormat *f);
4730
4731 AVOutputFormat *av_oformat_next(AVOutputFormat *f);
4732
4733 AVFormatContext *avformat_alloc_context(void);
4734
4735 void avformat_free_context(AVFormatContext *s);
4736
4737 const AVClass *avformat_get_class(void);
4738
4739 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c);
4740
4741 uint8_t *av_stream_get_side_data(AVStream *stream,
4742 enum AVPacketSideDataType type, int *size);
4743
4744 AVProgram *av_new_program(AVFormatContext *s, int id);
4745
4746 attribute_deprecated
4747 AVFormatContext *avformat_alloc_output_context(const char *format,
4748 AVOutputFormat *oformat,
4749 const char *filename);
4750
4751 int avformat_alloc_output_context2(AVFormatContext **ctx, AVOutputFormat *oformat,
4752 const char *format_name, const char *filename);
4753
4754 AVInputFormat *av_find_input_format(const char *short_name);
4755
4756 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened);
4757
4758 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max);
4759
4760 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret);
4761
4762 int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
4763 const char *filename, void *logctx,
4764 unsigned int offset, unsigned int max_probe_size);
4765
4766 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
4767 const char *filename, void *logctx,
4768 unsigned int offset, unsigned int max_probe_size);
4769
4770 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options);
4771
4772 attribute_deprecated
4773 int av_demuxer_open(AVFormatContext *ic);
4774
4775 attribute_deprecated
4776 int av_find_stream_info(AVFormatContext *ic);
4777
4778 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options);
4779
4780 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s);
4781
4782 int av_find_best_stream(AVFormatContext *ic,
4783 enum AVMediaType type,
4784 int wanted_stream_nb,
4785 int related_stream,
4786 AVCodec **decoder_ret,
4787 int flags);
4788
4789 attribute_deprecated
4790 int av_read_packet(AVFormatContext *s, AVPacket *pkt);
4791
4792 int av_read_frame(AVFormatContext *s, AVPacket *pkt);
4793
4794 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp,
4795 int flags);
4796
4797 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags);
4798
4799 int av_read_play(AVFormatContext *s);
4800
4801 int av_read_pause(AVFormatContext *s);
4802
4803 attribute_deprecated
4804 void av_close_input_file(AVFormatContext *s);
4805
4806 void avformat_close_input(AVFormatContext **s);
4807
4808 attribute_deprecated
4809 AVStream *av_new_stream(AVFormatContext *s, int id);
4810
4811 attribute_deprecated
4812 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
4813 unsigned int pts_num, unsigned int pts_den);
4814
4815 #define AVSEEK_FLAG_BACKWARD 1
4816 #define AVSEEK_FLAG_BYTE 2
4817 #define AVSEEK_FLAG_ANY 4
4818 #define AVSEEK_FLAG_FRAME 8
4819
4820 int avformat_write_header(AVFormatContext *s, AVDictionary **options);
4821
4822 int av_write_frame(AVFormatContext *s, AVPacket *pkt);
4823
4824 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt);
4825
4826 int av_write_uncoded_frame(AVFormatContext *s, int stream_index,
4827 AVFrame *frame);
4828
4829 int av_interleaved_write_uncoded_frame(AVFormatContext *s, int stream_index,
4830 AVFrame *frame);
4831
4832 int av_write_uncoded_frame_query(AVFormatContext *s, int stream_index);
4833
4834 int av_write_trailer(AVFormatContext *s);
4835
4836 AVOutputFormat *av_guess_format(const char *short_name,
4837 const char *filename,
4838 const char *mime_type);
4839
4840 enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
4841 const char *filename, const char *mime_type,
4842 enum AVMediaType type);
4843
4844 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
4845 int64_t *dts, int64_t *wall);
4846
4847 void av_hex_dump(FILE *f, const uint8_t *buf, int size);
4848
4849 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size);
4850
4851 void av_pkt_dump2(FILE *f, const AVPacket *pkt, int dump_payload, const AVStream *st);
4852
4853 void av_pkt_dump_log2(void *avcl, int level, const AVPacket *pkt, int dump_payload,
4854 const AVStream *st);
4855
4856 enum AVCodecID av_codec_get_id(const struct AVCodecTag * const *tags, unsigned int tag);
4857
4858 unsigned int av_codec_get_tag(const struct AVCodecTag * const *tags, enum AVCodecID id);
4859
4860 int av_codec_get_tag2(const struct AVCodecTag * const *tags, enum AVCodecID id,
4861 unsigned int *tag);
4862
4863 int av_find_default_stream_index(AVFormatContext *s);
4864
4865 int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags);
4866
4867 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
4868 int size, int distance, int flags);
4869
4870 void av_url_split(char *proto, int proto_size,
4871 char *authorization, int authorization_size,
4872 char *hostname, int hostname_size,
4873 int *port_ptr,
4874 char *path, int path_size,
4875 const char *url);
4876
4877 void av_dump_format(AVFormatContext *ic,
4878 int index,
4879 const char *url,
4880 int is_output);
4881
4882 int av_get_frame_filename(char *buf, int buf_size,
4883 const char *path, int number);
4884
4885 int av_filename_number_test(const char *filename);
4886
4887 int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size);
4888
4889 int av_match_ext(const char *filename, const char *extensions);
4890
4891 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance);
4892
4893 const struct AVCodecTag *avformat_get_riff_video_tags(void);
4894
4895 const struct AVCodecTag *avformat_get_riff_audio_tags(void);
4896
4897 const struct AVCodecTag *avformat_get_mov_video_tags(void);
4898
4899 const struct AVCodecTag *avformat_get_mov_audio_tags(void);
4900
4901 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame);
4902
4903 AVRational av_guess_frame_rate(AVFormatContext *ctx, AVStream *stream, AVFrame *frame);
4904
4905 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4906 const char *spec);
4907
4908 int avformat_queue_attached_pictures(AVFormatContext *s);
4909
4910 #define AVUTIL_FIFO_H
4911
4912 typedef struct AVFifoBuffer {
4913 uint8_t *buffer;
4914 uint8_t *rptr, *wptr, *end;
4915 uint32_t rndx, wndx;
4916 } AVFifoBuffer;
4917
4918 AVFifoBuffer *av_fifo_alloc(unsigned int size);
4919
4920 AVFifoBuffer *av_fifo_alloc_array(size_t nmemb, size_t size);
4921
4922 void av_fifo_free(AVFifoBuffer *f);
4923
4924 void av_fifo_freep(AVFifoBuffer **f);
4925
4926 void av_fifo_reset(AVFifoBuffer *f);
4927
4928 int av_fifo_size(FF_CONST_AVUTIL53 AVFifoBuffer *f);
4929
4930 int av_fifo_space(FF_CONST_AVUTIL53 AVFifoBuffer *f);
4931
4932 int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int));
4933
4934 int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void*, void*, int));
4935
4936 int av_fifo_realloc2(AVFifoBuffer *f, unsigned int size);
4937
4938 int av_fifo_grow(AVFifoBuffer *f, unsigned int additional_space);
4939
4940 void av_fifo_drain(AVFifoBuffer *f, int size);
4941
av_fifo_peek2(const AVFifoBuffer * f,int offs)4942 static inline uint8_t *av_fifo_peek2(const AVFifoBuffer *f, int offs)
4943 {
4944 uint8_t *ptr = f->rptr + offs;
4945 if (ptr >= f->end)
4946 ptr = f->buffer + (ptr - f->end);
4947 else if (ptr < f->buffer)
4948 ptr = f->end - (f->buffer - ptr);
4949 return ptr;
4950 }
4951
4952