Audacity 3.2.0
ffmpeg-4.2.4-single-header.h
Go to the documentation of this file.
1// This header was generated from the FFMPEG headers
2#pragma once
3
4#include <math.h>
5#include <stdint.h>
6#include <stdio.h>
7#include <stdlib.h>
8#include <limits.h>
9#include <inttypes.h>
10#include <string.h>
11#include <errno.h>
12#include <stdarg.h>
13#include <time.h>
14#include <stddef.h>
15
16#define AVCODEC_AVCODEC_H
17
18#define AVUTIL_SAMPLEFMT_H
19
20#define AVUTIL_AVUTIL_H
21
22unsigned avutil_version(void);
23
24const char *av_version_info(void);
25
26const char *avutil_configuration(void);
27
28const char *avutil_license(void);
29
38};
39
40const char *av_get_media_type_string(enum AVMediaType media_type);
41
42#define FF_LAMBDA_SHIFT 7
43#define FF_LAMBDA_SCALE (1<<FF_LAMBDA_SHIFT)
44#define FF_QP2LAMBDA 118
45#define FF_LAMBDA_MAX (256*128-1)
46
47#define FF_QUALITY_SCALE FF_LAMBDA_SCALE
48
49#define AV_NOPTS_VALUE ((int64_t)UINT64_C(0x8000000000000000))
50
51#define AV_TIME_BASE 1000000
52
53#define AV_TIME_BASE_Q (AVRational){1, AV_TIME_BASE}
54
64};
65
67
68#define AVUTIL_COMMON_H
69
70#define AVUTIL_ATTRIBUTES_H
71
72# define AV_GCC_VERSION_AT_LEAST(x,y) 0
73# define AV_GCC_VERSION_AT_MOST(x,y) 0
74
75# define av_always_inline inline
76
77# define av_extern_inline inline
78
79# define av_warn_unused_result
80
81# define av_noinline
82
83# define av_pure
84
85# define av_const
86
87# define av_cold
88
89# define av_flatten
90
91# define attribute_deprecated
92
93# define AV_NOWARN_DEPRECATED(code) code
94
95# define av_unused
96
97# define av_used
98
99# define av_alias
100
101# define av_uninit(x) x
102
103# define av_builtin_constant_p(x) 0
104# define av_printf_format(fmtpos, attrpos)
105
106# define av_noreturn
107
108#define AVUTIL_MACROS_H
109
110#define AV_STRINGIFY(s) AV_TOSTRING(s)
111#define AV_TOSTRING(s) #s
112
113#define AV_GLUE(a, b) a ## b
114#define AV_JOIN(a, b) AV_GLUE(a, b)
115
116#define AV_PRAGMA(s) _Pragma(#s)
117
118#define FFALIGN(x, a) (((x)+(a)-1)&~((a)-1))
119
120#define AVUTIL_VERSION_H
121
122#define AV_VERSION_INT(a, b, c) ((a)<<16 | (b)<<8 | (c))
123#define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c
124#define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)
125
126#define AV_VERSION_MAJOR(a) ((a) >> 16)
127#define AV_VERSION_MINOR(a) (((a) & 0x00FF00) >> 8)
128#define AV_VERSION_MICRO(a) ((a) & 0xFF)
129
130#define LIBAVUTIL_VERSION_MAJOR 56
131#define LIBAVUTIL_VERSION_MINOR 31
132#define LIBAVUTIL_VERSION_MICRO 100
133
134#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
135 LIBAVUTIL_VERSION_MINOR, \
136 LIBAVUTIL_VERSION_MICRO)
137#define LIBAVUTIL_VERSION AV_VERSION(LIBAVUTIL_VERSION_MAJOR, \
138 LIBAVUTIL_VERSION_MINOR, \
139 LIBAVUTIL_VERSION_MICRO)
140#define LIBAVUTIL_BUILD LIBAVUTIL_VERSION_INT
141
142#define LIBAVUTIL_IDENT "Lavu" AV_STRINGIFY(LIBAVUTIL_VERSION)
143
144#define FF_API_VAAPI (LIBAVUTIL_VERSION_MAJOR < 57)
145#define FF_API_FRAME_QP (LIBAVUTIL_VERSION_MAJOR < 57)
146#define FF_API_PLUS1_MINUS1 (LIBAVUTIL_VERSION_MAJOR < 57)
147#define FF_API_ERROR_FRAME (LIBAVUTIL_VERSION_MAJOR < 57)
148#define FF_API_PKT_PTS (LIBAVUTIL_VERSION_MAJOR < 57)
149#define FF_API_CRYPTO_SIZE_T (LIBAVUTIL_VERSION_MAJOR < 57)
150#define FF_API_FRAME_GET_SET (LIBAVUTIL_VERSION_MAJOR < 57)
151#define FF_API_PSEUDOPAL (LIBAVUTIL_VERSION_MAJOR < 57)
152
153# define AV_NE(be, le) (le)
154
155#define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))
156
157#define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
158
159#define AV_CEIL_RSHIFT(a,b) (!av_builtin_constant_p(b) ? -((-(a)) >> (b)) \
160 : ((a) + (1<<(b)) - 1) >> (b))
161
162#define FF_CEIL_RSHIFT AV_CEIL_RSHIFT
163
164#define FFUDIV(a,b) (((a)>0 ?(a):(a)-(b)+1) / (b))
165#define FFUMOD(a,b) ((a)-(b)*FFUDIV(a,b))
166
167#define FFABS(a) ((a) >= 0 ? (a) : (-(a)))
168#define FFSIGN(a) ((a) > 0 ? 1 : -1)
169
170#define FFNABS(a) ((a) <= 0 ? (a) : (-(a)))
171
172#define FFDIFFSIGN(x,y) (((x)>(y)) - ((x)<(y)))
173
174#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
175#define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
176#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
177#define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
178
179#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
180#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
181
182# define av_ceil_log2 av_ceil_log2_c
183# define av_clip av_clip_c
184# define av_clip64 av_clip64_c
185# define av_clip_uint8 av_clip_uint8_c
186# define av_clip_int8 av_clip_int8_c
187# define av_clip_uint16 av_clip_uint16_c
188# define av_clip_int16 av_clip_int16_c
189# define av_clipl_int32 av_clipl_int32_c
190# define av_clip_intp2 av_clip_intp2_c
191# define av_clip_uintp2 av_clip_uintp2_c
192# define av_mod_uintp2 av_mod_uintp2_c
193# define av_sat_add32 av_sat_add32_c
194# define av_sat_dadd32 av_sat_dadd32_c
195# define av_sat_sub32 av_sat_sub32_c
196# define av_sat_dsub32 av_sat_dsub32_c
197# define av_clipf av_clipf_c
198# define av_clipd av_clipd_c
199# define av_popcount av_popcount_c
200# define av_popcount64 av_popcount64_c
201# define av_parity av_parity_c
202
203av_const int av_log2(unsigned v);
204
205av_const int av_log2_16bit(unsigned v);
206
207static av_always_inline av_const int av_clip_c(int a, int amin, int amax)
208{
209 if (a < amin) return amin;
210 else if (a > amax) return amax;
211 else return a;
212}
213
214static av_always_inline av_const int64_t av_clip64_c(int64_t a, int64_t amin, int64_t amax)
215{
216 if (a < amin) return amin;
217 else if (a > amax) return amax;
218 else return a;
219}
220
222{
223 if (a&(~0xFF)) return (~a)>>31;
224 else return a;
225}
226
228{
229 if ((a+0x80U) & ~0xFF) return (a>>31) ^ 0x7F;
230 else return a;
231}
232
234{
235 if (a&(~0xFFFF)) return (~a)>>31;
236 else return a;
237}
238
240{
241 if ((a+0x8000U) & ~0xFFFF) return (a>>31) ^ 0x7FFF;
242 else return a;
243}
244
246{
247 if ((a+0x80000000u) & ~UINT64_C(0xFFFFFFFF)) return (int32_t)((a>>63) ^ 0x7FFFFFFF);
248 else return (int32_t)a;
249}
250
252{
253 if (((unsigned)a + (1 << p)) & ~((2 << p) - 1))
254 return (a >> 31) ^ ((1 << p) - 1);
255 else
256 return a;
257}
258
259static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
260{
261 if (a & ~((1<<p) - 1)) return (~a) >> 31 & ((1<<p) - 1);
262 else return a;
263}
264
265static av_always_inline av_const unsigned av_mod_uintp2_c(unsigned a, unsigned p)
266{
267 return a & ((1 << p) - 1);
268}
269
270static av_always_inline int av_sat_add32_c(int a, int b)
271{
272 return av_clipl_int32((int64_t)a + b);
273}
274
275static av_always_inline int av_sat_dadd32_c(int a, int b)
276{
277 return av_sat_add32(a, av_sat_add32(b, b));
278}
279
280static av_always_inline int av_sat_sub32_c(int a, int b)
281{
282 return av_clipl_int32((int64_t)a - b);
283}
284
285static av_always_inline int av_sat_dsub32_c(int a, int b)
286{
287 return av_sat_sub32(a, av_sat_add32(b, b));
288}
289
290static av_always_inline av_const float av_clipf_c(float a, float amin, float amax)
291{
292 if (a < amin) return amin;
293 else if (a > amax) return amax;
294 else return a;
295}
296
297static av_always_inline av_const double av_clipd_c(double a, double amin, double amax)
298{
299 if (a < amin) return amin;
300 else if (a > amax) return amax;
301 else return a;
302}
303
305{
306 return av_log2((x - 1U) << 1);
307}
308
310{
311 x -= (x >> 1) & 0x55555555;
312 x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
313 x = (x + (x >> 4)) & 0x0F0F0F0F;
314 x += x >> 8;
315 return (x + (x >> 16)) & 0x3F;
316}
317
319{
320 return av_popcount((uint32_t)x) + av_popcount((uint32_t)(x >> 32));
321}
322
324{
325 return av_popcount(v) & 1;
326}
327
328#define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
329#define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
330
331#define GET_UTF8(val, GET_BYTE, ERROR)\
332 val= (GET_BYTE);\
333 {\
334 uint32_t top = (val & 128) >> 1;\
335 if ((val & 0xc0) == 0x80 || val >= 0xFE)\
336 ERROR\
337 while (val & top) {\
338 int tmp= (GET_BYTE) - 128;\
339 if(tmp>>6)\
340 ERROR\
341 val= (val<<6) + tmp;\
342 top <<= 5;\
343 }\
344 val &= (top << 1) - 1;\
345 }
346
347#define GET_UTF16(val, GET_16BIT, ERROR)\
348 val = GET_16BIT;\
349 {\
350 unsigned int hi = val - 0xD800;\
351 if (hi < 0x800) {\
352 val = GET_16BIT - 0xDC00;\
353 if (val > 0x3FFU || hi > 0x3FFU)\
354 ERROR\
355 val += (hi<<10) + 0x10000;\
356 }\
357 }\
358
359#define PUT_UTF8(val, tmp, PUT_BYTE)\
360 {\
361 int bytes, shift;\
362 uint32_t in = val;\
363 if (in < 0x80) {\
364 tmp = in;\
365 PUT_BYTE\
366 } else {\
367 bytes = (av_log2(in) + 4) / 5;\
368 shift = (bytes - 1) * 6;\
369 tmp = (256 - (256 >> bytes)) | (in >> shift);\
370 PUT_BYTE\
371 while (shift >= 6) {\
372 shift -= 6;\
373 tmp = 0x80 | ((in >> shift) & 0x3f);\
374 PUT_BYTE\
375 }\
376 }\
377 }
378
379#define PUT_UTF16(val, tmp, PUT_16BIT)\
380 {\
381 uint32_t in = val;\
382 if (in < 0x10000) {\
383 tmp = in;\
384 PUT_16BIT\
385 } else {\
386 tmp = 0xD800 | ((in - 0x10000) >> 10);\
387 PUT_16BIT\
388 tmp = 0xDC00 | ((in - 0x10000) & 0x3FF);\
389 PUT_16BIT\
390 }\
391 }\
392
393#define AVUTIL_MEM_H
394
395#define AVUTIL_ERROR_H
396
397#define AVERROR(e) (e)
398#define AVUNERROR(e) (e)
399
400#define FFERRTAG(a, b, c, d) (-(int)MKTAG(a, b, c, d))
401
402#define AVERROR_BSF_NOT_FOUND FFERRTAG(0xF8,'B','S','F')
403#define AVERROR_BUG FFERRTAG( 'B','U','G','!')
404#define AVERROR_BUFFER_TOO_SMALL FFERRTAG( 'B','U','F','S')
405#define AVERROR_DECODER_NOT_FOUND FFERRTAG(0xF8,'D','E','C')
406#define AVERROR_DEMUXER_NOT_FOUND FFERRTAG(0xF8,'D','E','M')
407#define AVERROR_ENCODER_NOT_FOUND FFERRTAG(0xF8,'E','N','C')
408#define AVERROR_EOF FFERRTAG( 'E','O','F',' ')
409#define AVERROR_EXIT FFERRTAG( 'E','X','I','T')
410#define AVERROR_EXTERNAL FFERRTAG( 'E','X','T',' ')
411#define AVERROR_FILTER_NOT_FOUND FFERRTAG(0xF8,'F','I','L')
412#define AVERROR_INVALIDDATA FFERRTAG( 'I','N','D','A')
413#define AVERROR_MUXER_NOT_FOUND FFERRTAG(0xF8,'M','U','X')
414#define AVERROR_OPTION_NOT_FOUND FFERRTAG(0xF8,'O','P','T')
415#define AVERROR_PATCHWELCOME FFERRTAG( 'P','A','W','E')
416#define AVERROR_PROTOCOL_NOT_FOUND FFERRTAG(0xF8,'P','R','O')
417
418#define AVERROR_STREAM_NOT_FOUND FFERRTAG(0xF8,'S','T','R')
419
420#define AVERROR_BUG2 FFERRTAG( 'B','U','G',' ')
421#define AVERROR_UNKNOWN FFERRTAG( 'U','N','K','N')
422#define AVERROR_EXPERIMENTAL (-0x2bb2afa8)
423#define AVERROR_INPUT_CHANGED (-0x636e6701)
424#define AVERROR_OUTPUT_CHANGED (-0x636e6702)
425
426#define AVERROR_HTTP_BAD_REQUEST FFERRTAG(0xF8,'4','0','0')
427#define AVERROR_HTTP_UNAUTHORIZED FFERRTAG(0xF8,'4','0','1')
428#define AVERROR_HTTP_FORBIDDEN FFERRTAG(0xF8,'4','0','3')
429#define AVERROR_HTTP_NOT_FOUND FFERRTAG(0xF8,'4','0','4')
430#define AVERROR_HTTP_OTHER_4XX FFERRTAG(0xF8,'4','X','X')
431#define AVERROR_HTTP_SERVER_ERROR FFERRTAG(0xF8,'5','X','X')
432
433#define AV_ERROR_MAX_STRING_SIZE 64
434
435int av_strerror(int errnum, char *errbuf, size_t errbuf_size);
436
437static inline char *av_make_error_string(char *errbuf, size_t errbuf_size, int errnum)
438{
439 av_strerror(errnum, errbuf, errbuf_size);
440 return errbuf;
441}
442
443#define av_err2str(errnum) \
444 av_make_error_string((char[AV_ERROR_MAX_STRING_SIZE]){0}, AV_ERROR_MAX_STRING_SIZE, errnum)
445
446 #define DECLARE_ALIGNED(n,t,v) t v
447 #define DECLARE_ASM_ALIGNED(n,t,v) t v
448 #define DECLARE_ASM_CONST(n,t,v) static const t v
449
450 #define av_malloc_attrib
451
452 #define av_alloc_size(...)
453
455
457
458av_alloc_size(1, 2) void *av_malloc_array(size_t nmemb, size_t size);
459
460av_alloc_size(1, 2) void *av_mallocz_array(size_t nmemb, size_t size);
461
462void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib;
463
464void *av_realloc(void *ptr, size_t size) av_alloc_size(2);
465
467int av_reallocp(void *ptr, size_t size);
468
469void *av_realloc_f(void *ptr, size_t nelem, size_t elsize);
470
471av_alloc_size(2, 3) void *av_realloc_array(void *ptr, size_t nmemb, size_t size);
472
473int av_reallocp_array(void *ptr, size_t nmemb, size_t size);
474
475void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size);
476
477void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size);
478
479void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size);
480
481void av_free(void *ptr);
482
483void av_freep(void *ptr);
484
485char *av_strdup(const char *s) av_malloc_attrib;
486
487char *av_strndup(const char *s, size_t len) av_malloc_attrib;
488
489void *av_memdup(const void *p, size_t size);
490
491void av_memcpy_backptr(uint8_t *dst, int back, int cnt);
492
493void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem);
494
496int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem);
497
498void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
499 const uint8_t *elem_data);
500
501static inline int av_size_mult(size_t a, size_t b, size_t *r)
502{
503 size_t t = a * b;
504
505 if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
506 return AVERROR(EINVAL);
507 *r = t;
508 return 0;
509}
510
511void av_max_alloc(size_t max);
512
513#define AVUTIL_RATIONAL_H
514
515typedef struct AVRational{
516 int num;
517 int den;
519
520static inline AVRational av_make_q(int num, int den)
521{
522 AVRational r = { num, den };
523 return r;
524}
525
526static inline int av_cmp_q(AVRational a, AVRational b){
527 const int64_t tmp= a.num * (int64_t)b.den - b.num * (int64_t)a.den;
528
529 if(tmp) return (int)((tmp ^ a.den ^ b.den)>>63)|1;
530 else if(b.den && a.den) return 0;
531 else if(a.num && b.num) return (a.num>>31) - (b.num>>31);
532 else return INT_MIN;
533}
534
535static inline double av_q2d(AVRational a){
536 return a.num / (double) a.den;
537}
538
539int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max);
540
542
544
546
548
550{
551 AVRational r = { q.den, q.num };
552 return r;
553}
554
555AVRational av_d2q(double d, int max) av_const;
556
558
560
562
563#define AVUTIL_MATHEMATICS_H
564
565#define AVUTIL_INTFLOAT_H
566
567union av_intfloat32 {
568 uint32_t i;
569 float f;
570};
571
572union av_intfloat64 {
573 uint64_t i;
574 double f;
575};
576
577static av_always_inline float av_int2float(uint32_t i)
578{
579 union av_intfloat32 v;
580 v.i = i;
581 return v.f;
582}
583
584static av_always_inline uint32_t av_float2int(float f)
585{
586 union av_intfloat32 v;
587 v.f = f;
588 return v.i;
589}
590
591static av_always_inline double av_int2double(uint64_t i)
592{
593 union av_intfloat64 v;
594 v.i = i;
595 return v.f;
596}
597
598static av_always_inline uint64_t av_double2int(double f)
599{
600 union av_intfloat64 v;
601 v.f = f;
602 return v.i;
603}
604
605#define M_E 2.7182818284590452354
606#define M_LN2 0.69314718055994530942
607#define M_LN10 2.30258509299404568402
608#define M_LOG2_10 3.32192809488736234787
609#define M_PHI 1.61803398874989484820
610#define M_PI 3.14159265358979323846
611#define M_PI_2 1.57079632679489661923
612#define M_SQRT1_2 0.70710678118654752440
613#define M_SQRT2 1.41421356237309504880
614#define NAN av_int2float(0x7fc00000)
615#define INFINITY av_int2float(0x7f800000)
616
623
625};
626
627int64_t av_const av_gcd(int64_t a, int64_t b);
628
629int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const;
630
631int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd) av_const;
632
633int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const;
634
635int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq,
636 enum AVRounding rnd) av_const;
637
638int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b);
639
640int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod);
641
642int64_t av_rescale_delta(AVRational in_tb, int64_t in_ts, AVRational fs_tb, int duration, int64_t *last, AVRational out_tb);
643
644int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc);
645
646#define AVUTIL_LOG_H
647
648typedef enum {
668
669#define AV_IS_INPUT_DEVICE(category) \
670 (((category) == AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT) || \
671 ((category) == AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT) || \
672 ((category) == AV_CLASS_CATEGORY_DEVICE_INPUT))
673
674#define AV_IS_OUTPUT_DEVICE(category) \
675 (((category) == AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT) || \
676 ((category) == AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT) || \
677 ((category) == AV_CLASS_CATEGORY_DEVICE_OUTPUT))
678
679struct AVOptionRanges;
680
681typedef struct AVClass {
682
683 const char* class_name;
684
685 const char* (*item_name)(void* ctx);
686
687 const struct AVOption *option;
688
689 int version;
690
692
694
695 void* (*child_next)(void *obj, void *prev);
696
697 const struct AVClass* (*child_class_next)(const struct AVClass *prev);
698
700
701 AVClassCategory (*get_category)(void* ctx);
702
703 int (*query_ranges)(struct AVOptionRanges **, void *obj, const char *key, int flags);
705
706#define AV_LOG_QUIET -8
707
708#define AV_LOG_PANIC 0
709
710#define AV_LOG_FATAL 8
711
712#define AV_LOG_ERROR 16
713
714#define AV_LOG_WARNING 24
715
716#define AV_LOG_INFO 32
717
718#define AV_LOG_VERBOSE 40
719
720#define AV_LOG_DEBUG 48
721
722#define AV_LOG_TRACE 56
723
724#define AV_LOG_MAX_OFFSET (AV_LOG_TRACE - AV_LOG_QUIET)
725
726#define AV_LOG_C(x) ((x) << 8)
727
728void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4);
729
730void av_vlog(void *avcl, int level, const char *fmt, va_list vl);
731
733
734void av_log_set_level(int level);
735
736void av_log_set_callback(void (*callback)(void*, int, const char*, va_list));
737
738void av_log_default_callback(void *avcl, int level, const char *fmt,
739 va_list vl);
740
741const char* av_default_item_name(void* ctx);
743
744void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl,
745 char *line, int line_size, int *print_prefix);
746
747int av_log_format_line2(void *ptr, int level, const char *fmt, va_list vl,
748 char *line, int line_size, int *print_prefix);
749
750#define AV_LOG_SKIP_REPEATED 1
751
752#define AV_LOG_PRINT_LEVEL 2
753
754void av_log_set_flags(int arg);
756
757#define AVUTIL_PIXFMT_H
758
759#define AVPALETTE_SIZE 1024
760#define AVPALETTE_COUNT 256
761
789
794
802
807
812
816
818
826
832
835
838
879
881
887
892
894
897
901
903
905
907
909
914
932
945
947
954
956
959
962
965
967
972
975
977
980
985
987
989
992
995
1000
1003
1006
1007# define AV_PIX_FMT_NE(be, le) AV_PIX_FMT_##le
1008
1009#define AV_PIX_FMT_RGB32 AV_PIX_FMT_NE(ARGB, BGRA)
1010#define AV_PIX_FMT_RGB32_1 AV_PIX_FMT_NE(RGBA, ABGR)
1011#define AV_PIX_FMT_BGR32 AV_PIX_FMT_NE(ABGR, RGBA)
1012#define AV_PIX_FMT_BGR32_1 AV_PIX_FMT_NE(BGRA, ARGB)
1013#define AV_PIX_FMT_0RGB32 AV_PIX_FMT_NE(0RGB, BGR0)
1014#define AV_PIX_FMT_0BGR32 AV_PIX_FMT_NE(0BGR, RGB0)
1015
1016#define AV_PIX_FMT_GRAY9 AV_PIX_FMT_NE(GRAY9BE, GRAY9LE)
1017#define AV_PIX_FMT_GRAY10 AV_PIX_FMT_NE(GRAY10BE, GRAY10LE)
1018#define AV_PIX_FMT_GRAY12 AV_PIX_FMT_NE(GRAY12BE, GRAY12LE)
1019#define AV_PIX_FMT_GRAY14 AV_PIX_FMT_NE(GRAY14BE, GRAY14LE)
1020#define AV_PIX_FMT_GRAY16 AV_PIX_FMT_NE(GRAY16BE, GRAY16LE)
1021#define AV_PIX_FMT_YA16 AV_PIX_FMT_NE(YA16BE, YA16LE)
1022#define AV_PIX_FMT_RGB48 AV_PIX_FMT_NE(RGB48BE, RGB48LE)
1023#define AV_PIX_FMT_RGB565 AV_PIX_FMT_NE(RGB565BE, RGB565LE)
1024#define AV_PIX_FMT_RGB555 AV_PIX_FMT_NE(RGB555BE, RGB555LE)
1025#define AV_PIX_FMT_RGB444 AV_PIX_FMT_NE(RGB444BE, RGB444LE)
1026#define AV_PIX_FMT_RGBA64 AV_PIX_FMT_NE(RGBA64BE, RGBA64LE)
1027#define AV_PIX_FMT_BGR48 AV_PIX_FMT_NE(BGR48BE, BGR48LE)
1028#define AV_PIX_FMT_BGR565 AV_PIX_FMT_NE(BGR565BE, BGR565LE)
1029#define AV_PIX_FMT_BGR555 AV_PIX_FMT_NE(BGR555BE, BGR555LE)
1030#define AV_PIX_FMT_BGR444 AV_PIX_FMT_NE(BGR444BE, BGR444LE)
1031#define AV_PIX_FMT_BGRA64 AV_PIX_FMT_NE(BGRA64BE, BGRA64LE)
1032
1033#define AV_PIX_FMT_YUV420P9 AV_PIX_FMT_NE(YUV420P9BE , YUV420P9LE)
1034#define AV_PIX_FMT_YUV422P9 AV_PIX_FMT_NE(YUV422P9BE , YUV422P9LE)
1035#define AV_PIX_FMT_YUV444P9 AV_PIX_FMT_NE(YUV444P9BE , YUV444P9LE)
1036#define AV_PIX_FMT_YUV420P10 AV_PIX_FMT_NE(YUV420P10BE, YUV420P10LE)
1037#define AV_PIX_FMT_YUV422P10 AV_PIX_FMT_NE(YUV422P10BE, YUV422P10LE)
1038#define AV_PIX_FMT_YUV440P10 AV_PIX_FMT_NE(YUV440P10BE, YUV440P10LE)
1039#define AV_PIX_FMT_YUV444P10 AV_PIX_FMT_NE(YUV444P10BE, YUV444P10LE)
1040#define AV_PIX_FMT_YUV420P12 AV_PIX_FMT_NE(YUV420P12BE, YUV420P12LE)
1041#define AV_PIX_FMT_YUV422P12 AV_PIX_FMT_NE(YUV422P12BE, YUV422P12LE)
1042#define AV_PIX_FMT_YUV440P12 AV_PIX_FMT_NE(YUV440P12BE, YUV440P12LE)
1043#define AV_PIX_FMT_YUV444P12 AV_PIX_FMT_NE(YUV444P12BE, YUV444P12LE)
1044#define AV_PIX_FMT_YUV420P14 AV_PIX_FMT_NE(YUV420P14BE, YUV420P14LE)
1045#define AV_PIX_FMT_YUV422P14 AV_PIX_FMT_NE(YUV422P14BE, YUV422P14LE)
1046#define AV_PIX_FMT_YUV444P14 AV_PIX_FMT_NE(YUV444P14BE, YUV444P14LE)
1047#define AV_PIX_FMT_YUV420P16 AV_PIX_FMT_NE(YUV420P16BE, YUV420P16LE)
1048#define AV_PIX_FMT_YUV422P16 AV_PIX_FMT_NE(YUV422P16BE, YUV422P16LE)
1049#define AV_PIX_FMT_YUV444P16 AV_PIX_FMT_NE(YUV444P16BE, YUV444P16LE)
1050
1051#define AV_PIX_FMT_GBRP9 AV_PIX_FMT_NE(GBRP9BE , GBRP9LE)
1052#define AV_PIX_FMT_GBRP10 AV_PIX_FMT_NE(GBRP10BE, GBRP10LE)
1053#define AV_PIX_FMT_GBRP12 AV_PIX_FMT_NE(GBRP12BE, GBRP12LE)
1054#define AV_PIX_FMT_GBRP14 AV_PIX_FMT_NE(GBRP14BE, GBRP14LE)
1055#define AV_PIX_FMT_GBRP16 AV_PIX_FMT_NE(GBRP16BE, GBRP16LE)
1056#define AV_PIX_FMT_GBRAP10 AV_PIX_FMT_NE(GBRAP10BE, GBRAP10LE)
1057#define AV_PIX_FMT_GBRAP12 AV_PIX_FMT_NE(GBRAP12BE, GBRAP12LE)
1058#define AV_PIX_FMT_GBRAP16 AV_PIX_FMT_NE(GBRAP16BE, GBRAP16LE)
1059
1060#define AV_PIX_FMT_BAYER_BGGR16 AV_PIX_FMT_NE(BAYER_BGGR16BE, BAYER_BGGR16LE)
1061#define AV_PIX_FMT_BAYER_RGGB16 AV_PIX_FMT_NE(BAYER_RGGB16BE, BAYER_RGGB16LE)
1062#define AV_PIX_FMT_BAYER_GBRG16 AV_PIX_FMT_NE(BAYER_GBRG16BE, BAYER_GBRG16LE)
1063#define AV_PIX_FMT_BAYER_GRBG16 AV_PIX_FMT_NE(BAYER_GRBG16BE, BAYER_GRBG16LE)
1064
1065#define AV_PIX_FMT_GBRPF32 AV_PIX_FMT_NE(GBRPF32BE, GBRPF32LE)
1066#define AV_PIX_FMT_GBRAPF32 AV_PIX_FMT_NE(GBRAPF32BE, GBRAPF32LE)
1067
1068#define AV_PIX_FMT_GRAYF32 AV_PIX_FMT_NE(GRAYF32BE, GRAYF32LE)
1069
1070#define AV_PIX_FMT_YUVA420P9 AV_PIX_FMT_NE(YUVA420P9BE , YUVA420P9LE)
1071#define AV_PIX_FMT_YUVA422P9 AV_PIX_FMT_NE(YUVA422P9BE , YUVA422P9LE)
1072#define AV_PIX_FMT_YUVA444P9 AV_PIX_FMT_NE(YUVA444P9BE , YUVA444P9LE)
1073#define AV_PIX_FMT_YUVA420P10 AV_PIX_FMT_NE(YUVA420P10BE, YUVA420P10LE)
1074#define AV_PIX_FMT_YUVA422P10 AV_PIX_FMT_NE(YUVA422P10BE, YUVA422P10LE)
1075#define AV_PIX_FMT_YUVA444P10 AV_PIX_FMT_NE(YUVA444P10BE, YUVA444P10LE)
1076#define AV_PIX_FMT_YUVA422P12 AV_PIX_FMT_NE(YUVA422P12BE, YUVA422P12LE)
1077#define AV_PIX_FMT_YUVA444P12 AV_PIX_FMT_NE(YUVA444P12BE, YUVA444P12LE)
1078#define AV_PIX_FMT_YUVA420P16 AV_PIX_FMT_NE(YUVA420P16BE, YUVA420P16LE)
1079#define AV_PIX_FMT_YUVA422P16 AV_PIX_FMT_NE(YUVA422P16BE, YUVA422P16LE)
1080#define AV_PIX_FMT_YUVA444P16 AV_PIX_FMT_NE(YUVA444P16BE, YUVA444P16LE)
1081
1082#define AV_PIX_FMT_XYZ12 AV_PIX_FMT_NE(XYZ12BE, XYZ12LE)
1083#define AV_PIX_FMT_NV20 AV_PIX_FMT_NE(NV20BE, NV20LE)
1084#define AV_PIX_FMT_AYUV64 AV_PIX_FMT_NE(AYUV64BE, AYUV64LE)
1085#define AV_PIX_FMT_P010 AV_PIX_FMT_NE(P010BE, P010LE)
1086#define AV_PIX_FMT_P016 AV_PIX_FMT_NE(P016BE, P016LE)
1087
1094
1107
1132
1152
1159
1170
1171static inline void *av_x_if_null(const void *p, const void *x)
1172{
1173 return (void *)(intptr_t)(p ? p : x);
1174}
1175
1176unsigned av_int_list_length_for_size(unsigned elsize,
1177 const void *list, uint64_t term) av_pure;
1178
1179#define av_int_list_length(list, term) \
1180 av_int_list_length_for_size(sizeof(*(list)), list, term)
1181
1182FILE *av_fopen_utf8(const char *path, const char *mode);
1183
1185
1186#define AV_FOURCC_MAX_STRING_SIZE 32
1187
1188#define av_fourcc2str(fourcc) av_fourcc_make_string((char[AV_FOURCC_MAX_STRING_SIZE]){0}, fourcc)
1189
1190char *av_fourcc_make_string(char *buf, uint32_t fourcc);
1191
1199
1207
1210
1211const char *av_get_sample_fmt_name(enum AVSampleFormat sample_fmt);
1212
1214
1215enum AVSampleFormat av_get_alt_sample_fmt(enum AVSampleFormat sample_fmt, int planar);
1216
1218
1220
1221char *av_get_sample_fmt_string(char *buf, int buf_size, enum AVSampleFormat sample_fmt);
1222
1224
1226
1227int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples,
1228 enum AVSampleFormat sample_fmt, int align);
1229
1230int av_samples_fill_arrays(uint8_t **audio_data, int *linesize,
1231 const uint8_t *buf,
1232 int nb_channels, int nb_samples,
1233 enum AVSampleFormat sample_fmt, int align);
1234
1235int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels,
1236 int nb_samples, enum AVSampleFormat sample_fmt, int align);
1237
1238int av_samples_alloc_array_and_samples(uint8_t ***audio_data, int *linesize, int nb_channels,
1239 int nb_samples, enum AVSampleFormat sample_fmt, int align);
1240
1241int av_samples_copy(uint8_t **dst, uint8_t * const *src, int dst_offset,
1242 int src_offset, int nb_samples, int nb_channels,
1243 enum AVSampleFormat sample_fmt);
1244
1245int av_samples_set_silence(uint8_t **audio_data, int offset, int nb_samples,
1246 int nb_channels, enum AVSampleFormat sample_fmt);
1247
1248#define AVUTIL_BUFFER_H
1249
1250typedef struct AVBuffer AVBuffer;
1251
1252typedef struct AVBufferRef {
1254
1255 uint8_t *data;
1256
1257 int size;
1259
1261
1263
1264#define AV_BUFFER_FLAG_READONLY (1 << 0)
1265
1267 void (*free)(void *opaque, uint8_t *data),
1268 void *opaque, int flags);
1269
1270void av_buffer_default_free(void *opaque, uint8_t *data);
1271
1273
1275
1277
1279
1281
1283
1285
1287
1289
1291 AVBufferRef* (*alloc)(void *opaque, int size),
1292 void (*pool_free)(void *opaque));
1293
1295
1297
1298#define AVUTIL_CPU_H
1299
1300#define AV_CPU_FLAG_FORCE 0x80000000
1301
1302#define AV_CPU_FLAG_MMX 0x0001
1303#define AV_CPU_FLAG_MMXEXT 0x0002
1304#define AV_CPU_FLAG_MMX2 0x0002
1305#define AV_CPU_FLAG_3DNOW 0x0004
1306#define AV_CPU_FLAG_SSE 0x0008
1307#define AV_CPU_FLAG_SSE2 0x0010
1308#define AV_CPU_FLAG_SSE2SLOW 0x40000000
1309
1310#define AV_CPU_FLAG_3DNOWEXT 0x0020
1311#define AV_CPU_FLAG_SSE3 0x0040
1312#define AV_CPU_FLAG_SSE3SLOW 0x20000000
1313
1314#define AV_CPU_FLAG_SSSE3 0x0080
1315#define AV_CPU_FLAG_SSSE3SLOW 0x4000000
1316#define AV_CPU_FLAG_ATOM 0x10000000
1317#define AV_CPU_FLAG_SSE4 0x0100
1318#define AV_CPU_FLAG_SSE42 0x0200
1319#define AV_CPU_FLAG_AESNI 0x80000
1320#define AV_CPU_FLAG_AVX 0x4000
1321#define AV_CPU_FLAG_AVXSLOW 0x8000000
1322#define AV_CPU_FLAG_XOP 0x0400
1323#define AV_CPU_FLAG_FMA4 0x0800
1324#define AV_CPU_FLAG_CMOV 0x1000
1325#define AV_CPU_FLAG_AVX2 0x8000
1326#define AV_CPU_FLAG_FMA3 0x10000
1327#define AV_CPU_FLAG_BMI1 0x20000
1328#define AV_CPU_FLAG_BMI2 0x40000
1329#define AV_CPU_FLAG_AVX512 0x100000
1330
1331#define AV_CPU_FLAG_ALTIVEC 0x0001
1332#define AV_CPU_FLAG_VSX 0x0002
1333#define AV_CPU_FLAG_POWER8 0x0004
1334
1335#define AV_CPU_FLAG_ARMV5TE (1 << 0)
1336#define AV_CPU_FLAG_ARMV6 (1 << 1)
1337#define AV_CPU_FLAG_ARMV6T2 (1 << 2)
1338#define AV_CPU_FLAG_VFP (1 << 3)
1339#define AV_CPU_FLAG_VFPV3 (1 << 4)
1340#define AV_CPU_FLAG_NEON (1 << 5)
1341#define AV_CPU_FLAG_ARMV8 (1 << 6)
1342#define AV_CPU_FLAG_VFP_VM (1 << 7)
1343#define AV_CPU_FLAG_SETEND (1 <<16)
1344
1346
1347void av_force_cpu_flags(int flags);
1348
1350
1352int av_parse_cpu_flags(const char *s);
1353
1354int av_parse_cpu_caps(unsigned *flags, const char *s);
1355
1357
1358size_t av_cpu_max_align(void);
1359
1360#define AVUTIL_CHANNEL_LAYOUT_H
1361
1362#define AV_CH_FRONT_LEFT 0x00000001
1363#define AV_CH_FRONT_RIGHT 0x00000002
1364#define AV_CH_FRONT_CENTER 0x00000004
1365#define AV_CH_LOW_FREQUENCY 0x00000008
1366#define AV_CH_BACK_LEFT 0x00000010
1367#define AV_CH_BACK_RIGHT 0x00000020
1368#define AV_CH_FRONT_LEFT_OF_CENTER 0x00000040
1369#define AV_CH_FRONT_RIGHT_OF_CENTER 0x00000080
1370#define AV_CH_BACK_CENTER 0x00000100
1371#define AV_CH_SIDE_LEFT 0x00000200
1372#define AV_CH_SIDE_RIGHT 0x00000400
1373#define AV_CH_TOP_CENTER 0x00000800
1374#define AV_CH_TOP_FRONT_LEFT 0x00001000
1375#define AV_CH_TOP_FRONT_CENTER 0x00002000
1376#define AV_CH_TOP_FRONT_RIGHT 0x00004000
1377#define AV_CH_TOP_BACK_LEFT 0x00008000
1378#define AV_CH_TOP_BACK_CENTER 0x00010000
1379#define AV_CH_TOP_BACK_RIGHT 0x00020000
1380#define AV_CH_STEREO_LEFT 0x20000000
1381#define AV_CH_STEREO_RIGHT 0x40000000
1382#define AV_CH_WIDE_LEFT 0x0000000080000000ULL
1383#define AV_CH_WIDE_RIGHT 0x0000000100000000ULL
1384#define AV_CH_SURROUND_DIRECT_LEFT 0x0000000200000000ULL
1385#define AV_CH_SURROUND_DIRECT_RIGHT 0x0000000400000000ULL
1386#define AV_CH_LOW_FREQUENCY_2 0x0000000800000000ULL
1387
1388#define AV_CH_LAYOUT_NATIVE 0x8000000000000000ULL
1389
1390#define AV_CH_LAYOUT_MONO (AV_CH_FRONT_CENTER)
1391#define AV_CH_LAYOUT_STEREO (AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT)
1392#define AV_CH_LAYOUT_2POINT1 (AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY)
1393#define AV_CH_LAYOUT_2_1 (AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER)
1394#define AV_CH_LAYOUT_SURROUND (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER)
1395#define AV_CH_LAYOUT_3POINT1 (AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY)
1396#define AV_CH_LAYOUT_4POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_CENTER)
1397#define AV_CH_LAYOUT_4POINT1 (AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY)
1398#define AV_CH_LAYOUT_2_2 (AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
1399#define AV_CH_LAYOUT_QUAD (AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
1400#define AV_CH_LAYOUT_5POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
1401#define AV_CH_LAYOUT_5POINT1 (AV_CH_LAYOUT_5POINT0|AV_CH_LOW_FREQUENCY)
1402#define AV_CH_LAYOUT_5POINT0_BACK (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
1403#define AV_CH_LAYOUT_5POINT1_BACK (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_LOW_FREQUENCY)
1404#define AV_CH_LAYOUT_6POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_CENTER)
1405#define AV_CH_LAYOUT_6POINT0_FRONT (AV_CH_LAYOUT_2_2|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
1406#define AV_CH_LAYOUT_HEXAGONAL (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_BACK_CENTER)
1407#define AV_CH_LAYOUT_6POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER)
1408#define AV_CH_LAYOUT_6POINT1_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER)
1409#define AV_CH_LAYOUT_6POINT1_FRONT (AV_CH_LAYOUT_6POINT0_FRONT|AV_CH_LOW_FREQUENCY)
1410#define AV_CH_LAYOUT_7POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
1411#define AV_CH_LAYOUT_7POINT0_FRONT (AV_CH_LAYOUT_5POINT0|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
1412#define AV_CH_LAYOUT_7POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
1413#define AV_CH_LAYOUT_7POINT1_WIDE (AV_CH_LAYOUT_5POINT1|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
1414#define AV_CH_LAYOUT_7POINT1_WIDE_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
1415#define AV_CH_LAYOUT_OCTAGONAL (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT)
1416#define AV_CH_LAYOUT_HEXADECAGONAL (AV_CH_LAYOUT_OCTAGONAL|AV_CH_WIDE_LEFT|AV_CH_WIDE_RIGHT|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT|AV_CH_TOP_BACK_CENTER|AV_CH_TOP_FRONT_CENTER|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT)
1417#define AV_CH_LAYOUT_STEREO_DOWNMIX (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT)
1418
1429
1430uint64_t av_get_channel_layout(const char *name);
1431
1432int av_get_extended_channel_layout(const char *name, uint64_t* channel_layout, int* nb_channels);
1433
1434void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout);
1435
1436struct AVBPrint;
1437
1438void av_bprint_channel_layout(struct AVBPrint *bp, int nb_channels, uint64_t channel_layout);
1439
1440int av_get_channel_layout_nb_channels(uint64_t channel_layout);
1441
1442int64_t av_get_default_channel_layout(int nb_channels);
1443
1444int av_get_channel_layout_channel_index(uint64_t channel_layout,
1445 uint64_t channel);
1446
1447uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index);
1448
1449const char *av_get_channel_name(uint64_t channel);
1450
1451const char *av_get_channel_description(uint64_t channel);
1452
1453int av_get_standard_channel_layout(unsigned index, uint64_t *layout,
1454 const char **name);
1455
1456#define AVUTIL_DICT_H
1457
1458#define AV_DICT_MATCH_CASE 1
1459#define AV_DICT_IGNORE_SUFFIX 2
1460
1461#define AV_DICT_DONT_STRDUP_KEY 4
1462
1463#define AV_DICT_DONT_STRDUP_VAL 8
1464
1465#define AV_DICT_DONT_OVERWRITE 16
1466#define AV_DICT_APPEND 32
1467
1468#define AV_DICT_MULTIKEY 64
1469
1470typedef struct AVDictionaryEntry {
1471 char *key;
1472 char *value;
1474
1476
1478 const AVDictionaryEntry *prev, int flags);
1479
1481
1482int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags);
1483
1484int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags);
1485
1487 const char *key_val_sep, const char *pairs_sep,
1488 int flags);
1489
1490int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags);
1491
1493
1494int av_dict_get_string(const AVDictionary *m, char **buffer,
1495 const char key_val_sep, const char pairs_sep);
1496
1497#define AVUTIL_FRAME_H
1498
1500
1502
1504
1506
1508
1510
1512
1514
1516
1518
1520
1522
1524
1526
1528
1530
1532
1534
1536
1538
1540
1542};
1543
1552};
1553
1554typedef struct AVFrameSideData {
1556 uint8_t *data;
1557 int size;
1561
1562typedef struct AVRegionOfInterest {
1563
1564 uint32_t self_size;
1565
1566 int top;
1568 int left;
1570
1573
1574typedef struct AVFrame {
1575#define AV_NUM_DATA_POINTERS 8
1576
1577 uint8_t *data[AV_NUM_DATA_POINTERS];
1578
1580
1581 uint8_t **extended_data;
1582
1583 int width, height;
1584
1585 int nb_samples;
1586
1587 int format;
1588
1589 int key_frame;
1590
1592
1594
1595 int64_t pts;
1596
1598 int64_t pkt_pts;
1599
1600 int64_t pkt_dts;
1601
1603
1605
1606 int quality;
1607
1608 void *opaque;
1609
1611 uint64_t error[AV_NUM_DATA_POINTERS];
1612
1613 int repeat_pict;
1614
1615 int interlaced_frame;
1616
1617 int top_field_first;
1618
1620
1621 int64_t reordered_opaque;
1622
1623 int sample_rate;
1624
1625 uint64_t channel_layout;
1626
1628
1630
1631 int nb_extended_buf;
1632
1634 int nb_side_data;
1635
1636#define AV_FRAME_FLAG_CORRUPT (1 << 0)
1637
1638#define AV_FRAME_FLAG_DISCARD (1 << 2)
1639
1640 int flags;
1641
1643
1645
1647
1649
1651
1652 int64_t best_effort_timestamp;
1653
1654 int64_t pkt_pos;
1655
1656 int64_t pkt_duration;
1657
1659
1661#define FF_DECODE_ERROR_INVALID_BITSTREAM 1
1662#define FF_DECODE_ERROR_MISSING_REFERENCE 2
1663#define FF_DECODE_ERROR_CONCEALMENT_ACTIVE 4
1664#define FF_DECODE_ERROR_DECODE_SLICES 8
1665
1666 int channels;
1667
1668 int pkt_size;
1669
1671 int8_t *qscale_table;
1672
1674 int qstride;
1675
1677 int qscale_type;
1678
1681
1683
1685
1686 size_t crop_top;
1687 size_t crop_bottom;
1688 size_t crop_left;
1689 size_t crop_right;
1690
1693
1699int64_t av_frame_get_pkt_duration (const AVFrame *frame);
1701void av_frame_set_pkt_duration (AVFrame *frame, int64_t val);
1703int64_t av_frame_get_pkt_pos (const AVFrame *frame);
1705void av_frame_set_pkt_pos (AVFrame *frame, int64_t val);
1709void av_frame_set_channel_layout (AVFrame *frame, int64_t val);
1713void av_frame_set_channels (AVFrame *frame, int val);
1717void av_frame_set_sample_rate (AVFrame *frame, int val);
1729void av_frame_set_pkt_size(AVFrame *frame, int val);
1731int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type);
1733int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int type);
1742
1744
1746
1748
1749int av_frame_ref(AVFrame *dst, const AVFrame *src);
1750
1752
1754
1756
1757int av_frame_get_buffer(AVFrame *frame, int align);
1758
1760
1762
1763int av_frame_copy(AVFrame *dst, const AVFrame *src);
1764
1766
1768
1770 enum AVFrameSideDataType type,
1771 int size);
1772
1774 enum AVFrameSideDataType type,
1775 AVBufferRef *buf);
1776
1778 enum AVFrameSideDataType type);
1779
1781
1782enum {
1783
1785};
1786
1787int av_frame_apply_cropping(AVFrame *frame, int flags);
1788
1790
1791#define AVUTIL_HWCONTEXT_H
1792
1805};
1806
1808
1809typedef struct AVHWDeviceContext {
1810
1812
1814
1816
1817 void *hwctx;
1818
1819 void (*free)(struct AVHWDeviceContext *ctx);
1820
1823
1825
1826typedef struct AVHWFramesContext {
1827
1829
1831
1833
1835
1836 void *hwctx;
1837
1838 void (*free)(struct AVHWFramesContext *ctx);
1839
1841
1843
1845
1847
1849
1852
1854
1856
1858
1860
1862
1864 const char *device, AVDictionary *opts, int flags);
1865
1867 enum AVHWDeviceType type,
1868 AVBufferRef *src_ctx, int flags);
1869
1871
1873
1874int av_hwframe_get_buffer(AVBufferRef *hwframe_ctx, AVFrame *frame, int flags);
1875
1876int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags);
1877
1879
1881
1883};
1884
1887 enum AVPixelFormat **formats, int flags);
1888
1890
1892
1894
1897
1901
1903
1905 const void *hwconfig);
1906
1908
1909enum {
1910
1912
1914
1916
1918};
1919
1920int av_hwframe_map(AVFrame *dst, const AVFrame *src, int flags);
1921
1923 enum AVPixelFormat format,
1924 AVBufferRef *derived_device_ctx,
1925 AVBufferRef *source_frame_ctx,
1926 int flags);
1927
1928#define AVCODEC_VERSION_H
1929
1930#define LIBAVCODEC_VERSION_MAJOR 58
1931#define LIBAVCODEC_VERSION_MINOR 54
1932#define LIBAVCODEC_VERSION_MICRO 100
1933
1934#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
1935 LIBAVCODEC_VERSION_MINOR, \
1936 LIBAVCODEC_VERSION_MICRO)
1937#define LIBAVCODEC_VERSION AV_VERSION(LIBAVCODEC_VERSION_MAJOR, \
1938 LIBAVCODEC_VERSION_MINOR, \
1939 LIBAVCODEC_VERSION_MICRO)
1940#define LIBAVCODEC_BUILD LIBAVCODEC_VERSION_INT
1941
1942#define LIBAVCODEC_IDENT "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION)
1943
1944#define FF_API_LOWRES (LIBAVCODEC_VERSION_MAJOR < 59)
1945#define FF_API_DEBUG_MV (LIBAVCODEC_VERSION_MAJOR < 58)
1946#define FF_API_AVCTX_TIMEBASE (LIBAVCODEC_VERSION_MAJOR < 59)
1947#define FF_API_CODED_FRAME (LIBAVCODEC_VERSION_MAJOR < 59)
1948#define FF_API_SIDEDATA_ONLY_PKT (LIBAVCODEC_VERSION_MAJOR < 59)
1949#define FF_API_VDPAU_PROFILE (LIBAVCODEC_VERSION_MAJOR < 59)
1950#define FF_API_CONVERGENCE_DURATION (LIBAVCODEC_VERSION_MAJOR < 59)
1951#define FF_API_AVPICTURE (LIBAVCODEC_VERSION_MAJOR < 59)
1952#define FF_API_AVPACKET_OLD_API (LIBAVCODEC_VERSION_MAJOR < 59)
1953#define FF_API_RTP_CALLBACK (LIBAVCODEC_VERSION_MAJOR < 59)
1954#define FF_API_VBV_DELAY (LIBAVCODEC_VERSION_MAJOR < 59)
1955#define FF_API_CODER_TYPE (LIBAVCODEC_VERSION_MAJOR < 59)
1956#define FF_API_STAT_BITS (LIBAVCODEC_VERSION_MAJOR < 59)
1957#define FF_API_PRIVATE_OPT (LIBAVCODEC_VERSION_MAJOR < 59)
1958#define FF_API_ASS_TIMING (LIBAVCODEC_VERSION_MAJOR < 59)
1959#define FF_API_OLD_BSF (LIBAVCODEC_VERSION_MAJOR < 59)
1960#define FF_API_COPY_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59)
1961#define FF_API_GET_CONTEXT_DEFAULTS (LIBAVCODEC_VERSION_MAJOR < 59)
1962#define FF_API_NVENC_OLD_NAME (LIBAVCODEC_VERSION_MAJOR < 59)
1963#define FF_API_STRUCT_VAAPI_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59)
1964#define FF_API_MERGE_SD_API (LIBAVCODEC_VERSION_MAJOR < 59)
1965#define FF_API_TAG_STRING (LIBAVCODEC_VERSION_MAJOR < 59)
1966#define FF_API_GETCHROMA (LIBAVCODEC_VERSION_MAJOR < 59)
1967#define FF_API_CODEC_GET_SET (LIBAVCODEC_VERSION_MAJOR < 59)
1968#define FF_API_USER_VISIBLE_AVHWACCEL (LIBAVCODEC_VERSION_MAJOR < 59)
1969#define FF_API_LOCKMGR (LIBAVCODEC_VERSION_MAJOR < 59)
1970#define FF_API_NEXT (LIBAVCODEC_VERSION_MAJOR < 59)
1971#define FF_API_UNSANITIZED_BITRATES (LIBAVCODEC_VERSION_MAJOR < 59)
1972
1975
2112#define AV_CODEC_ID_IFF_BYTERUN1 AV_CODEC_ID_IFF_ILBM
2150#define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC
2170
2217
2250
2256
2288
2300
2303
2306
2311
2314
2383
2406
2417
2435
2438
2448
2450
2452
2454
2457};
2458
2459typedef struct AVCodecDescriptor {
2460 enum AVCodecID id;
2461 enum AVMediaType type;
2462
2463 const char *name;
2464
2465 const char *long_name;
2466
2467 int props;
2468
2469 const char *const *mime_types;
2470
2471 const struct AVProfile *profiles;
2473
2474#define AV_CODEC_PROP_INTRA_ONLY (1 << 0)
2475
2476#define AV_CODEC_PROP_LOSSY (1 << 1)
2477
2478#define AV_CODEC_PROP_LOSSLESS (1 << 2)
2479
2480#define AV_CODEC_PROP_REORDER (1 << 3)
2481
2482#define AV_CODEC_PROP_BITMAP_SUB (1 << 16)
2483
2484#define AV_CODEC_PROP_TEXT_SUB (1 << 17)
2485
2486#define AV_INPUT_BUFFER_PADDING_SIZE 64
2487
2488#define AV_INPUT_BUFFER_MIN_SIZE 16384
2489
2491
2499};
2500
2512};
2513
2514typedef struct RcOverride{
2515 int start_frame;
2516 int end_frame;
2517 int qscale;
2518 float quality_factor;
2520
2521#define AV_CODEC_FLAG_UNALIGNED (1 << 0)
2522
2523#define AV_CODEC_FLAG_QSCALE (1 << 1)
2524
2525#define AV_CODEC_FLAG_4MV (1 << 2)
2526
2527#define AV_CODEC_FLAG_OUTPUT_CORRUPT (1 << 3)
2528
2529#define AV_CODEC_FLAG_QPEL (1 << 4)
2530
2531#define AV_CODEC_FLAG_DROPCHANGED (1 << 5)
2532
2533#define AV_CODEC_FLAG_PASS1 (1 << 9)
2534
2535#define AV_CODEC_FLAG_PASS2 (1 << 10)
2536
2537#define AV_CODEC_FLAG_LOOP_FILTER (1 << 11)
2538
2539#define AV_CODEC_FLAG_GRAY (1 << 13)
2540
2541#define AV_CODEC_FLAG_PSNR (1 << 15)
2542
2543#define AV_CODEC_FLAG_TRUNCATED (1 << 16)
2544
2545#define AV_CODEC_FLAG_INTERLACED_DCT (1 << 18)
2546
2547#define AV_CODEC_FLAG_LOW_DELAY (1 << 19)
2548
2549#define AV_CODEC_FLAG_GLOBAL_HEADER (1 << 22)
2550
2551#define AV_CODEC_FLAG_BITEXACT (1 << 23)
2552
2553#define AV_CODEC_FLAG_AC_PRED (1 << 24)
2554
2555#define AV_CODEC_FLAG_INTERLACED_ME (1 << 29)
2556#define AV_CODEC_FLAG_CLOSED_GOP (1U << 31)
2557
2558#define AV_CODEC_FLAG2_FAST (1 << 0)
2559
2560#define AV_CODEC_FLAG2_NO_OUTPUT (1 << 2)
2561
2562#define AV_CODEC_FLAG2_LOCAL_HEADER (1 << 3)
2563
2564#define AV_CODEC_FLAG2_DROP_FRAME_TIMECODE (1 << 13)
2565
2566#define AV_CODEC_FLAG2_CHUNKS (1 << 15)
2567
2568#define AV_CODEC_FLAG2_IGNORE_CROP (1 << 16)
2569
2570#define AV_CODEC_FLAG2_SHOW_ALL (1 << 22)
2571
2572#define AV_CODEC_FLAG2_EXPORT_MVS (1 << 28)
2573
2574#define AV_CODEC_FLAG2_SKIP_MANUAL (1 << 29)
2575
2576#define AV_CODEC_FLAG2_RO_FLUSH_NOOP (1 << 30)
2577
2578#define AV_CODEC_CAP_DRAW_HORIZ_BAND (1 << 0)
2579
2580#define AV_CODEC_CAP_DR1 (1 << 1)
2581#define AV_CODEC_CAP_TRUNCATED (1 << 3)
2582
2583#define AV_CODEC_CAP_DELAY (1 << 5)
2584
2585#define AV_CODEC_CAP_SMALL_LAST_FRAME (1 << 6)
2586
2587#define AV_CODEC_CAP_SUBFRAMES (1 << 8)
2588
2589#define AV_CODEC_CAP_EXPERIMENTAL (1 << 9)
2590
2591#define AV_CODEC_CAP_CHANNEL_CONF (1 << 10)
2592
2593#define AV_CODEC_CAP_FRAME_THREADS (1 << 12)
2594
2595#define AV_CODEC_CAP_SLICE_THREADS (1 << 13)
2596
2597#define AV_CODEC_CAP_PARAM_CHANGE (1 << 14)
2598
2599#define AV_CODEC_CAP_AUTO_THREADS (1 << 15)
2600
2601#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
2602
2603#define AV_CODEC_CAP_AVOID_PROBING (1 << 17)
2604
2605#define AV_CODEC_CAP_INTRA_ONLY 0x40000000
2606
2607#define AV_CODEC_CAP_LOSSLESS 0x80000000
2608
2609#define AV_CODEC_CAP_HARDWARE (1 << 18)
2610
2611#define AV_CODEC_CAP_HYBRID (1 << 19)
2612
2613#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE (1 << 20)
2614
2615typedef struct AVPanScan {
2616
2617 int id;
2618
2619 int width;
2620 int height;
2621
2622 int16_t position[3][2];
2624
2625typedef struct AVCPBProperties {
2626
2627 int max_bitrate;
2628
2629 int min_bitrate;
2630
2631 int avg_bitrate;
2632
2633 int buffer_size;
2634
2635 uint64_t vbv_delay;
2637
2638#define AV_GET_BUFFER_FLAG_REF (1 << 0)
2639
2641
2643
2645
2647
2649
2651
2653
2655
2657
2659
2661
2663
2665
2667
2669
2671
2673
2675
2677
2679
2681
2683
2685
2687
2689
2691
2693
2695
2698
2699#define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS
2700
2701typedef struct AVPacketSideData {
2702 uint8_t *data;
2703 int size;
2706
2707typedef struct AVPacket {
2708
2710
2711 int64_t pts;
2712
2713 int64_t dts;
2714 uint8_t *data;
2715 int size;
2716 int stream_index;
2717
2718 int flags;
2719
2721 int side_data_elems;
2722
2723 int64_t duration;
2724
2725 int64_t pos;
2726
2728 int64_t convergence_duration;
2730#define AV_PKT_FLAG_KEY 0x0001
2731#define AV_PKT_FLAG_CORRUPT 0x0002
2732
2733#define AV_PKT_FLAG_DISCARD 0x0004
2734
2735#define AV_PKT_FLAG_TRUSTED 0x0008
2736
2737#define AV_PKT_FLAG_DISPOSABLE 0x0010
2738
2744};
2745
2746struct AVCodecInternal;
2747
2755};
2756
2757typedef struct AVCodecContext {
2758
2759 const AVClass *av_class;
2760 int log_level_offset;
2761
2762 enum AVMediaType codec_type;
2763 const struct AVCodec *codec;
2764 enum AVCodecID codec_id;
2765
2766 unsigned int codec_tag;
2767
2768 void *priv_data;
2769
2770 struct AVCodecInternal *internal;
2771
2772 void *opaque;
2773
2774 int64_t bit_rate;
2775
2777
2778 int global_quality;
2779
2781#define FF_COMPRESSION_DEFAULT -1
2782
2783 int flags;
2784
2785 int flags2;
2786
2787 uint8_t *extradata;
2788 int extradata_size;
2789
2791
2792 int ticks_per_frame;
2793
2794 int delay;
2795
2796 int width, height;
2797
2799
2800 int gop_size;
2801
2803
2804 void (*draw_horiz_band)(struct AVCodecContext *s,
2805 const AVFrame *src, int offset[AV_NUM_DATA_POINTERS],
2806 int y, int type, int height);
2807
2808 enum AVPixelFormat (*get_format)(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
2809
2810 int max_b_frames;
2811
2812 float b_quant_factor;
2813
2815 int b_frame_strategy;
2816
2817 float b_quant_offset;
2818
2819 int has_b_frames;
2820
2822 int mpeg_quant;
2823
2824 float i_quant_factor;
2825
2826 float i_quant_offset;
2827
2828 float lumi_masking;
2829
2831
2833
2834 float p_masking;
2835
2836 float dark_masking;
2837
2838 int slice_count;
2839
2842#define FF_PRED_LEFT 0
2843#define FF_PRED_PLANE 1
2844#define FF_PRED_MEDIAN 2
2845
2846 int *slice_offset;
2847
2849
2850 int me_cmp;
2851
2852 int me_sub_cmp;
2853
2854 int mb_cmp;
2855
2856 int ildct_cmp;
2857#define FF_CMP_SAD 0
2858#define FF_CMP_SSE 1
2859#define FF_CMP_SATD 2
2860#define FF_CMP_DCT 3
2861#define FF_CMP_PSNR 4
2862#define FF_CMP_BIT 5
2863#define FF_CMP_RD 6
2864#define FF_CMP_ZERO 7
2865#define FF_CMP_VSAD 8
2866#define FF_CMP_VSSE 9
2867#define FF_CMP_NSSE 10
2868#define FF_CMP_W53 11
2869#define FF_CMP_W97 12
2870#define FF_CMP_DCTMAX 13
2871#define FF_CMP_DCT264 14
2872#define FF_CMP_MEDIAN_SAD 15
2873#define FF_CMP_CHROMA 256
2874
2875 int dia_size;
2876
2878
2880 int pre_me;
2881
2882 int me_pre_cmp;
2883
2884 int pre_dia_size;
2885
2887
2888 int me_range;
2889
2890 int slice_flags;
2891#define SLICE_FLAG_CODED_ORDER 0x0001
2892#define SLICE_FLAG_ALLOW_FIELD 0x0002
2893#define SLICE_FLAG_ALLOW_PLANE 0x0004
2894
2895 int mb_decision;
2896#define FF_MB_DECISION_SIMPLE 0
2897#define FF_MB_DECISION_BITS 1
2898#define FF_MB_DECISION_RD 2
2899
2900 uint16_t *intra_matrix;
2901
2902 uint16_t *inter_matrix;
2903
2906
2908 int noise_reduction;
2909
2911
2912 int skip_top;
2913
2914 int skip_bottom;
2915
2916 int mb_lmin;
2917
2918 int mb_lmax;
2919
2922
2923 int bidir_refine;
2924
2926 int brd_scale;
2927
2928 int keyint_min;
2929
2930 int refs;
2931
2933 int chromaoffset;
2934
2935 int mv0_threshold;
2936
2938 int b_sensitivity;
2939
2941
2943
2945
2947
2949
2950 int slices;
2951
2953
2954 int sample_rate;
2955 int channels;
2956
2958
2959 int frame_size;
2960
2961 int frame_number;
2962
2963 int block_align;
2964
2965 int cutoff;
2966
2967 uint64_t channel_layout;
2968
2969 uint64_t request_channel_layout;
2970
2972
2974
2975 int (*get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags);
2976
2979
2980 float qcompress;
2981 float qblur;
2982
2983 int qmin;
2984
2985 int qmax;
2986
2987 int max_qdiff;
2988
2989 int rc_buffer_size;
2990
2993
2994 int64_t rc_max_rate;
2995
2996 int64_t rc_min_rate;
2997
2999
3001
3003
3004#define FF_CODER_TYPE_VLC 0
3005#define FF_CODER_TYPE_AC 1
3006#define FF_CODER_TYPE_RAW 2
3007#define FF_CODER_TYPE_RLE 3
3008
3010 int coder_type;
3011
3013 int context_model;
3014
3017
3020
3022 int frame_skip_exp;
3023
3025 int frame_skip_cmp;
3026
3027 int trellis;
3028
3031
3034
3036 int64_t timecode_frame_start;
3037
3039 void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb);
3040
3042 int rtp_payload_size;
3043
3045 int mv_bits;
3047 int header_bits;
3049 int i_tex_bits;
3051 int p_tex_bits;
3053 int i_count;
3055 int p_count;
3057 int skip_count;
3059 int misc_bits;
3060
3062 int frame_bits;
3063
3064 char *stats_out;
3065
3066 char *stats_in;
3067
3068 int workaround_bugs;
3069#define FF_BUG_AUTODETECT 1
3070#define FF_BUG_XVID_ILACE 4
3071#define FF_BUG_UMP4 8
3072#define FF_BUG_NO_PADDING 16
3073#define FF_BUG_AMV 32
3074#define FF_BUG_QPEL_CHROMA 64
3075#define FF_BUG_STD_QPEL 128
3076#define FF_BUG_QPEL_CHROMA2 256
3077#define FF_BUG_DIRECT_BLOCKSIZE 512
3078#define FF_BUG_EDGE 1024
3079#define FF_BUG_HPEL_CHROMA 2048
3080#define FF_BUG_DC_CLIP 4096
3081#define FF_BUG_MS 8192
3082#define FF_BUG_TRUNCATED 16384
3083#define FF_BUG_IEDGE 32768
3084
3086#define FF_COMPLIANCE_VERY_STRICT 2
3087#define FF_COMPLIANCE_STRICT 1
3088#define FF_COMPLIANCE_NORMAL 0
3089#define FF_COMPLIANCE_UNOFFICIAL -1
3090#define FF_COMPLIANCE_EXPERIMENTAL -2
3091
3093#define FF_EC_GUESS_MVS 1
3094#define FF_EC_DEBLOCK 2
3095#define FF_EC_FAVOR_INTER 256
3096
3097 int debug;
3098#define FF_DEBUG_PICT_INFO 1
3099#define FF_DEBUG_RC 2
3100#define FF_DEBUG_BITSTREAM 4
3101#define FF_DEBUG_MB_TYPE 8
3102#define FF_DEBUG_QP 16
3103
3104#define FF_DEBUG_MV 32
3105#define FF_DEBUG_DCT_COEFF 0x00000040
3106#define FF_DEBUG_SKIP 0x00000080
3107#define FF_DEBUG_STARTCODE 0x00000100
3108#define FF_DEBUG_ER 0x00000400
3109#define FF_DEBUG_MMCO 0x00000800
3110#define FF_DEBUG_BUGS 0x00001000
3111#define FF_DEBUG_VIS_QP 0x00002000
3112#define FF_DEBUG_VIS_MB_TYPE 0x00004000
3113#define FF_DEBUG_BUFFERS 0x00008000
3114#define FF_DEBUG_THREADS 0x00010000
3115#define FF_DEBUG_GREEN_MD 0x00800000
3116#define FF_DEBUG_NOMC 0x01000000
3117
3118 int debug_mv;
3119#define FF_DEBUG_VIS_MV_P_FOR 0x00000001
3120#define FF_DEBUG_VIS_MV_B_FOR 0x00000002
3121#define FF_DEBUG_VIS_MV_B_BACK 0x00000004
3122
3123 int err_recognition;
3124
3125#define AV_EF_CRCCHECK (1<<0)
3126#define AV_EF_BITSTREAM (1<<1)
3127#define AV_EF_BUFFER (1<<2)
3128#define AV_EF_EXPLODE (1<<3)
3129
3130#define AV_EF_IGNORE_ERR (1<<15)
3131#define AV_EF_CAREFUL (1<<16)
3132#define AV_EF_COMPLIANT (1<<17)
3133#define AV_EF_AGGRESSIVE (1<<18)
3134
3135 int64_t reordered_opaque;
3136
3137 const struct AVHWAccel *hwaccel;
3138
3139 void *hwaccel_context;
3140
3141 uint64_t error[AV_NUM_DATA_POINTERS];
3142
3143 int dct_algo;
3144#define FF_DCT_AUTO 0
3145#define FF_DCT_FASTINT 1
3146#define FF_DCT_INT 2
3147#define FF_DCT_MMX 3
3148#define FF_DCT_ALTIVEC 5
3149#define FF_DCT_FAAN 6
3150
3151 int idct_algo;
3152#define FF_IDCT_AUTO 0
3153#define FF_IDCT_INT 1
3154#define FF_IDCT_SIMPLE 2
3155#define FF_IDCT_SIMPLEMMX 3
3156#define FF_IDCT_ARM 7
3157#define FF_IDCT_ALTIVEC 8
3158#define FF_IDCT_SIMPLEARM 10
3159#define FF_IDCT_XVID 14
3160#define FF_IDCT_SIMPLEARMV5TE 16
3161#define FF_IDCT_SIMPLEARMV6 17
3162#define FF_IDCT_FAAN 20
3163#define FF_IDCT_SIMPLENEON 22
3164#define FF_IDCT_NONE 24
3165#define FF_IDCT_SIMPLEAUTO 128
3166
3168
3170
3171 int lowres;
3172
3174
3175 int thread_count;
3176
3177 int thread_type;
3178#define FF_THREAD_FRAME 1
3179#define FF_THREAD_SLICE 2
3180
3182
3184
3185 int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size);
3186
3187 int (*execute2)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count);
3188
3189 int nsse_weight;
3190
3191 int profile;
3192#define FF_PROFILE_UNKNOWN -99
3193#define FF_PROFILE_RESERVED -100
3194
3195#define FF_PROFILE_AAC_MAIN 0
3196#define FF_PROFILE_AAC_LOW 1
3197#define FF_PROFILE_AAC_SSR 2
3198#define FF_PROFILE_AAC_LTP 3
3199#define FF_PROFILE_AAC_HE 4
3200#define FF_PROFILE_AAC_HE_V2 28
3201#define FF_PROFILE_AAC_LD 22
3202#define FF_PROFILE_AAC_ELD 38
3203#define FF_PROFILE_MPEG2_AAC_LOW 128
3204#define FF_PROFILE_MPEG2_AAC_HE 131
3205
3206#define FF_PROFILE_DNXHD 0
3207#define FF_PROFILE_DNXHR_LB 1
3208#define FF_PROFILE_DNXHR_SQ 2
3209#define FF_PROFILE_DNXHR_HQ 3
3210#define FF_PROFILE_DNXHR_HQX 4
3211#define FF_PROFILE_DNXHR_444 5
3212
3213#define FF_PROFILE_DTS 20
3214#define FF_PROFILE_DTS_ES 30
3215#define FF_PROFILE_DTS_96_24 40
3216#define FF_PROFILE_DTS_HD_HRA 50
3217#define FF_PROFILE_DTS_HD_MA 60
3218#define FF_PROFILE_DTS_EXPRESS 70
3219
3220#define FF_PROFILE_MPEG2_422 0
3221#define FF_PROFILE_MPEG2_HIGH 1
3222#define FF_PROFILE_MPEG2_SS 2
3223#define FF_PROFILE_MPEG2_SNR_SCALABLE 3
3224#define FF_PROFILE_MPEG2_MAIN 4
3225#define FF_PROFILE_MPEG2_SIMPLE 5
3226
3227#define FF_PROFILE_H264_CONSTRAINED (1<<9)
3228#define FF_PROFILE_H264_INTRA (1<<11)
3229
3230#define FF_PROFILE_H264_BASELINE 66
3231#define FF_PROFILE_H264_CONSTRAINED_BASELINE (66|FF_PROFILE_H264_CONSTRAINED)
3232#define FF_PROFILE_H264_MAIN 77
3233#define FF_PROFILE_H264_EXTENDED 88
3234#define FF_PROFILE_H264_HIGH 100
3235#define FF_PROFILE_H264_HIGH_10 110
3236#define FF_PROFILE_H264_HIGH_10_INTRA (110|FF_PROFILE_H264_INTRA)
3237#define FF_PROFILE_H264_MULTIVIEW_HIGH 118
3238#define FF_PROFILE_H264_HIGH_422 122
3239#define FF_PROFILE_H264_HIGH_422_INTRA (122|FF_PROFILE_H264_INTRA)
3240#define FF_PROFILE_H264_STEREO_HIGH 128
3241#define FF_PROFILE_H264_HIGH_444 144
3242#define FF_PROFILE_H264_HIGH_444_PREDICTIVE 244
3243#define FF_PROFILE_H264_HIGH_444_INTRA (244|FF_PROFILE_H264_INTRA)
3244#define FF_PROFILE_H264_CAVLC_444 44
3245
3246#define FF_PROFILE_VC1_SIMPLE 0
3247#define FF_PROFILE_VC1_MAIN 1
3248#define FF_PROFILE_VC1_COMPLEX 2
3249#define FF_PROFILE_VC1_ADVANCED 3
3250
3251#define FF_PROFILE_MPEG4_SIMPLE 0
3252#define FF_PROFILE_MPEG4_SIMPLE_SCALABLE 1
3253#define FF_PROFILE_MPEG4_CORE 2
3254#define FF_PROFILE_MPEG4_MAIN 3
3255#define FF_PROFILE_MPEG4_N_BIT 4
3256#define FF_PROFILE_MPEG4_SCALABLE_TEXTURE 5
3257#define FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION 6
3258#define FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE 7
3259#define FF_PROFILE_MPEG4_HYBRID 8
3260#define FF_PROFILE_MPEG4_ADVANCED_REAL_TIME 9
3261#define FF_PROFILE_MPEG4_CORE_SCALABLE 10
3262#define FF_PROFILE_MPEG4_ADVANCED_CODING 11
3263#define FF_PROFILE_MPEG4_ADVANCED_CORE 12
3264#define FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE 13
3265#define FF_PROFILE_MPEG4_SIMPLE_STUDIO 14
3266#define FF_PROFILE_MPEG4_ADVANCED_SIMPLE 15
3267
3268#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0 1
3269#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1 2
3270#define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION 32768
3271#define FF_PROFILE_JPEG2000_DCINEMA_2K 3
3272#define FF_PROFILE_JPEG2000_DCINEMA_4K 4
3273
3274#define FF_PROFILE_VP9_0 0
3275#define FF_PROFILE_VP9_1 1
3276#define FF_PROFILE_VP9_2 2
3277#define FF_PROFILE_VP9_3 3
3278
3279#define FF_PROFILE_HEVC_MAIN 1
3280#define FF_PROFILE_HEVC_MAIN_10 2
3281#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE 3
3282#define FF_PROFILE_HEVC_REXT 4
3283
3284#define FF_PROFILE_AV1_MAIN 0
3285#define FF_PROFILE_AV1_HIGH 1
3286#define FF_PROFILE_AV1_PROFESSIONAL 2
3287
3288#define FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT 0xc0
3289#define FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT 0xc1
3290#define FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT 0xc2
3291#define FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS 0xc3
3292#define FF_PROFILE_MJPEG_JPEG_LS 0xf7
3293
3294#define FF_PROFILE_SBC_MSBC 1
3295
3296#define FF_PROFILE_PRORES_PROXY 0
3297#define FF_PROFILE_PRORES_LT 1
3298#define FF_PROFILE_PRORES_STANDARD 2
3299#define FF_PROFILE_PRORES_HQ 3
3300#define FF_PROFILE_PRORES_4444 4
3301#define FF_PROFILE_PRORES_XQ 5
3302
3303#define FF_PROFILE_ARIB_PROFILE_A 0
3304#define FF_PROFILE_ARIB_PROFILE_C 1
3305
3306 int level;
3307#define FF_LEVEL_UNKNOWN -99
3308
3310
3311 enum AVDiscard skip_idct;
3312
3313 enum AVDiscard skip_frame;
3314
3315 uint8_t *subtitle_header;
3317
3319 uint64_t vbv_delay;
3320
3323
3324 int initial_padding;
3325
3327
3329
3331
3333
3336 int64_t pts_correction_last_pts;
3337 int64_t pts_correction_last_dts;
3338
3339 char *sub_charenc;
3340
3341 int sub_charenc_mode;
3342#define FF_SUB_CHARENC_MODE_DO_NOTHING -1
3343#define FF_SUB_CHARENC_MODE_AUTOMATIC 0
3344#define FF_SUB_CHARENC_MODE_PRE_DECODER 1
3345#define FF_SUB_CHARENC_MODE_IGNORE 2
3346
3347 int skip_alpha;
3348
3349 int seek_preroll;
3350
3351 uint16_t *chroma_intra_matrix;
3352
3353 uint8_t *dump_separator;
3354
3355 char *codec_whitelist;
3356
3357 unsigned properties;
3358#define FF_CODEC_PROPERTY_LOSSLESS 0x00000001
3359#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS 0x00000002
3360
3363
3365
3366 int sub_text_format;
3367#define FF_SUB_TEXT_FMT_ASS 0
3368#define FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS 1
3369
3370 int trailing_padding;
3371
3372 int64_t max_pixels;
3373
3375
3376 int hwaccel_flags;
3377
3378 int apply_cropping;
3379
3381
3384
3389
3394
3397
3402
3407
3412
3413typedef struct AVProfile {
3414 int profile;
3415 const char *name;
3417
3418enum {
3419
3421
3423
3425
3427};
3428
3429typedef struct AVCodecHWConfig {
3430
3432
3434
3437
3439
3440struct AVSubtitle;
3441
3442typedef struct AVCodec {
3443
3444 const char *name;
3445
3446 const char *long_name;
3447 enum AVMediaType type;
3448 enum AVCodecID id;
3449
3450 int capabilities;
3452 const enum AVPixelFormat *pix_fmts;
3453 const int *supported_samplerates;
3454 const enum AVSampleFormat *sample_fmts;
3455 const uint64_t *channel_layouts;
3456 uint8_t max_lowres;
3457 const AVClass *priv_class;
3458 const AVProfile *profiles;
3459
3460 const char *wrapper_name;
3461
3462 int priv_data_size;
3463 struct AVCodec *next;
3464
3466
3467 int (*update_thread_context)(AVCodecContext *dst, const AVCodecContext *src);
3468
3469 const AVCodecDefault *defaults;
3470
3471 void (*init_static_data)(struct AVCodec *codec);
3472
3473 int (*init)(AVCodecContext *);
3474 int (*encode_sub)(AVCodecContext *, uint8_t *buf, int buf_size,
3475 const struct AVSubtitle *sub);
3476
3477 int (*encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame,
3478 int *got_packet_ptr);
3479 int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt);
3480 int (*close)(AVCodecContext *);
3481
3482 int (*send_frame)(AVCodecContext *avctx, const AVFrame *frame);
3483 int (*receive_packet)(AVCodecContext *avctx, AVPacket *avpkt);
3484
3485 int (*receive_frame)(AVCodecContext *avctx, AVFrame *frame);
3486
3487 void (*flush)(AVCodecContext *);
3488
3489 int caps_internal;
3490
3491 const char *bsfs;
3492
3493 const struct AVCodecHWConfigInternal **hw_configs;
3495
3498
3499struct MpegEncContext;
3500
3501const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index);
3502
3503typedef struct AVHWAccel {
3504
3505 const char *name;
3506
3507 enum AVMediaType type;
3508
3509 enum AVCodecID id;
3510
3512
3513 int capabilities;
3514
3515 int (*alloc_frame)(AVCodecContext *avctx, AVFrame *frame);
3516
3517 int (*start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);
3518
3519 int (*decode_params)(AVCodecContext *avctx, int type, const uint8_t *buf, uint32_t buf_size);
3520
3521 int (*decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);
3522
3523 int (*end_frame)(AVCodecContext *avctx);
3524
3526
3527 void (*decode_mb)(struct MpegEncContext *s);
3528
3529 int (*init)(AVCodecContext *avctx);
3530
3531 int (*uninit)(AVCodecContext *avctx);
3532
3533 int priv_data_size;
3534
3535 int caps_internal;
3536
3537 int (*frame_params)(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx);
3539
3540#define AV_HWACCEL_CODEC_CAP_EXPERIMENTAL 0x0200
3541
3542#define AV_HWACCEL_FLAG_IGNORE_LEVEL (1 << 0)
3543
3544#define AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH (1 << 1)
3545
3546#define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH (1 << 2)
3547
3548typedef struct AVPicture {
3550 uint8_t *data[AV_NUM_DATA_POINTERS];
3554
3557
3559
3561
3563};
3564
3565#define AV_SUBTITLE_FLAG_FORCED 0x00000001
3566
3567typedef struct AVSubtitleRect {
3568 int x;
3569 int y;
3570 int w;
3571 int h;
3572 int nb_colors;
3573
3576
3577 uint8_t *data[4];
3578 int linesize[4];
3579
3580 enum AVSubtitleType type;
3581
3582 char *text;
3583
3584 char *ass;
3585
3586 int flags;
3588
3589typedef struct AVSubtitle {
3590 uint16_t format;
3591 uint32_t start_display_time;
3592 uint32_t end_display_time;
3593 unsigned num_rects;
3595 int64_t pts;
3597
3598typedef struct AVCodecParameters {
3599
3601
3602 enum AVCodecID codec_id;
3603
3604 uint32_t codec_tag;
3605
3606 uint8_t *extradata;
3607
3608 int extradata_size;
3609
3610 int format;
3611
3612 int64_t bit_rate;
3613
3615
3617
3618 int profile;
3619 int level;
3620
3621 int width;
3622 int height;
3623
3625
3627
3633
3634 int video_delay;
3635
3636 uint64_t channel_layout;
3637
3638 int channels;
3639
3640 int sample_rate;
3641
3642 int block_align;
3643
3644 int frame_size;
3645
3646 int initial_padding;
3647
3648 int trailing_padding;
3649
3650 int seek_preroll;
3652
3653const AVCodec *av_codec_iterate(void **opaque);
3654
3657
3658unsigned avcodec_version(void);
3659
3660const char *avcodec_configuration(void);
3661
3662const char *avcodec_license(void);
3663
3666
3669
3671
3673
3675
3677
3679
3681
3684
3686
3688
3690
3692 const AVCodecContext *codec);
3693
3695 const AVCodecParameters *par);
3696
3697int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);
3698
3700
3702
3704
3706
3708
3710
3712
3714
3715int av_grow_packet(AVPacket *pkt, int grow_by);
3716
3717int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);
3718
3721
3723int av_copy_packet(AVPacket *dst, const AVPacket *src);
3724
3727
3730
3732 int size);
3733
3735 uint8_t *data, size_t size);
3736
3738 int size);
3739
3741 int *size);
3742
3745
3748
3750
3752
3753int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict);
3754
3756
3757int av_packet_ref(AVPacket *dst, const AVPacket *src);
3758
3760
3762
3764
3766
3768
3770
3772
3774
3776
3777void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height);
3778
3779void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
3780 int linesize_align[AV_NUM_DATA_POINTERS]);
3781
3782int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos);
3783
3785
3788 int *got_frame_ptr, const AVPacket *avpkt);
3789
3792 int *got_picture_ptr,
3793 const AVPacket *avpkt);
3794
3796 int *got_sub_ptr,
3797 AVPacket *avpkt);
3798
3800
3802
3804
3806
3808 AVBufferRef *device_ref,
3809 enum AVPixelFormat hw_pix_fmt,
3810 AVBufferRef **out_frames_ref);
3811
3817};
3818
3819typedef struct AVCodecParserContext {
3820 void *priv_data;
3821 struct AVCodecParser *parser;
3822 int64_t frame_offset;
3823 int64_t cur_offset;
3824
3825 int64_t next_frame_offset;
3826
3827 int pict_type;
3828
3829 int repeat_pict;
3830 int64_t pts;
3831 int64_t dts;
3832
3833 int64_t last_pts;
3834 int64_t last_dts;
3835 int fetch_timestamp;
3836
3837#define AV_PARSER_PTS_NB 4
3842
3843 int flags;
3844#define PARSER_FLAG_COMPLETE_FRAMES 0x0001
3845#define PARSER_FLAG_ONCE 0x0002
3846
3847#define PARSER_FLAG_FETCHED_OFFSET 0x0004
3848#define PARSER_FLAG_USE_CODEC_TS 0x1000
3849
3850 int64_t offset;
3852
3853 int key_frame;
3854
3856 int64_t convergence_duration;
3857
3858 int dts_sync_point;
3859
3861
3862 int pts_dts_delta;
3863
3865
3866 int64_t pos;
3867
3868 int64_t last_pos;
3869
3870 int duration;
3871
3873
3875
3877
3878 int width;
3879 int height;
3880
3881 int coded_width;
3882 int coded_height;
3883
3884 int format;
3886
3887typedef struct AVCodecParser {
3888 int codec_ids[5];
3889 int priv_data_size;
3891
3893 AVCodecContext *avctx,
3894 const uint8_t **poutbuf, int *poutbuf_size,
3895 const uint8_t *buf, int buf_size);
3897 int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size);
3898 struct AVCodecParser *next;
3900
3901const AVCodecParser *av_parser_iterate(void **opaque);
3902
3905
3909
3911 AVCodecContext *avctx,
3912 uint8_t **poutbuf, int *poutbuf_size,
3913 const uint8_t *buf, int buf_size,
3914 int64_t pts, int64_t dts,
3915 int64_t pos);
3916
3918 AVCodecContext *avctx,
3919 uint8_t **poutbuf, int *poutbuf_size,
3920 const uint8_t *buf, int buf_size, int keyframe);
3922
3924
3926
3929 const AVFrame *frame, int *got_packet_ptr);
3930
3933 const AVFrame *frame, int *got_packet_ptr);
3934
3935int