Audacity 3.2.0
ffmpeg-3.4.8-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 <stdarg.h>
6#include <errno.h>
7#include <stdint.h>
8#include <stdlib.h>
9#include <string.h>
10#include <inttypes.h>
11#include <time.h>
12#include <limits.h>
13#include <stdio.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 55
131#define LIBAVUTIL_VERSION_MINOR 78
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_VDPAU (LIBAVUTIL_VERSION_MAJOR < 56)
145#define FF_API_XVMC (LIBAVUTIL_VERSION_MAJOR < 56)
146#define FF_API_OPT_TYPE_METADATA (LIBAVUTIL_VERSION_MAJOR < 56)
147#define FF_API_DLOG (LIBAVUTIL_VERSION_MAJOR < 56)
148#define FF_API_VAAPI (LIBAVUTIL_VERSION_MAJOR < 56)
149#define FF_API_FRAME_QP (LIBAVUTIL_VERSION_MAJOR < 56)
150#define FF_API_PLUS1_MINUS1 (LIBAVUTIL_VERSION_MAJOR < 56)
151#define FF_API_ERROR_FRAME (LIBAVUTIL_VERSION_MAJOR < 56)
152#define FF_API_CRC_BIG_TABLE (LIBAVUTIL_VERSION_MAJOR < 56)
153#define FF_API_PKT_PTS (LIBAVUTIL_VERSION_MAJOR < 56)
154#define FF_API_CRYPTO_SIZE_T (LIBAVUTIL_VERSION_MAJOR < 56)
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 AV_CEIL_RSHIFT(a,b) (!av_builtin_constant_p(b) ? -((-(a)) >> (b)) \
163 : ((a) + (1<<(b)) - 1) >> (b))
164
165#define FF_CEIL_RSHIFT AV_CEIL_RSHIFT
166
167#define FFUDIV(a,b) (((a)>0 ?(a):(a)-(b)+1) / (b))
168#define FFUMOD(a,b) ((a)-(b)*FFUDIV(a,b))
169
170#define FFABS(a) ((a) >= 0 ? (a) : (-(a)))
171#define FFSIGN(a) ((a) > 0 ? 1 : -1)
172
173#define FFNABS(a) ((a) <= 0 ? (a) : (-(a)))
174
175#define FFDIFFSIGN(x,y) (((x)>(y)) - ((x)<(y)))
176
177#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
178#define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
179#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
180#define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
181
182#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
183#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
184
185# define av_ceil_log2 av_ceil_log2_c
186# define av_clip av_clip_c
187# define av_clip64 av_clip64_c
188# define av_clip_uint8 av_clip_uint8_c
189# define av_clip_int8 av_clip_int8_c
190# define av_clip_uint16 av_clip_uint16_c
191# define av_clip_int16 av_clip_int16_c
192# define av_clipl_int32 av_clipl_int32_c
193# define av_clip_intp2 av_clip_intp2_c
194# define av_clip_uintp2 av_clip_uintp2_c
195# define av_mod_uintp2 av_mod_uintp2_c
196# define av_sat_add32 av_sat_add32_c
197# define av_sat_dadd32 av_sat_dadd32_c
198# define av_clipf av_clipf_c
199# define av_clipd av_clipd_c
200# define av_popcount av_popcount_c
201# define av_popcount64 av_popcount64_c
202# define av_parity av_parity_c
203
204av_const int av_log2(unsigned v);
205
206av_const int av_log2_16bit(unsigned v);
207
208static av_always_inline av_const int av_clip_c(int a, int amin, int amax)
209{
210 if (a < amin) return amin;
211 else if (a > amax) return amax;
212 else return a;
213}
214
215static av_always_inline av_const int64_t av_clip64_c(int64_t a, int64_t amin, int64_t amax)
216{
217 if (a < amin) return amin;
218 else if (a > amax) return amax;
219 else return a;
220}
221
223{
224 if (a&(~0xFF)) return (~a)>>31;
225 else return a;
226}
227
229{
230 if ((a+0x80U) & ~0xFF) return (a>>31) ^ 0x7F;
231 else return a;
232}
233
235{
236 if (a&(~0xFFFF)) return (~a)>>31;
237 else return a;
238}
239
241{
242 if ((a+0x8000U) & ~0xFFFF) return (a>>31) ^ 0x7FFF;
243 else return a;
244}
245
247{
248 if ((a+0x80000000u) & ~UINT64_C(0xFFFFFFFF)) return (int32_t)((a>>63) ^ 0x7FFFFFFF);
249 else return (int32_t)a;
250}
251
253{
254 if (((unsigned)a + (1 << p)) & ~((2 << p) - 1))
255 return (a >> 31) ^ ((1 << p) - 1);
256 else
257 return a;
258}
259
260static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
261{
262 if (a & ~((1<<p) - 1)) return (~a) >> 31 & ((1<<p) - 1);
263 else return a;
264}
265
266static av_always_inline av_const unsigned av_mod_uintp2_c(unsigned a, unsigned p)
267{
268 return a & ((1 << p) - 1);
269}
270
271static av_always_inline int av_sat_add32_c(int a, int b)
272{
273 return av_clipl_int32((int64_t)a + b);
274}
275
276static av_always_inline int av_sat_dadd32_c(int a, int b)
277{
278 return av_sat_add32(a, av_sat_add32(b, b));
279}
280
281static av_always_inline av_const float av_clipf_c(float a, float amin, float amax)
282{
283 if (a < amin) return amin;
284 else if (a > amax) return amax;
285 else return a;
286}
287
288static av_always_inline av_const double av_clipd_c(double a, double amin, double amax)
289{
290 if (a < amin) return amin;
291 else if (a > amax) return amax;
292 else return a;
293}
294
296{
297 return av_log2((x - 1U) << 1);
298}
299
301{
302 x -= (x >> 1) & 0x55555555;
303 x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
304 x = (x + (x >> 4)) & 0x0F0F0F0F;
305 x += x >> 8;
306 return (x + (x >> 16)) & 0x3F;
307}
308
310{
311 return av_popcount((uint32_t)x) + av_popcount((uint32_t)(x >> 32));
312}
313
315{
316 return av_popcount(v) & 1;
317}
318
319#define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
320#define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
321
322#define GET_UTF8(val, GET_BYTE, ERROR)\
323 val= (GET_BYTE);\
324 {\
325 uint32_t top = (val & 128) >> 1;\
326 if ((val & 0xc0) == 0x80 || val >= 0xFE)\
327 ERROR\
328 while (val & top) {\
329 int tmp= (GET_BYTE) - 128;\
330 if(tmp>>6)\
331 ERROR\
332 val= (val<<6) + tmp;\
333 top <<= 5;\
334 }\
335 val &= (top << 1) - 1;\
336 }
337
338#define GET_UTF16(val, GET_16BIT, ERROR)\
339 val = GET_16BIT;\
340 {\
341 unsigned int hi = val - 0xD800;\
342 if (hi < 0x800) {\
343 val = GET_16BIT - 0xDC00;\
344 if (val > 0x3FFU || hi > 0x3FFU)\
345 ERROR\
346 val += (hi<<10) + 0x10000;\
347 }\
348 }\
349
350#define PUT_UTF8(val, tmp, PUT_BYTE)\
351 {\
352 int bytes, shift;\
353 uint32_t in = val;\
354 if (in < 0x80) {\
355 tmp = in;\
356 PUT_BYTE\
357 } else {\
358 bytes = (av_log2(in) + 4) / 5;\
359 shift = (bytes - 1) * 6;\
360 tmp = (256 - (256 >> bytes)) | (in >> shift);\
361 PUT_BYTE\
362 while (shift >= 6) {\
363 shift -= 6;\
364 tmp = 0x80 | ((in >> shift) & 0x3f);\
365 PUT_BYTE\
366 }\
367 }\
368 }
369
370#define PUT_UTF16(val, tmp, PUT_16BIT)\
371 {\
372 uint32_t in = val;\
373 if (in < 0x10000) {\
374 tmp = in;\
375 PUT_16BIT\
376 } else {\
377 tmp = 0xD800 | ((in - 0x10000) >> 10);\
378 PUT_16BIT\
379 tmp = 0xDC00 | ((in - 0x10000) & 0x3FF);\
380 PUT_16BIT\
381 }\
382 }\
383
384#define AVUTIL_MEM_H
385
386#define AVUTIL_ERROR_H
387
388#define AVERROR(e) (e)
389#define AVUNERROR(e) (e)
390
391#define FFERRTAG(a, b, c, d) (-(int)MKTAG(a, b, c, d))
392
393#define AVERROR_BSF_NOT_FOUND FFERRTAG(0xF8,'B','S','F')
394#define AVERROR_BUG FFERRTAG( 'B','U','G','!')
395#define AVERROR_BUFFER_TOO_SMALL FFERRTAG( 'B','U','F','S')
396#define AVERROR_DECODER_NOT_FOUND FFERRTAG(0xF8,'D','E','C')
397#define AVERROR_DEMUXER_NOT_FOUND FFERRTAG(0xF8,'D','E','M')
398#define AVERROR_ENCODER_NOT_FOUND FFERRTAG(0xF8,'E','N','C')
399#define AVERROR_EOF FFERRTAG( 'E','O','F',' ')
400#define AVERROR_EXIT FFERRTAG( 'E','X','I','T')
401#define AVERROR_EXTERNAL FFERRTAG( 'E','X','T',' ')
402#define AVERROR_FILTER_NOT_FOUND FFERRTAG(0xF8,'F','I','L')
403#define AVERROR_INVALIDDATA FFERRTAG( 'I','N','D','A')
404#define AVERROR_MUXER_NOT_FOUND FFERRTAG(0xF8,'M','U','X')
405#define AVERROR_OPTION_NOT_FOUND FFERRTAG(0xF8,'O','P','T')
406#define AVERROR_PATCHWELCOME FFERRTAG( 'P','A','W','E')
407#define AVERROR_PROTOCOL_NOT_FOUND FFERRTAG(0xF8,'P','R','O')
408
409#define AVERROR_STREAM_NOT_FOUND FFERRTAG(0xF8,'S','T','R')
410
411#define AVERROR_BUG2 FFERRTAG( 'B','U','G',' ')
412#define AVERROR_UNKNOWN FFERRTAG( 'U','N','K','N')
413#define AVERROR_EXPERIMENTAL (-0x2bb2afa8)
414#define AVERROR_INPUT_CHANGED (-0x636e6701)
415#define AVERROR_OUTPUT_CHANGED (-0x636e6702)
416
417#define AVERROR_HTTP_BAD_REQUEST FFERRTAG(0xF8,'4','0','0')
418#define AVERROR_HTTP_UNAUTHORIZED FFERRTAG(0xF8,'4','0','1')
419#define AVERROR_HTTP_FORBIDDEN FFERRTAG(0xF8,'4','0','3')
420#define AVERROR_HTTP_NOT_FOUND FFERRTAG(0xF8,'4','0','4')
421#define AVERROR_HTTP_OTHER_4XX FFERRTAG(0xF8,'4','X','X')
422#define AVERROR_HTTP_SERVER_ERROR FFERRTAG(0xF8,'5','X','X')
423
424#define AV_ERROR_MAX_STRING_SIZE 64
425
426int av_strerror(int errnum, char *errbuf, size_t errbuf_size);
427
428static inline char *av_make_error_string(char *errbuf, size_t errbuf_size, int errnum)
429{
430 av_strerror(errnum, errbuf, errbuf_size);
431 return errbuf;
432}
433
434#define av_err2str(errnum) \
435 av_make_error_string((char[AV_ERROR_MAX_STRING_SIZE]){0}, AV_ERROR_MAX_STRING_SIZE, errnum)
436
437 #define DECLARE_ALIGNED(n,t,v) t v
438 #define DECLARE_ASM_CONST(n,t,v) static const t v
439
440 #define av_malloc_attrib
441
442 #define av_alloc_size(...)
443
445
447
448av_alloc_size(1, 2) static inline void *av_malloc_array(size_t nmemb, size_t size)
449{
450 if (!size || nmemb >= INT_MAX / size)
451 return NULL;
453}
454
455av_alloc_size(1, 2) static inline void *av_mallocz_array(size_t nmemb, size_t size)
456{
457 if (!size || nmemb >= INT_MAX / size)
458 return NULL;
460}
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_dlog(pctx, ...) do { if (0) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__); } while (0)
751
752#define AV_LOG_SKIP_REPEATED 1
753
754#define AV_LOG_PRINT_LEVEL 2
755
756void av_log_set_flags(int arg);
758
759#define AVUTIL_PIXFMT_H
760
761#define AVPALETTE_SIZE 1024
762#define AVPALETTE_COUNT 256
763
794
799
812
817
822
826
828
837
843
846
849
891
893
899
904
906
908
911
915
917
919
921
923
928
946
965
967
970
973
976
978
983
986
988
991
996
998
1001
1002# define AV_PIX_FMT_NE(be, le) AV_PIX_FMT_##le
1003
1004#define AV_PIX_FMT_RGB32 AV_PIX_FMT_NE(ARGB, BGRA)
1005#define AV_PIX_FMT_RGB32_1 AV_PIX_FMT_NE(RGBA, ABGR)
1006#define AV_PIX_FMT_BGR32 AV_PIX_FMT_NE(ABGR, RGBA)
1007#define AV_PIX_FMT_BGR32_1 AV_PIX_FMT_NE(BGRA, ARGB)
1008#define AV_PIX_FMT_0RGB32 AV_PIX_FMT_NE(0RGB, BGR0)
1009#define AV_PIX_FMT_0BGR32 AV_PIX_FMT_NE(0BGR, RGB0)
1010
1011#define AV_PIX_FMT_GRAY9 AV_PIX_FMT_NE(GRAY9BE, GRAY9LE)
1012#define AV_PIX_FMT_GRAY10 AV_PIX_FMT_NE(GRAY10BE, GRAY10LE)
1013#define AV_PIX_FMT_GRAY12 AV_PIX_FMT_NE(GRAY12BE, GRAY12LE)
1014#define AV_PIX_FMT_GRAY16 AV_PIX_FMT_NE(GRAY16BE, GRAY16LE)
1015#define AV_PIX_FMT_YA16 AV_PIX_FMT_NE(YA16BE, YA16LE)
1016#define AV_PIX_FMT_RGB48 AV_PIX_FMT_NE(RGB48BE, RGB48LE)
1017#define AV_PIX_FMT_RGB565 AV_PIX_FMT_NE(RGB565BE, RGB565LE)
1018#define AV_PIX_FMT_RGB555 AV_PIX_FMT_NE(RGB555BE, RGB555LE)
1019#define AV_PIX_FMT_RGB444 AV_PIX_FMT_NE(RGB444BE, RGB444LE)
1020#define AV_PIX_FMT_RGBA64 AV_PIX_FMT_NE(RGBA64BE, RGBA64LE)
1021#define AV_PIX_FMT_BGR48 AV_PIX_FMT_NE(BGR48BE, BGR48LE)
1022#define AV_PIX_FMT_BGR565 AV_PIX_FMT_NE(BGR565BE, BGR565LE)
1023#define AV_PIX_FMT_BGR555 AV_PIX_FMT_NE(BGR555BE, BGR555LE)
1024#define AV_PIX_FMT_BGR444 AV_PIX_FMT_NE(BGR444BE, BGR444LE)
1025#define AV_PIX_FMT_BGRA64 AV_PIX_FMT_NE(BGRA64BE, BGRA64LE)
1026
1027#define AV_PIX_FMT_YUV420P9 AV_PIX_FMT_NE(YUV420P9BE , YUV420P9LE)
1028#define AV_PIX_FMT_YUV422P9 AV_PIX_FMT_NE(YUV422P9BE , YUV422P9LE)
1029#define AV_PIX_FMT_YUV444P9 AV_PIX_FMT_NE(YUV444P9BE , YUV444P9LE)
1030#define AV_PIX_FMT_YUV420P10 AV_PIX_FMT_NE(YUV420P10BE, YUV420P10LE)
1031#define AV_PIX_FMT_YUV422P10 AV_PIX_FMT_NE(YUV422P10BE, YUV422P10LE)
1032#define AV_PIX_FMT_YUV440P10 AV_PIX_FMT_NE(YUV440P10BE, YUV440P10LE)
1033#define AV_PIX_FMT_YUV444P10 AV_PIX_FMT_NE(YUV444P10BE, YUV444P10LE)
1034#define AV_PIX_FMT_YUV420P12 AV_PIX_FMT_NE(YUV420P12BE, YUV420P12LE)
1035#define AV_PIX_FMT_YUV422P12 AV_PIX_FMT_NE(YUV422P12BE, YUV422P12LE)
1036#define AV_PIX_FMT_YUV440P12 AV_PIX_FMT_NE(YUV440P12BE, YUV440P12LE)
1037#define AV_PIX_FMT_YUV444P12 AV_PIX_FMT_NE(YUV444P12BE, YUV444P12LE)
1038#define AV_PIX_FMT_YUV420P14 AV_PIX_FMT_NE(YUV420P14BE, YUV420P14LE)
1039#define AV_PIX_FMT_YUV422P14 AV_PIX_FMT_NE(YUV422P14BE, YUV422P14LE)
1040#define AV_PIX_FMT_YUV444P14 AV_PIX_FMT_NE(YUV444P14BE, YUV444P14LE)
1041#define AV_PIX_FMT_YUV420P16 AV_PIX_FMT_NE(YUV420P16BE, YUV420P16LE)
1042#define AV_PIX_FMT_YUV422P16 AV_PIX_FMT_NE(YUV422P16BE, YUV422P16LE)
1043#define AV_PIX_FMT_YUV444P16 AV_PIX_FMT_NE(YUV444P16BE, YUV444P16LE)
1044
1045#define AV_PIX_FMT_GBRP9 AV_PIX_FMT_NE(GBRP9BE , GBRP9LE)
1046#define AV_PIX_FMT_GBRP10 AV_PIX_FMT_NE(GBRP10BE, GBRP10LE)
1047#define AV_PIX_FMT_GBRP12 AV_PIX_FMT_NE(GBRP12BE, GBRP12LE)
1048#define AV_PIX_FMT_GBRP14 AV_PIX_FMT_NE(GBRP14BE, GBRP14LE)
1049#define AV_PIX_FMT_GBRP16 AV_PIX_FMT_NE(GBRP16BE, GBRP16LE)
1050#define AV_PIX_FMT_GBRAP10 AV_PIX_FMT_NE(GBRAP10BE, GBRAP10LE)
1051#define AV_PIX_FMT_GBRAP12 AV_PIX_FMT_NE(GBRAP12BE, GBRAP12LE)
1052#define AV_PIX_FMT_GBRAP16 AV_PIX_FMT_NE(GBRAP16BE, GBRAP16LE)
1053
1054#define AV_PIX_FMT_BAYER_BGGR16 AV_PIX_FMT_NE(BAYER_BGGR16BE, BAYER_BGGR16LE)
1055#define AV_PIX_FMT_BAYER_RGGB16 AV_PIX_FMT_NE(BAYER_RGGB16BE, BAYER_RGGB16LE)
1056#define AV_PIX_FMT_BAYER_GBRG16 AV_PIX_FMT_NE(BAYER_GBRG16BE, BAYER_GBRG16LE)
1057#define AV_PIX_FMT_BAYER_GRBG16 AV_PIX_FMT_NE(BAYER_GRBG16BE, BAYER_GRBG16LE)
1058
1059#define AV_PIX_FMT_GBRPF32 AV_PIX_FMT_NE(GBRPF32BE, GBRPF32LE)
1060#define AV_PIX_FMT_GBRAPF32 AV_PIX_FMT_NE(GBRAPF32BE, GBRAPF32LE)
1061
1062#define AV_PIX_FMT_YUVA420P9 AV_PIX_FMT_NE(YUVA420P9BE , YUVA420P9LE)
1063#define AV_PIX_FMT_YUVA422P9 AV_PIX_FMT_NE(YUVA422P9BE , YUVA422P9LE)
1064#define AV_PIX_FMT_YUVA444P9 AV_PIX_FMT_NE(YUVA444P9BE , YUVA444P9LE)
1065#define AV_PIX_FMT_YUVA420P10 AV_PIX_FMT_NE(YUVA420P10BE, YUVA420P10LE)
1066#define AV_PIX_FMT_YUVA422P10 AV_PIX_FMT_NE(YUVA422P10BE, YUVA422P10LE)
1067#define AV_PIX_FMT_YUVA444P10 AV_PIX_FMT_NE(YUVA444P10BE, YUVA444P10LE)
1068#define AV_PIX_FMT_YUVA420P16 AV_PIX_FMT_NE(YUVA420P16BE, YUVA420P16LE)
1069#define AV_PIX_FMT_YUVA422P16 AV_PIX_FMT_NE(YUVA422P16BE, YUVA422P16LE)
1070#define AV_PIX_FMT_YUVA444P16 AV_PIX_FMT_NE(YUVA444P16BE, YUVA444P16LE)
1071
1072#define AV_PIX_FMT_XYZ12 AV_PIX_FMT_NE(XYZ12BE, XYZ12LE)
1073#define AV_PIX_FMT_NV20 AV_PIX_FMT_NE(NV20BE, NV20LE)
1074#define AV_PIX_FMT_AYUV64 AV_PIX_FMT_NE(AYUV64BE, AYUV64LE)
1075#define AV_PIX_FMT_P010 AV_PIX_FMT_NE(P010BE, P010LE)
1076#define AV_PIX_FMT_P016 AV_PIX_FMT_NE(P016BE, P016LE)
1077
1084
1097
1122
1142
1149
1160
1161static inline void *av_x_if_null(const void *p, const void *x)
1162{
1163 return (void *)(intptr_t)(p ? p : x);
1164}
1165
1166unsigned av_int_list_length_for_size(unsigned elsize,
1167 const void *list, uint64_t term) av_pure;
1168
1169#define av_int_list_length(list, term) \
1170 av_int_list_length_for_size(sizeof(*(list)), list, term)
1171
1172FILE *av_fopen_utf8(const char *path, const char *mode);
1173
1175
1176#define AV_FOURCC_MAX_STRING_SIZE 32
1177
1178#define av_fourcc2str(fourcc) av_fourcc_make_string((char[AV_FOURCC_MAX_STRING_SIZE]){0}, fourcc)
1179
1180char *av_fourcc_make_string(char *buf, uint32_t fourcc);
1181
1189
1197
1200
1201const char *av_get_sample_fmt_name(enum AVSampleFormat sample_fmt);
1202
1204
1205enum AVSampleFormat av_get_alt_sample_fmt(enum AVSampleFormat sample_fmt, int planar);
1206
1208
1210
1211char *av_get_sample_fmt_string(char *buf, int buf_size, enum AVSampleFormat sample_fmt);
1212
1214
1216
1217int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples,
1218 enum AVSampleFormat sample_fmt, int align);
1219
1220int av_samples_fill_arrays(uint8_t **audio_data, int *linesize,
1221 const uint8_t *buf,
1222 int nb_channels, int nb_samples,
1223 enum AVSampleFormat sample_fmt, int align);
1224
1225int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels,
1226 int nb_samples, enum AVSampleFormat sample_fmt, int align);
1227
1228int av_samples_alloc_array_and_samples(uint8_t ***audio_data, int *linesize, int nb_channels,
1229 int nb_samples, enum AVSampleFormat sample_fmt, int align);
1230
1231int av_samples_copy(uint8_t **dst, uint8_t * const *src, int dst_offset,
1232 int src_offset, int nb_samples, int nb_channels,
1233 enum AVSampleFormat sample_fmt);
1234
1235int av_samples_set_silence(uint8_t **audio_data, int offset, int nb_samples,
1236 int nb_channels, enum AVSampleFormat sample_fmt);
1237
1238#define AVUTIL_BUFFER_H
1239
1240typedef struct AVBuffer AVBuffer;
1241
1242typedef struct AVBufferRef {
1244
1245 uint8_t *data;
1246
1247 int size;
1249
1251
1253
1254#define AV_BUFFER_FLAG_READONLY (1 << 0)
1255
1257 void (*free)(void *opaque, uint8_t *data),
1258 void *opaque, int flags);
1259
1260void av_buffer_default_free(void *opaque, uint8_t *data);
1261
1263
1265
1267
1269
1271
1273
1275
1277
1279
1281 AVBufferRef* (*alloc)(void *opaque, int size),
1282 void (*pool_free)(void *opaque));
1283
1285
1287
1288#define AVUTIL_CPU_H
1289
1290#define AV_CPU_FLAG_FORCE 0x80000000
1291
1292#define AV_CPU_FLAG_MMX 0x0001
1293#define AV_CPU_FLAG_MMXEXT 0x0002
1294#define AV_CPU_FLAG_MMX2 0x0002
1295#define AV_CPU_FLAG_3DNOW 0x0004
1296#define AV_CPU_FLAG_SSE 0x0008
1297#define AV_CPU_FLAG_SSE2 0x0010
1298#define AV_CPU_FLAG_SSE2SLOW 0x40000000
1299
1300#define AV_CPU_FLAG_3DNOWEXT 0x0020
1301#define AV_CPU_FLAG_SSE3 0x0040
1302#define AV_CPU_FLAG_SSE3SLOW 0x20000000
1303
1304#define AV_CPU_FLAG_SSSE3 0x0080
1305#define AV_CPU_FLAG_SSSE3SLOW 0x4000000
1306#define AV_CPU_FLAG_ATOM 0x10000000
1307#define AV_CPU_FLAG_SSE4 0x0100
1308#define AV_CPU_FLAG_SSE42 0x0200
1309#define AV_CPU_FLAG_AESNI 0x80000
1310#define AV_CPU_FLAG_AVX 0x4000
1311#define AV_CPU_FLAG_AVXSLOW 0x8000000
1312#define AV_CPU_FLAG_XOP 0x0400
1313#define AV_CPU_FLAG_FMA4 0x0800
1314#define AV_CPU_FLAG_CMOV 0x1000
1315#define AV_CPU_FLAG_AVX2 0x8000
1316#define AV_CPU_FLAG_FMA3 0x10000
1317#define AV_CPU_FLAG_BMI1 0x20000
1318#define AV_CPU_FLAG_BMI2 0x40000
1319
1320#define AV_CPU_FLAG_ALTIVEC 0x0001
1321#define AV_CPU_FLAG_VSX 0x0002
1322#define AV_CPU_FLAG_POWER8 0x0004
1323
1324#define AV_CPU_FLAG_ARMV5TE (1 << 0)
1325#define AV_CPU_FLAG_ARMV6 (1 << 1)
1326#define AV_CPU_FLAG_ARMV6T2 (1 << 2)
1327#define AV_CPU_FLAG_VFP (1 << 3)
1328#define AV_CPU_FLAG_VFPV3 (1 << 4)
1329#define AV_CPU_FLAG_NEON (1 << 5)
1330#define AV_CPU_FLAG_ARMV8 (1 << 6)
1331#define AV_CPU_FLAG_VFP_VM (1 << 7)
1332#define AV_CPU_FLAG_SETEND (1 <<16)
1333
1335
1336void av_force_cpu_flags(int flags);
1337
1339
1341int av_parse_cpu_flags(const char *s);
1342
1343int av_parse_cpu_caps(unsigned *flags, const char *s);
1344
1346
1347size_t av_cpu_max_align(void);
1348
1349#define AVUTIL_CHANNEL_LAYOUT_H
1350
1351#define AV_CH_FRONT_LEFT 0x00000001
1352#define AV_CH_FRONT_RIGHT 0x00000002
1353#define AV_CH_FRONT_CENTER 0x00000004
1354#define AV_CH_LOW_FREQUENCY 0x00000008
1355#define AV_CH_BACK_LEFT 0x00000010
1356#define AV_CH_BACK_RIGHT 0x00000020
1357#define AV_CH_FRONT_LEFT_OF_CENTER 0x00000040
1358#define AV_CH_FRONT_RIGHT_OF_CENTER 0x00000080
1359#define AV_CH_BACK_CENTER 0x00000100
1360#define AV_CH_SIDE_LEFT 0x00000200
1361#define AV_CH_SIDE_RIGHT 0x00000400
1362#define AV_CH_TOP_CENTER 0x00000800
1363#define AV_CH_TOP_FRONT_LEFT 0x00001000
1364#define AV_CH_TOP_FRONT_CENTER 0x00002000
1365#define AV_CH_TOP_FRONT_RIGHT 0x00004000
1366#define AV_CH_TOP_BACK_LEFT 0x00008000
1367#define AV_CH_TOP_BACK_CENTER 0x00010000
1368#define AV_CH_TOP_BACK_RIGHT 0x00020000
1369#define AV_CH_STEREO_LEFT 0x20000000
1370#define AV_CH_STEREO_RIGHT 0x40000000
1371#define AV_CH_WIDE_LEFT 0x0000000080000000ULL
1372#define AV_CH_WIDE_RIGHT 0x0000000100000000ULL
1373#define AV_CH_SURROUND_DIRECT_LEFT 0x0000000200000000ULL
1374#define AV_CH_SURROUND_DIRECT_RIGHT 0x0000000400000000ULL
1375#define AV_CH_LOW_FREQUENCY_2 0x0000000800000000ULL
1376
1377#define AV_CH_LAYOUT_NATIVE 0x8000000000000000ULL
1378
1379#define AV_CH_LAYOUT_MONO (AV_CH_FRONT_CENTER)
1380#define AV_CH_LAYOUT_STEREO (AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT)
1381#define AV_CH_LAYOUT_2POINT1 (AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY)
1382#define AV_CH_LAYOUT_2_1 (AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER)
1383#define AV_CH_LAYOUT_SURROUND (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER)
1384#define AV_CH_LAYOUT_3POINT1 (AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY)
1385#define AV_CH_LAYOUT_4POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_CENTER)
1386#define AV_CH_LAYOUT_4POINT1 (AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY)
1387#define AV_CH_LAYOUT_2_2 (AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
1388#define AV_CH_LAYOUT_QUAD (AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
1389#define AV_CH_LAYOUT_5POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
1390#define AV_CH_LAYOUT_5POINT1 (AV_CH_LAYOUT_5POINT0|AV_CH_LOW_FREQUENCY)
1391#define AV_CH_LAYOUT_5POINT0_BACK (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
1392#define AV_CH_LAYOUT_5POINT1_BACK (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_LOW_FREQUENCY)
1393#define AV_CH_LAYOUT_6POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_CENTER)
1394#define AV_CH_LAYOUT_6POINT0_FRONT (AV_CH_LAYOUT_2_2|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
1395#define AV_CH_LAYOUT_HEXAGONAL (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_BACK_CENTER)
1396#define AV_CH_LAYOUT_6POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER)
1397#define AV_CH_LAYOUT_6POINT1_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER)
1398#define AV_CH_LAYOUT_6POINT1_FRONT (AV_CH_LAYOUT_6POINT0_FRONT|AV_CH_LOW_FREQUENCY)
1399#define AV_CH_LAYOUT_7POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
1400#define AV_CH_LAYOUT_7POINT0_FRONT (AV_CH_LAYOUT_5POINT0|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
1401#define AV_CH_LAYOUT_7POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
1402#define AV_CH_LAYOUT_7POINT1_WIDE (AV_CH_LAYOUT_5POINT1|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
1403#define AV_CH_LAYOUT_7POINT1_WIDE_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
1404#define AV_CH_LAYOUT_OCTAGONAL (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT)
1405#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)
1406#define AV_CH_LAYOUT_STEREO_DOWNMIX (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT)
1407
1418
1419uint64_t av_get_channel_layout(const char *name);
1420
1421int av_get_extended_channel_layout(const char *name, uint64_t* channel_layout, int* nb_channels);
1422
1423void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout);
1424
1425struct AVBPrint;
1426
1427void av_bprint_channel_layout(struct AVBPrint *bp, int nb_channels, uint64_t channel_layout);
1428
1429int av_get_channel_layout_nb_channels(uint64_t channel_layout);
1430
1431int64_t av_get_default_channel_layout(int nb_channels);
1432
1433int av_get_channel_layout_channel_index(uint64_t channel_layout,
1434 uint64_t channel);
1435
1436uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index);
1437
1438const char *av_get_channel_name(uint64_t channel);
1439
1440const char *av_get_channel_description(uint64_t channel);
1441
1442int av_get_standard_channel_layout(unsigned index, uint64_t *layout,
1443 const char **name);
1444
1445#define AVUTIL_DICT_H
1446
1447#define AV_DICT_MATCH_CASE 1
1448#define AV_DICT_IGNORE_SUFFIX 2
1449
1450#define AV_DICT_DONT_STRDUP_KEY 4
1451
1452#define AV_DICT_DONT_STRDUP_VAL 8
1453
1454#define AV_DICT_DONT_OVERWRITE 16
1455#define AV_DICT_APPEND 32
1456
1457#define AV_DICT_MULTIKEY 64
1458
1459typedef struct AVDictionaryEntry {
1460 char *key;
1461 char *value;
1463
1465
1467 const AVDictionaryEntry *prev, int flags);
1468
1470
1471int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags);
1472
1473int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags);
1474
1476 const char *key_val_sep, const char *pairs_sep,
1477 int flags);
1478
1479int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags);
1480
1482
1483int av_dict_get_string(const AVDictionary *m, char **buffer,
1484 const char key_val_sep, const char pairs_sep);
1485
1486#define AVUTIL_FRAME_H
1487
1489
1491
1493
1495
1497
1499
1501
1503
1505
1507
1509
1511
1513
1515
1517
1519
1521};
1522
1531};
1532
1533typedef struct AVFrameSideData {
1535 uint8_t *data;
1536 int size;
1540
1541typedef struct AVFrame {
1542#define AV_NUM_DATA_POINTERS 8
1543
1544 uint8_t *data[AV_NUM_DATA_POINTERS];
1545
1547
1548 uint8_t **extended_data;
1549
1550 int width, height;
1551
1552 int nb_samples;
1553
1554 int format;
1555
1556 int key_frame;
1557
1559
1561
1562 int64_t pts;
1563
1565 int64_t pkt_pts;
1566
1567 int64_t pkt_dts;
1568
1570
1572
1573 int quality;
1574
1575 void *opaque;
1576
1579
1580 int repeat_pict;
1581
1582 int interlaced_frame;
1583
1584 int top_field_first;
1585
1587
1588 int64_t reordered_opaque;
1589
1590 int sample_rate;
1591
1592 uint64_t channel_layout;
1593
1595
1597
1598 int nb_extended_buf;
1599
1601 int nb_side_data;
1602
1603#define AV_FRAME_FLAG_CORRUPT (1 << 0)
1604
1605#define AV_FRAME_FLAG_DISCARD (1 << 2)
1606
1607 int flags;
1608
1610
1612
1614
1616
1618
1619 int64_t best_effort_timestamp;
1620
1621 int64_t pkt_pos;
1622
1623 int64_t pkt_duration;
1624
1626
1628#define FF_DECODE_ERROR_INVALID_BITSTREAM 1
1629#define FF_DECODE_ERROR_MISSING_REFERENCE 2
1630
1631 int channels;
1632
1633 int pkt_size;
1634
1636 int8_t *qscale_table;
1637
1639 int qstride;
1640
1642 int qscale_type;
1643
1645
1647
1649
1650 size_t crop_top;
1654
1656
1659int64_t av_frame_get_pkt_duration (const AVFrame *frame);
1660void av_frame_set_pkt_duration (AVFrame *frame, int64_t val);
1661int64_t av_frame_get_pkt_pos (const AVFrame *frame);
1662void av_frame_set_pkt_pos (AVFrame *frame, int64_t val);
1664void av_frame_set_channel_layout (AVFrame *frame, int64_t val);
1666void av_frame_set_channels (AVFrame *frame, int val);
1668void av_frame_set_sample_rate (AVFrame *frame, int val);
1674void av_frame_set_pkt_size(AVFrame *frame, int val);
1676int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type);
1677int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int type);
1682
1684
1686
1688
1689int av_frame_ref(AVFrame *dst, const AVFrame *src);
1690
1692
1694
1696
1697int av_frame_get_buffer(AVFrame *frame, int align);
1698
1700
1702
1703int av_frame_copy(AVFrame *dst, const AVFrame *src);
1704
1706
1708
1710 enum AVFrameSideDataType type,
1711 int size);
1712
1714 enum AVFrameSideDataType type);
1715
1717
1718enum {
1719
1721};
1722
1723int av_frame_apply_cropping(AVFrame *frame, int flags);
1724
1726
1727#define AVCODEC_VERSION_H
1728
1729#define LIBAVCODEC_VERSION_MAJOR 57
1730#define LIBAVCODEC_VERSION_MINOR 107
1731#define LIBAVCODEC_VERSION_MICRO 100
1732
1733#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
1734 LIBAVCODEC_VERSION_MINOR, \
1735 LIBAVCODEC_VERSION_MICRO)
1736#define LIBAVCODEC_VERSION AV_VERSION(LIBAVCODEC_VERSION_MAJOR, \
1737 LIBAVCODEC_VERSION_MINOR, \
1738 LIBAVCODEC_VERSION_MICRO)
1739#define LIBAVCODEC_BUILD LIBAVCODEC_VERSION_INT
1740
1741#define LIBAVCODEC_IDENT "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION)
1742
1743#define FF_API_VIMA_DECODER (LIBAVCODEC_VERSION_MAJOR < 58)
1744#define FF_API_AUDIO_CONVERT (LIBAVCODEC_VERSION_MAJOR < 58)
1745#define FF_API_AVCODEC_RESAMPLE FF_API_AUDIO_CONVERT
1746#define FF_API_MISSING_SAMPLE (LIBAVCODEC_VERSION_MAJOR < 58)
1747#define FF_API_LOWRES (LIBAVCODEC_VERSION_MAJOR < 58)
1748#define FF_API_CAP_VDPAU (LIBAVCODEC_VERSION_MAJOR < 58)
1749#define FF_API_BUFS_VDPAU (LIBAVCODEC_VERSION_MAJOR < 58)
1750#define FF_API_VOXWARE (LIBAVCODEC_VERSION_MAJOR < 58)
1751#define FF_API_SET_DIMENSIONS (LIBAVCODEC_VERSION_MAJOR < 58)
1752#define FF_API_DEBUG_MV (LIBAVCODEC_VERSION_MAJOR < 58)
1753#define FF_API_AC_VLC (LIBAVCODEC_VERSION_MAJOR < 58)
1754#define FF_API_OLD_MSMPEG4 (LIBAVCODEC_VERSION_MAJOR < 58)
1755#define FF_API_ASPECT_EXTENDED (LIBAVCODEC_VERSION_MAJOR < 58)
1756#define FF_API_ARCH_ALPHA (LIBAVCODEC_VERSION_MAJOR < 58)
1757#define FF_API_ERROR_RATE (LIBAVCODEC_VERSION_MAJOR < 58)
1758#define FF_API_QSCALE_TYPE (LIBAVCODEC_VERSION_MAJOR < 58)
1759#define FF_API_MB_TYPE (LIBAVCODEC_VERSION_MAJOR < 58)
1760#define FF_API_MAX_BFRAMES (LIBAVCODEC_VERSION_MAJOR < 58)
1761#define FF_API_NEG_LINESIZES (LIBAVCODEC_VERSION_MAJOR < 58)
1762#define FF_API_EMU_EDGE (LIBAVCODEC_VERSION_MAJOR < 58)
1763#define FF_API_ARCH_SH4 (LIBAVCODEC_VERSION_MAJOR < 58)
1764#define FF_API_ARCH_SPARC (LIBAVCODEC_VERSION_MAJOR < 58)
1765#define FF_API_UNUSED_MEMBERS (LIBAVCODEC_VERSION_MAJOR < 58)
1766#define FF_API_IDCT_XVIDMMX (LIBAVCODEC_VERSION_MAJOR < 58)
1767#define FF_API_INPUT_PRESERVED (LIBAVCODEC_VERSION_MAJOR < 58)
1768#define FF_API_NORMALIZE_AQP (LIBAVCODEC_VERSION_MAJOR < 58)
1769#define FF_API_GMC (LIBAVCODEC_VERSION_MAJOR < 58)
1770#define FF_API_MV0 (LIBAVCODEC_VERSION_MAJOR < 58)
1771#define FF_API_CODEC_NAME (LIBAVCODEC_VERSION_MAJOR < 58)
1772#define FF_API_AFD (LIBAVCODEC_VERSION_MAJOR < 58)
1773
1774#define FF_API_VISMV (LIBAVCODEC_VERSION_MAJOR < 58)
1775#define FF_API_AUDIOENC_DELAY (LIBAVCODEC_VERSION_MAJOR < 58)
1776#define FF_API_VAAPI_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 58)
1777#define FF_API_MERGE_SD (LIBAVCODEC_VERSION_MAJOR < 58)
1778#define FF_API_AVCTX_TIMEBASE (LIBAVCODEC_VERSION_MAJOR < 59)
1779#define FF_API_MPV_OPT (LIBAVCODEC_VERSION_MAJOR < 59)
1780#define FF_API_STREAM_CODEC_TAG (LIBAVCODEC_VERSION_MAJOR < 59)
1781#define FF_API_QUANT_BIAS (LIBAVCODEC_VERSION_MAJOR < 59)
1782#define FF_API_RC_STRATEGY (LIBAVCODEC_VERSION_MAJOR < 59)
1783#define FF_API_CODED_FRAME (LIBAVCODEC_VERSION_MAJOR < 59)
1784#define FF_API_MOTION_EST (LIBAVCODEC_VERSION_MAJOR < 59)
1785#define FF_API_WITHOUT_PREFIX (LIBAVCODEC_VERSION_MAJOR < 59)
1786#define FF_API_SIDEDATA_ONLY_PKT (LIBAVCODEC_VERSION_MAJOR < 59)
1787#define FF_API_VDPAU_PROFILE (LIBAVCODEC_VERSION_MAJOR < 59)
1788#define FF_API_CONVERGENCE_DURATION (LIBAVCODEC_VERSION_MAJOR < 59)
1789#define FF_API_AVPICTURE (LIBAVCODEC_VERSION_MAJOR < 59)
1790#define FF_API_AVPACKET_OLD_API (LIBAVCODEC_VERSION_MAJOR < 59)
1791#define FF_API_RTP_CALLBACK (LIBAVCODEC_VERSION_MAJOR < 59)
1792#define FF_API_VBV_DELAY (LIBAVCODEC_VERSION_MAJOR < 59)
1793#define FF_API_CODER_TYPE (LIBAVCODEC_VERSION_MAJOR < 59)
1794#define FF_API_STAT_BITS (LIBAVCODEC_VERSION_MAJOR < 59)
1795#define FF_API_PRIVATE_OPT (LIBAVCODEC_VERSION_MAJOR < 59)
1796#define FF_API_ASS_TIMING (LIBAVCODEC_VERSION_MAJOR < 59)
1797#define FF_API_OLD_BSF (LIBAVCODEC_VERSION_MAJOR < 59)
1798#define FF_API_COPY_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59)
1799#define FF_API_GET_CONTEXT_DEFAULTS (LIBAVCODEC_VERSION_MAJOR < 59)
1800#define FF_API_NVENC_OLD_NAME (LIBAVCODEC_VERSION_MAJOR < 59)
1801#define FF_API_STRUCT_VAAPI_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59)
1802#define FF_API_MERGE_SD_API (LIBAVCODEC_VERSION_MAJOR < 59)
1803#define FF_API_TAG_STRING (LIBAVCODEC_VERSION_MAJOR < 59)
1804#define FF_API_GETCHROMA (LIBAVCODEC_VERSION_MAJOR < 59)
1805
1808
1946#define AV_CODEC_ID_IFF_BYTERUN1 AV_CODEC_ID_IFF_ILBM
1984#define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC
2003
2040
2073
2078
2111
2122
2125
2128
2133
2136
2205
2223
2234
2250
2253
2263
2265
2267
2269
2272};
2273
2274typedef struct AVCodecDescriptor {
2275 enum AVCodecID id;
2276 enum AVMediaType type;
2277
2278 const char *name;
2279
2280 const char *long_name;
2281
2282 int props;
2283
2284 const char *const *mime_types;
2285
2286 const struct AVProfile *profiles;
2288
2289#define AV_CODEC_PROP_INTRA_ONLY (1 << 0)
2290
2291#define AV_CODEC_PROP_LOSSY (1 << 1)
2292
2293#define AV_CODEC_PROP_LOSSLESS (1 << 2)
2294
2295#define AV_CODEC_PROP_REORDER (1 << 3)
2296
2297#define AV_CODEC_PROP_BITMAP_SUB (1 << 16)
2298
2299#define AV_CODEC_PROP_TEXT_SUB (1 << 17)
2300
2301#define AV_INPUT_BUFFER_PADDING_SIZE 32
2302
2303#define AV_INPUT_BUFFER_MIN_SIZE 16384
2304
2305#define FF_INPUT_BUFFER_PADDING_SIZE 32
2306
2307#define FF_MIN_BUFFER_SIZE 16384
2308
2320};
2321
2323
2331};
2332
2344};
2345
2346typedef struct RcOverride{
2347 int start_frame;
2348 int end_frame;
2349 int qscale;
2350 float quality_factor;
2352
2353#define FF_MAX_B_FRAMES 16
2354
2355#define AV_CODEC_FLAG_UNALIGNED (1 << 0)
2356
2357#define AV_CODEC_FLAG_QSCALE (1 << 1)
2358
2359#define AV_CODEC_FLAG_4MV (1 << 2)
2360
2361#define AV_CODEC_FLAG_OUTPUT_CORRUPT (1 << 3)
2362
2363#define AV_CODEC_FLAG_QPEL (1 << 4)
2364
2365#define AV_CODEC_FLAG_PASS1 (1 << 9)
2366
2367#define AV_CODEC_FLAG_PASS2 (1 << 10)
2368
2369#define AV_CODEC_FLAG_LOOP_FILTER (1 << 11)
2370
2371#define AV_CODEC_FLAG_GRAY (1 << 13)
2372
2373#define AV_CODEC_FLAG_PSNR (1 << 15)
2374
2375#define AV_CODEC_FLAG_TRUNCATED (1 << 16)
2376
2377#define AV_CODEC_FLAG_INTERLACED_DCT (1 << 18)
2378
2379#define AV_CODEC_FLAG_LOW_DELAY (1 << 19)
2380
2381#define AV_CODEC_FLAG_GLOBAL_HEADER (1 << 22)
2382
2383#define AV_CODEC_FLAG_BITEXACT (1 << 23)
2384
2385#define AV_CODEC_FLAG_AC_PRED (1 << 24)
2386
2387#define AV_CODEC_FLAG_INTERLACED_ME (1 << 29)
2388#define AV_CODEC_FLAG_CLOSED_GOP (1U << 31)
2389
2390#define AV_CODEC_FLAG2_FAST (1 << 0)
2391
2392#define AV_CODEC_FLAG2_NO_OUTPUT (1 << 2)
2393
2394#define AV_CODEC_FLAG2_LOCAL_HEADER (1 << 3)
2395
2396#define AV_CODEC_FLAG2_DROP_FRAME_TIMECODE (1 << 13)
2397
2398#define AV_CODEC_FLAG2_CHUNKS (1 << 15)
2399
2400#define AV_CODEC_FLAG2_IGNORE_CROP (1 << 16)
2401
2402#define AV_CODEC_FLAG2_SHOW_ALL (1 << 22)
2403
2404#define AV_CODEC_FLAG2_EXPORT_MVS (1 << 28)
2405
2406#define AV_CODEC_FLAG2_SKIP_MANUAL (1 << 29)
2407
2408#define AV_CODEC_FLAG2_RO_FLUSH_NOOP (1 << 30)
2409
2410#define AV_CODEC_CAP_DRAW_HORIZ_BAND (1 << 0)
2411
2412#define AV_CODEC_CAP_DR1 (1 << 1)
2413#define AV_CODEC_CAP_TRUNCATED (1 << 3)
2414
2415#define AV_CODEC_CAP_DELAY (1 << 5)
2416
2417#define AV_CODEC_CAP_SMALL_LAST_FRAME (1 << 6)
2418
2419#define AV_CODEC_CAP_HWACCEL_VDPAU (1 << 7)
2420
2421#define AV_CODEC_CAP_SUBFRAMES (1 << 8)
2422
2423#define AV_CODEC_CAP_EXPERIMENTAL (1 << 9)
2424
2425#define AV_CODEC_CAP_CHANNEL_CONF (1 << 10)
2426
2427#define AV_CODEC_CAP_FRAME_THREADS (1 << 12)
2428
2429#define AV_CODEC_CAP_SLICE_THREADS (1 << 13)
2430
2431#define AV_CODEC_CAP_PARAM_CHANGE (1 << 14)
2432
2433#define AV_CODEC_CAP_AUTO_THREADS (1 << 15)
2434
2435#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
2436
2437#define AV_CODEC_CAP_AVOID_PROBING (1 << 17)
2438
2439#define AV_CODEC_CAP_INTRA_ONLY 0x40000000
2440
2441#define AV_CODEC_CAP_LOSSLESS 0x80000000
2442
2443#define CODEC_FLAG_UNALIGNED AV_CODEC_FLAG_UNALIGNED
2444#define CODEC_FLAG_QSCALE AV_CODEC_FLAG_QSCALE
2445#define CODEC_FLAG_4MV AV_CODEC_FLAG_4MV
2446#define CODEC_FLAG_OUTPUT_CORRUPT AV_CODEC_FLAG_OUTPUT_CORRUPT
2447#define CODEC_FLAG_QPEL AV_CODEC_FLAG_QPEL
2448
2449#define CODEC_FLAG_GMC 0x0020
2450
2451#define CODEC_FLAG_MV0 0x0040
2452
2453#define CODEC_FLAG_INPUT_PRESERVED 0x0100
2454#define CODEC_FLAG_PASS1 AV_CODEC_FLAG_PASS1
2455#define CODEC_FLAG_PASS2 AV_CODEC_FLAG_PASS2
2456#define CODEC_FLAG_GRAY AV_CODEC_FLAG_GRAY
2457
2458#define CODEC_FLAG_EMU_EDGE 0x4000
2459#define CODEC_FLAG_PSNR AV_CODEC_FLAG_PSNR
2460#define CODEC_FLAG_TRUNCATED AV_CODEC_FLAG_TRUNCATED
2461
2462#define CODEC_FLAG_NORMALIZE_AQP 0x00020000
2463#define CODEC_FLAG_INTERLACED_DCT AV_CODEC_FLAG_INTERLACED_DCT
2464#define CODEC_FLAG_LOW_DELAY AV_CODEC_FLAG_LOW_DELAY
2465#define CODEC_FLAG_GLOBAL_HEADER AV_CODEC_FLAG_GLOBAL_HEADER
2466#define CODEC_FLAG_BITEXACT AV_CODEC_FLAG_BITEXACT
2467#define CODEC_FLAG_AC_PRED AV_CODEC_FLAG_AC_PRED
2468#define CODEC_FLAG_LOOP_FILTER AV_CODEC_FLAG_LOOP_FILTER
2469#define CODEC_FLAG_INTERLACED_ME AV_CODEC_FLAG_INTERLACED_ME
2470#define CODEC_FLAG_CLOSED_GOP AV_CODEC_FLAG_CLOSED_GOP
2471#define CODEC_FLAG2_FAST AV_CODEC_FLAG2_FAST
2472#define CODEC_FLAG2_NO_OUTPUT AV_CODEC_FLAG2_NO_OUTPUT
2473#define CODEC_FLAG2_LOCAL_HEADER AV_CODEC_FLAG2_LOCAL_HEADER
2474#define CODEC_FLAG2_DROP_FRAME_TIMECODE AV_CODEC_FLAG2_DROP_FRAME_TIMECODE
2475#define CODEC_FLAG2_IGNORE_CROP AV_CODEC_FLAG2_IGNORE_CROP
2476
2477#define CODEC_FLAG2_CHUNKS AV_CODEC_FLAG2_CHUNKS
2478#define CODEC_FLAG2_SHOW_ALL AV_CODEC_FLAG2_SHOW_ALL
2479#define CODEC_FLAG2_EXPORT_MVS AV_CODEC_FLAG2_EXPORT_MVS
2480#define CODEC_FLAG2_SKIP_MANUAL AV_CODEC_FLAG2_SKIP_MANUAL
2481
2482#define CODEC_CAP_DRAW_HORIZ_BAND AV_CODEC_CAP_DRAW_HORIZ_BAND
2483
2484#define CODEC_CAP_DR1 AV_CODEC_CAP_DR1
2485#define CODEC_CAP_TRUNCATED AV_CODEC_CAP_TRUNCATED
2486
2487#define CODEC_CAP_HWACCEL 0x0010
2488
2489#define CODEC_CAP_DELAY AV_CODEC_CAP_DELAY
2490
2491#define CODEC_CAP_SMALL_LAST_FRAME AV_CODEC_CAP_SMALL_LAST_FRAME
2492
2493#define CODEC_CAP_HWACCEL_VDPAU AV_CODEC_CAP_HWACCEL_VDPAU
2494
2495#define CODEC_CAP_SUBFRAMES AV_CODEC_CAP_SUBFRAMES
2496
2497#define CODEC_CAP_EXPERIMENTAL AV_CODEC_CAP_EXPERIMENTAL
2498
2499#define CODEC_CAP_CHANNEL_CONF AV_CODEC_CAP_CHANNEL_CONF
2500
2501#define CODEC_CAP_NEG_LINESIZES 0x0800
2502
2503#define CODEC_CAP_FRAME_THREADS AV_CODEC_CAP_FRAME_THREADS
2504
2505#define CODEC_CAP_SLICE_THREADS AV_CODEC_CAP_SLICE_THREADS
2506
2507#define CODEC_CAP_PARAM_CHANGE AV_CODEC_CAP_PARAM_CHANGE
2508
2509#define CODEC_CAP_AUTO_THREADS AV_CODEC_CAP_AUTO_THREADS
2510
2511#define CODEC_CAP_VARIABLE_FRAME_SIZE AV_CODEC_CAP_VARIABLE_FRAME_SIZE
2512
2513#define CODEC_CAP_INTRA_ONLY AV_CODEC_CAP_INTRA_ONLY
2514
2515#define CODEC_CAP_LOSSLESS AV_CODEC_CAP_LOSSLESS
2516
2517#define HWACCEL_CODEC_CAP_EXPERIMENTAL 0x0200
2518
2519#define MB_TYPE_INTRA4x4 0x0001
2520#define MB_TYPE_INTRA16x16 0x0002
2521#define MB_TYPE_INTRA_PCM 0x0004
2522#define MB_TYPE_16x16 0x0008
2523#define MB_TYPE_16x8 0x0010
2524#define MB_TYPE_8x16 0x0020
2525#define MB_TYPE_8x8 0x0040
2526#define MB_TYPE_INTERLACED 0x0080
2527#define MB_TYPE_DIRECT2 0x0100
2528#define MB_TYPE_ACPRED 0x0200
2529#define MB_TYPE_GMC 0x0400
2530#define MB_TYPE_SKIP 0x0800
2531#define MB_TYPE_P0L0 0x1000
2532#define MB_TYPE_P1L0 0x2000
2533#define MB_TYPE_P0L1 0x4000
2534#define MB_TYPE_P1L1 0x8000
2535#define MB_TYPE_L0 (MB_TYPE_P0L0 | MB_TYPE_P1L0)
2536#define MB_TYPE_L1 (MB_TYPE_P0L1 | MB_TYPE_P1L1)
2537#define MB_TYPE_L0L1 (MB_TYPE_L0 | MB_TYPE_L1)
2538#define MB_TYPE_QUANT 0x00010000
2539#define MB_TYPE_CBP 0x00020000
2540
2541typedef struct AVPanScan{
2542
2543 int id;
2544
2545 int width;
2546 int height;
2547
2548 int16_t position[3][2];
2550
2551typedef struct AVCPBProperties {
2552
2554
2556
2558
2560
2561 uint64_t vbv_delay;
2563
2564#define FF_QSCALE_TYPE_MPEG1 0
2565#define FF_QSCALE_TYPE_MPEG2 1
2566#define FF_QSCALE_TYPE_H264 2
2567#define FF_QSCALE_TYPE_VP56 3
2568
2569#define AV_GET_BUFFER_FLAG_REF (1 << 0)
2570
2572
2574
2576
2578
2580
2582
2584
2586
2588
2590
2592
2594
2596
2598
2600
2602
2604
2606
2608
2610
2612
2614
2616
2618
2620
2623
2624#define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS
2625
2626typedef struct AVPacketSideData {
2627 uint8_t *data;
2628 int size;
2631
2632typedef struct AVPacket {
2633
2635
2636 int64_t pts;
2637
2638 int64_t dts;
2639 uint8_t *data;
2640 int size;
2641 int stream_index;
2642
2643 int flags;
2644
2646 int side_data_elems;
2647
2648 int64_t duration;
2649
2650 int64_t pos;
2651
2655#define AV_PKT_FLAG_KEY 0x0001
2656#define AV_PKT_FLAG_CORRUPT 0x0002
2657
2658#define AV_PKT_FLAG_DISCARD 0x0004
2659
2660#define AV_PKT_FLAG_TRUSTED 0x0008
2661
2667};
2668
2669struct AVCodecInternal;
2670
2678};
2679
2680typedef struct AVCodecContext {
2681
2682 const AVClass *av_class;
2683 int log_level_offset;
2684
2685 enum AVMediaType codec_type;
2686 const struct AVCodec *codec;
2687
2689 char codec_name[32];
2690 enum AVCodecID codec_id;
2691
2692 unsigned int codec_tag;
2693
2695 unsigned int stream_codec_tag;
2696
2697 void *priv_data;
2698
2699 struct AVCodecInternal *internal;
2700
2701 void *opaque;
2702
2703 int64_t bit_rate;
2704
2706
2707 int global_quality;
2708
2710#define FF_COMPRESSION_DEFAULT -1
2711
2712 int flags;
2713
2714 int flags2;
2715
2716 uint8_t *extradata;
2717 int extradata_size;
2718
2720
2721 int ticks_per_frame;
2722
2723 int delay;
2724
2725 int width, height;
2726
2728
2729#define FF_ASPECT_EXTENDED 15
2730
2731 int gop_size;
2732
2734
2736
2737 void (*draw_horiz_band)(struct AVCodecContext *s,
2738 const AVFrame *src, int offset[AV_NUM_DATA_POINTERS],
2739 int y, int type, int height);
2740
2741 enum AVPixelFormat (*get_format)(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
2742
2743 int max_b_frames;
2744
2745 float b_quant_factor;
2746
2748#define FF_RC_STRATEGY_XVID 1
2749
2752
2753 float b_quant_offset;
2754
2755 int has_b_frames;
2756
2759
2760 float i_quant_factor;
2761
2762 float i_quant_offset;
2763
2764 float lumi_masking;
2765
2767
2769
2770 float p_masking;
2771
2772 float dark_masking;
2773
2774 int slice_count;
2775
2778#define FF_PRED_LEFT 0
2779#define FF_PRED_PLANE 1
2780#define FF_PRED_MEDIAN 2
2781
2782 int *slice_offset;
2783
2785
2786 int me_cmp;
2787
2788 int me_sub_cmp;
2789
2790 int mb_cmp;
2791
2792 int ildct_cmp;
2793#define FF_CMP_SAD 0
2794#define FF_CMP_SSE 1
2795#define FF_CMP_SATD 2
2796#define FF_CMP_DCT 3
2797#define FF_CMP_PSNR 4
2798#define FF_CMP_BIT 5
2799#define FF_CMP_RD 6
2800#define FF_CMP_ZERO 7
2801#define FF_CMP_VSAD 8
2802#define FF_CMP_VSSE 9
2803#define FF_CMP_NSSE 10
2804#define FF_CMP_W53 11
2805#define FF_CMP_W97 12
2806#define FF_CMP_DCTMAX 13
2807#define FF_CMP_DCT264 14
2808#define FF_CMP_MEDIAN_SAD 15
2809#define FF_CMP_CHROMA 256
2810
2811 int dia_size;
2812
2814
2817
2818 int me_pre_cmp;
2819
2820 int pre_dia_size;
2821
2823
2825#define FF_DTG_AFD_SAME 8
2826#define FF_DTG_AFD_4_3 9
2827#define FF_DTG_AFD_16_9 10
2828#define FF_DTG_AFD_14_9 11
2829#define FF_DTG_AFD_4_3_SP_14_9 13
2830#define FF_DTG_AFD_16_9_SP_14_9 14
2831#define FF_DTG_AFD_SP_4_3 15
2832
2833 int me_range;
2834
2836#define FF_DEFAULT_QUANT_BIAS 999999
2837
2839
2840 int slice_flags;
2841#define SLICE_FLAG_CODED_ORDER 0x0001
2842#define SLICE_FLAG_ALLOW_FIELD 0x0002
2843#define SLICE_FLAG_ALLOW_PLANE 0x0004
2844
2846
2847 int mb_decision;
2848#define FF_MB_DECISION_SIMPLE 0
2849#define FF_MB_DECISION_BITS 1
2850#define FF_MB_DECISION_RD 2
2851
2852 uint16_t *intra_matrix;
2853
2854 uint16_t *inter_matrix;
2855
2858
2861
2864
2867
2869
2870 int skip_top;
2871
2872 int skip_bottom;
2873
2876
2877 int mb_lmin;
2878
2879 int mb_lmax;
2880
2883
2884 int bidir_refine;
2885
2888
2889 int keyint_min;
2890
2891 int refs;
2892
2895
2897
2898 int mv0_threshold;
2899
2902
2904
2906
2908
2910
2912
2913 int slices;
2914
2916
2917 int sample_rate;
2918 int channels;
2919
2921
2922 int frame_size;
2923
2924 int frame_number;
2925
2926 int block_align;
2927
2928 int cutoff;
2929
2930 uint64_t channel_layout;
2931
2932 uint64_t request_channel_layout;
2933
2935
2937
2938 int (*get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags);
2939
2942
2943 float qcompress;
2944 float qblur;
2945
2946 int qmin;
2947
2948 int qmax;
2949
2950 int max_qdiff;
2951
2954
2959
2960 int rc_buffer_size;
2961
2964
2966 const char *rc_eq;
2967
2969
2971
2974
2977
2979
2981
2983
2984#define FF_CODER_TYPE_VLC 0
2985#define FF_CODER_TYPE_AC 1
2986#define FF_CODER_TYPE_RAW 2
2987#define FF_CODER_TYPE_RLE 3
2988#define FF_CODER_TYPE_DEFLATE 4
2989
2992
2995
2997 int lmin;
2998
3000 int lmax;
3001
3004
3007
3010
3013
3014 int trellis;
3015
3018
3021
3024
3026 void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb);
3027
3030
3047
3050
3051 char *stats_out;
3052
3053 char *stats_in;
3054
3055 int workaround_bugs;
3056#define FF_BUG_AUTODETECT 1
3057#define FF_BUG_OLD_MSMPEG4 2
3058#define FF_BUG_XVID_ILACE 4
3059#define FF_BUG_UMP4 8
3060#define FF_BUG_NO_PADDING 16
3061#define FF_BUG_AMV 32
3062#define FF_BUG_AC_VLC 0
3063#define FF_BUG_QPEL_CHROMA 64
3064#define FF_BUG_STD_QPEL 128
3065#define FF_BUG_QPEL_CHROMA2 256
3066#define FF_BUG_DIRECT_BLOCKSIZE 512
3067#define FF_BUG_EDGE 1024
3068#define FF_BUG_HPEL_CHROMA 2048
3069#define FF_BUG_DC_CLIP 4096
3070#define FF_BUG_MS 8192
3071#define FF_BUG_TRUNCATED 16384
3072#define FF_BUG_IEDGE 32768
3073
3075#define FF_COMPLIANCE_VERY_STRICT 2
3076#define FF_COMPLIANCE_STRICT 1
3077#define FF_COMPLIANCE_NORMAL 0
3078#define FF_COMPLIANCE_UNOFFICIAL -1
3079#define FF_COMPLIANCE_EXPERIMENTAL -2
3080
3082#define FF_EC_GUESS_MVS 1
3083#define FF_EC_DEBLOCK 2
3084#define FF_EC_FAVOR_INTER 256
3085
3086 int debug;
3087#define FF_DEBUG_PICT_INFO 1
3088#define FF_DEBUG_RC 2
3089#define FF_DEBUG_BITSTREAM 4
3090#define FF_DEBUG_MB_TYPE 8
3091#define FF_DEBUG_QP 16
3092
3093#define FF_DEBUG_MV 32
3094#define FF_DEBUG_DCT_COEFF 0x00000040
3095#define FF_DEBUG_SKIP 0x00000080
3096#define FF_DEBUG_STARTCODE 0x00000100
3097#define FF_DEBUG_PTS 0x00000200
3098#define FF_DEBUG_ER 0x00000400
3099#define FF_DEBUG_MMCO 0x00000800
3100#define FF_DEBUG_BUGS 0x00001000
3101#define FF_DEBUG_VIS_QP 0x00002000
3102#define FF_DEBUG_VIS_MB_TYPE 0x00004000
3103#define FF_DEBUG_BUFFERS 0x00008000
3104#define FF_DEBUG_THREADS 0x00010000
3105#define FF_DEBUG_GREEN_MD 0x00800000
3106#define FF_DEBUG_NOMC 0x01000000
3107
3108 int debug_mv;
3109#define FF_DEBUG_VIS_MV_P_FOR 0x00000001
3110#define FF_DEBUG_VIS_MV_B_FOR 0x00000002
3111#define FF_DEBUG_VIS_MV_B_BACK 0x00000004
3112
3113 int err_recognition;
3114
3115#define AV_EF_CRCCHECK (1<<0)
3116#define AV_EF_BITSTREAM (1<<1)
3117#define AV_EF_BUFFER (1<<2)
3118#define AV_EF_EXPLODE (1<<3)
3119
3120#define AV_EF_IGNORE_ERR (1<<15)
3121#define AV_EF_CAREFUL (1<<16)
3122#define AV_EF_COMPLIANT (1<<17)
3123#define AV_EF_AGGRESSIVE (1<<18)
3124
3125 int64_t reordered_opaque;
3126
3127 struct AVHWAccel *hwaccel;
3128
3129 void *hwaccel_context;
3130
3131 uint64_t error[AV_NUM_DATA_POINTERS];
3132
3133 int dct_algo;
3134#define FF_DCT_AUTO 0
3135#define FF_DCT_FASTINT 1
3136#define FF_DCT_INT 2
3137#define FF_DCT_MMX 3
3138#define FF_DCT_ALTIVEC 5
3139#define FF_DCT_FAAN 6
3140
3141 int idct_algo;
3142#define FF_IDCT_AUTO 0
3143#define FF_IDCT_INT 1
3144#define FF_IDCT_SIMPLE 2
3145#define FF_IDCT_SIMPLEMMX 3
3146#define FF_IDCT_ARM 7
3147#define FF_IDCT_ALTIVEC 8
3148#define FF_IDCT_SH4 9
3149#define FF_IDCT_SIMPLEARM 10
3150#define FF_IDCT_IPP 13
3151#define FF_IDCT_XVID 14
3152#define FF_IDCT_XVIDMMX 14
3153#define FF_IDCT_SIMPLEARMV5TE 16
3154#define FF_IDCT_SIMPLEARMV6 17
3155#define FF_IDCT_SIMPLEVIS 18
3156#define FF_IDCT_FAAN 20
3157#define FF_IDCT_SIMPLENEON 22
3158#define FF_IDCT_SIMPLEALPHA 23
3159#define FF_IDCT_NONE 24
3160#define FF_IDCT_SIMPLEAUTO 128
3161
3163
3165
3166 int lowres;
3167
3169
3170 int thread_count;
3171
3172 int thread_type;
3173#define FF_THREAD_FRAME 1
3174#define FF_THREAD_SLICE 2
3175
3177
3179
3180 int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size);
3181
3182 int (*execute2)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count);
3183
3184 int nsse_weight;
3185
3186 int profile;
3187#define FF_PROFILE_UNKNOWN -99
3188#define FF_PROFILE_RESERVED -100
3189
3190#define FF_PROFILE_AAC_MAIN 0
3191#define FF_PROFILE_AAC_LOW 1
3192#define FF_PROFILE_AAC_SSR 2
3193#define FF_PROFILE_AAC_LTP 3
3194#define FF_PROFILE_AAC_HE 4
3195#define FF_PROFILE_AAC_HE_V2 28
3196#define FF_PROFILE_AAC_LD 22
3197#define FF_PROFILE_AAC_ELD 38
3198#define FF_PROFILE_MPEG2_AAC_LOW 128
3199#define FF_PROFILE_MPEG2_AAC_HE 131
3200
3201#define FF_PROFILE_DNXHD 0
3202#define FF_PROFILE_DNXHR_LB 1
3203#define FF_PROFILE_DNXHR_SQ 2
3204#define FF_PROFILE_DNXHR_HQ 3
3205#define FF_PROFILE_DNXHR_HQX 4
3206#define FF_PROFILE_DNXHR_444 5
3207
3208#define FF_PROFILE_DTS 20
3209#define FF_PROFILE_DTS_ES 30
3210#define FF_PROFILE_DTS_96_24 40
3211#define FF_PROFILE_DTS_HD_HRA 50
3212#define FF_PROFILE_DTS_HD_MA 60
3213#define FF_PROFILE_DTS_EXPRESS 70
3214
3215#define FF_PROFILE_MPEG2_422 0
3216#define FF_PROFILE_MPEG2_HIGH 1
3217#define FF_PROFILE_MPEG2_SS 2
3218#define FF_PROFILE_MPEG2_SNR_SCALABLE 3
3219#define FF_PROFILE_MPEG2_MAIN 4
3220#define FF_PROFILE_MPEG2_SIMPLE 5
3221
3222#define FF_PROFILE_H264_CONSTRAINED (1<<9)
3223#define FF_PROFILE_H264_INTRA (1<<11)
3224
3225#define FF_PROFILE_H264_BASELINE 66
3226#define FF_PROFILE_H264_CONSTRAINED_BASELINE (66|FF_PROFILE_H264_CONSTRAINED)
3227#define FF_PROFILE_H264_MAIN 77
3228#define FF_PROFILE_H264_EXTENDED 88
3229#define FF_PROFILE_H264_HIGH 100
3230#define FF_PROFILE_H264_HIGH_10 110
3231#define FF_PROFILE_H264_HIGH_10_INTRA (110|FF_PROFILE_H264_INTRA)
3232#define FF_PROFILE_H264_MULTIVIEW_HIGH 118
3233#define FF_PROFILE_H264_HIGH_422 122
3234#define FF_PROFILE_H264_HIGH_422_INTRA (122|FF_PROFILE_H264_INTRA)
3235#define FF_PROFILE_H264_STEREO_HIGH 128
3236#define FF_PROFILE_H264_HIGH_444 144
3237#define FF_PROFILE_H264_HIGH_444_PREDICTIVE 244
3238#define FF_PROFILE_H264_HIGH_444_INTRA (244|FF_PROFILE_H264_INTRA)
3239#define FF_PROFILE_H264_CAVLC_444 44
3240
3241#define FF_PROFILE_VC1_SIMPLE 0
3242#define FF_PROFILE_VC1_MAIN 1
3243#define FF_PROFILE_VC1_COMPLEX 2
3244#define FF_PROFILE_VC1_ADVANCED 3
3245
3246#define FF_PROFILE_MPEG4_SIMPLE 0
3247#define FF_PROFILE_MPEG4_SIMPLE_SCALABLE 1
3248#define FF_PROFILE_MPEG4_CORE 2
3249#define FF_PROFILE_MPEG4_MAIN 3
3250#define FF_PROFILE_MPEG4_N_BIT 4
3251#define FF_PROFILE_MPEG4_SCALABLE_TEXTURE 5
3252#define FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION 6
3253#define FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE 7
3254#define FF_PROFILE_MPEG4_HYBRID 8
3255#define FF_PROFILE_MPEG4_ADVANCED_REAL_TIME 9
3256#define FF_PROFILE_MPEG4_CORE_SCALABLE 10
3257#define FF_PROFILE_MPEG4_ADVANCED_CODING 11
3258#define FF_PROFILE_MPEG4_ADVANCED_CORE 12
3259#define FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE 13
3260#define FF_PROFILE_MPEG4_SIMPLE_STUDIO 14
3261#define FF_PROFILE_MPEG4_ADVANCED_SIMPLE 15
3262
3263#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0 1
3264#define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1 2
3265#define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION 32768
3266#define FF_PROFILE_JPEG2000_DCINEMA_2K 3
3267#define FF_PROFILE_JPEG2000_DCINEMA_4K 4
3268
3269#define FF_PROFILE_VP9_0 0
3270#define FF_PROFILE_VP9_1 1
3271#define FF_PROFILE_VP9_2 2
3272#define FF_PROFILE_VP9_3 3
3273
3274#define FF_PROFILE_HEVC_MAIN 1
3275#define FF_PROFILE_HEVC_MAIN_10 2
3276#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE 3
3277#define FF_PROFILE_HEVC_REXT 4
3278
3279 int level;
3280#define FF_LEVEL_UNKNOWN -99
3281
3283
3284 enum AVDiscard skip_idct;
3285
3286 enum AVDiscard skip_frame;
3287
3288 uint8_t *subtitle_header;
3290
3292 int error_rate;
3293
3295 uint64_t vbv_delay;
3296
3299
3301
3303
3305
3307
3309
3312 int64_t pts_correction_last_pts;
3313 int64_t pts_correction_last_dts;
3314
3315 char *sub_charenc;
3316
3317 int sub_charenc_mode;
3318#define FF_SUB_CHARENC_MODE_DO_NOTHING -1
3319#define FF_SUB_CHARENC_MODE_AUTOMATIC 0
3320#define FF_SUB_CHARENC_MODE_PRE_DECODER 1
3321
3322 int skip_alpha;
3323
3324 int seek_preroll;
3325
3326 uint16_t *chroma_intra_matrix;
3327
3329
3331
3332 unsigned properties;
3333#define FF_CODEC_PROPERTY_LOSSLESS 0x00000001
3334#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS 0x00000002
3335
3338
3340
3342#define FF_SUB_TEXT_FMT_ASS 0
3343#define FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS 1
3344
3346
3347 int64_t max_pixels;
3348
3350
3352
3355
3358
3361
3363
3366
3369
3372
3373typedef struct AVProfile {
3374 int profile;
3375 const char *name;
3377
3379
3380struct AVSubtitle;
3381
3382typedef struct AVCodec {
3383
3384 const char *name;
3385
3386 const char *long_name;
3387 enum AVMediaType type;
3388 enum AVCodecID id;
3389
3390 int capabilities;
3392 const enum AVPixelFormat *pix_fmts;
3393 const int *supported_samplerates;
3394 const enum AVSampleFormat *sample_fmts;
3395 const uint64_t *channel_layouts;
3396 uint8_t max_lowres;
3397 const AVClass *priv_class;
3398 const AVProfile *profiles;
3399
3400 int priv_data_size;
3401 struct AVCodec *next;
3402
3404
3405 int (*update_thread_context)(AVCodecContext *dst, const AVCodecContext *src);
3406
3407 const AVCodecDefault *defaults;
3408
3409 void (*init_static_data)(struct AVCodec *codec);
3410
3411 int (*init)(AVCodecContext *);
3412 int (*encode_sub)(AVCodecContext *, uint8_t *buf, int buf_size,
3413 const struct AVSubtitle *sub);
3414
3415 int (*encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame,
3416 int *got_packet_ptr);
3417 int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt);
3418 int (*close)(AVCodecContext *);
3419
3420 int (*send_frame)(AVCodecContext *avctx, const AVFrame *frame);
3422
3423 int (*receive_frame)(AVCodecContext *avctx, AVFrame *frame);
3424
3425 void (*flush)(AVCodecContext *);
3426
3428
3429 const char *bsfs;
3431
3433
3434struct MpegEncContext;
3435
3436typedef struct AVHWAccel {
3437
3438 const char *name;
3439
3440 enum AVMediaType type;
3441
3442 enum AVCodecID id;
3443
3445
3446 int capabilities;
3447
3448 struct AVHWAccel *next;
3449
3450 int (*alloc_frame)(AVCodecContext *avctx, AVFrame *frame);
3451
3452 int (*start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);
3453
3454 int (*decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);
3455
3456 int (*end_frame)(AVCodecContext *avctx);
3457
3459
3460 void (*decode_mb)(struct MpegEncContext *s);
3461
3462 int (*init)(AVCodecContext *avctx);
3463
3464 int (*uninit)(AVCodecContext *avctx);
3465
3466 int priv_data_size;
3467
3470
3471#define AV_HWACCEL_CODEC_CAP_EXPERIMENTAL 0x0200
3472
3473#define AV_HWACCEL_FLAG_IGNORE_LEVEL (1 << 0)
3474
3475#define AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH (1 << 1)
3476
3477#define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH (1 << 2)
3478
3479typedef struct AVPicture {
3485
3488
3490
3492
3494};
3495
3496#define AV_SUBTITLE_FLAG_FORCED 0x00000001
3497
3498typedef struct AVSubtitleRect {
3499 int x;
3500 int y;
3501 int w;
3502 int h;
3503 int nb_colors;
3504
3507
3508 uint8_t *data[4];
3509 int linesize[4];
3510
3511 enum AVSubtitleType type;
3512
3513 char *text;
3514
3515 char *ass;
3516
3517 int flags;
3519
3520typedef struct AVSubtitle {
3521 uint16_t format;
3522 uint32_t start_display_time;
3523 uint32_t end_display_time;
3524 unsigned num_rects;
3526 int64_t pts;
3528
3529typedef struct AVCodecParameters {
3530
3532
3534
3535 uint32_t codec_tag;
3536
3537 uint8_t *extradata;
3538
3540
3542
3543 int64_t bit_rate;
3544
3546
3548
3551
3554
3556
3558
3564
3566
3568
3570
3572
3574
3576
3578
3580
3583
3585
3586unsigned avcodec_version(void);
3587
3588const char *avcodec_configuration(void);
3589
3590const char *avcodec_license(void);
3591
3593
3595
3597
3599
3601
3603
3605
3607
3610
3612
3614
3616
3618 const AVCodecContext *codec);
3619
3621 const AVCodecParameters *par);
3622
3623int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);
3624
3626
3628
3630
3632
3634
3636
3638
3640
3641int av_grow_packet(AVPacket *pkt, int grow_by);
3642
3643int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);
3644
3647
3649int av_copy_packet(AVPacket *dst, const AVPacket *src);
3650
3653
3656
3658 int size);
3659
3661 uint8_t *data, size_t size);
3662
3664 int size);
3665
3667 int *size);
3668
3671
3674
3676
3678
3679int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict);
3680
3682
3683int av_packet_ref(AVPacket *dst, const AVPacket *src);
3684
3686
3688
3690
3692
3694
3696
3698
3701
3702void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height);
3703
3704void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
3705 int linesize_align[AV_NUM_DATA_POINTERS]);
3706
3707int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos);
3708
3710
3713 int *got_frame_ptr, const AVPacket *avpkt);
3714
3717 int *got_picture_ptr,
3718 const AVPacket *avpkt);
3719
3721 int *got_sub_ptr,
3722 AVPacket *avpkt);
3723
3725
3727
3729
3731
3737};
3738
3739typedef struct AVCodecParserContext {
3740 void *priv_data;
3741 struct AVCodecParser *parser;
3742 int64_t frame_offset;
3743 int64_t cur_offset;
3744
3745 int64_t next_frame_offset;
3746
3747 int pict_type;
3748
3749 int repeat_pict;
3750 int64_t pts;
3751 int64_t dts;
3752
3753 int64_t last_pts;
3754 int64_t last_dts;
3755 int fetch_timestamp;
3756
3757#define AV_PARSER_PTS_NB 4
3762
3763 int flags;
3764#define PARSER_FLAG_COMPLETE_FRAMES 0x0001
3765#define PARSER_FLAG_ONCE 0x0002
3766
3767#define PARSER_FLAG_FETCHED_OFFSET 0x0004
3768#define PARSER_FLAG_USE_CODEC_TS 0x1000
3769
3770 int64_t offset;
3772
3773 int key_frame;
3774
3777
3778 int dts_sync_point;
3779
3781
3782 int pts_dts_delta;
3783
3785
3786 int64_t pos;
3787
3788 int64_t last_pos;
3789
3790 int duration;
3791
3793
3795
3797
3800
3803
3806
3807typedef struct AVCodecParser {
3808 int codec_ids[5];
3809 int priv_data_size;
3811
3813 AVCodecContext *avctx,
3814 const uint8_t **poutbuf, int *poutbuf_size,
3815 const uint8_t *buf, int buf_size);
3817 int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size);
3818 struct AVCodecParser *next;
3820
3822
3825
3827 AVCodecContext *avctx,
3828 uint8_t **poutbuf, int *poutbuf_size,
3829 const uint8_t *buf, int buf_size,
3830 int64_t pts, int64_t dts,
3831 int64_t pos);
3832
3834 AVCodecContext *avctx,
3835 uint8_t **poutbuf, int *poutbuf_size,
3836 const uint8_t *buf, int buf_size, int keyframe);
3838
3840
3842
3845 const AVFrame *frame, int *got_packet_ptr);
3846
3849 const AVFrame *frame, int *got_packet_ptr);
3850
3851int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
3852 const AVSubtitle *sub);
3853
3854struct ReSampleContext;
3855struct AVResampleContext;
3856
3858
3860ReSampleContext *av_audio_resample_init(int output_channels, int input_channels,
3861 int output_rate, int input_rate,
3862 enum AVSampleFormat sample_fmt_out,
3863 enum AVSampleFormat sample_fmt_in,
3864 int filter_length, int log2_phase_count,
3865 int linear, double cutoff);
3866
3868int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples);
3869
3872
3874struct AVResampleContext *av_resample_init(int out_rate, int in_rate, int filter_length, int log2_phase_count, int linear, double cutoff);
3875
3877int av_resample(struct AVResampleContext *c, short *dst, short *src, int *consumed, int src_size, int dst_size, int update_ctx);
3878
3880void av_resample_compensate(struct AVResampleContext *c, int sample_delta, int compensation_distance);
3882void av_resample_close(struct AVResampleContext *c);
3883
3885int avpicture_alloc(AVPicture *picture, enum AVPixelFormat pix_fmt, int width, int height);
3886
3889
3891int avpicture_fill(AVPicture *picture, const uint8_t *ptr,
3892 enum AVPixelFormat pix_fmt, int width, int height);
3893
3895int avpicture_layout(const AVPicture *src, enum AVPixelFormat pix_fmt,
3896 int width, int height,
3897 unsigned char *dest, int dest_size);
3898
3900int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);
3901