diff options
Diffstat (limited to 'apps/codecs/libwmapro/avcodec.h')
-rw-r--r-- | apps/codecs/libwmapro/avcodec.h | 3957 |
1 files changed, 0 insertions, 3957 deletions
diff --git a/apps/codecs/libwmapro/avcodec.h b/apps/codecs/libwmapro/avcodec.h deleted file mode 100644 index 8812d409ee..0000000000 --- a/apps/codecs/libwmapro/avcodec.h +++ /dev/null | |||
@@ -1,3957 +0,0 @@ | |||
1 | /* | ||
2 | * copyright (c) 2001 Fabrice Bellard | ||
3 | * | ||
4 | * This file is part of FFmpeg. | ||
5 | * | ||
6 | * FFmpeg is free software; you can redistribute it and/or | ||
7 | * modify it under the terms of the GNU Lesser General Public | ||
8 | * License as published by the Free Software Foundation; either | ||
9 | * version 2.1 of the License, or (at your option) any later version. | ||
10 | * | ||
11 | * FFmpeg is distributed in the hope that it will be useful, | ||
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
14 | * Lesser General Public License for more details. | ||
15 | * | ||
16 | * You should have received a copy of the GNU Lesser General Public | ||
17 | * License along with FFmpeg; if not, write to the Free Software | ||
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
19 | */ | ||
20 | |||
21 | #ifndef AVCODEC_AVCODEC_H | ||
22 | #define AVCODEC_AVCODEC_H | ||
23 | |||
24 | /** | ||
25 | * @file libavcodec/avcodec.h | ||
26 | * external API header | ||
27 | */ | ||
28 | |||
29 | #include <errno.h> | ||
30 | #include "libavutil/avutil.h" | ||
31 | |||
32 | #define LIBAVCODEC_VERSION_MAJOR 52 | ||
33 | #define LIBAVCODEC_VERSION_MINOR 66 | ||
34 | #define LIBAVCODEC_VERSION_MICRO 0 | ||
35 | |||
36 | #define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \ | ||
37 | LIBAVCODEC_VERSION_MINOR, \ | ||
38 | LIBAVCODEC_VERSION_MICRO) | ||
39 | #define LIBAVCODEC_VERSION AV_VERSION(LIBAVCODEC_VERSION_MAJOR, \ | ||
40 | LIBAVCODEC_VERSION_MINOR, \ | ||
41 | LIBAVCODEC_VERSION_MICRO) | ||
42 | #define LIBAVCODEC_BUILD LIBAVCODEC_VERSION_INT | ||
43 | |||
44 | #define LIBAVCODEC_IDENT "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION) | ||
45 | |||
46 | #define AV_NOPTS_VALUE INT64_C(0x8000000000000000) | ||
47 | #define AV_TIME_BASE 1000000 | ||
48 | #define AV_TIME_BASE_Q (AVRational){1, AV_TIME_BASE} | ||
49 | |||
50 | /* some function declarations not used in rockbox use it */ | ||
51 | enum PixelFormat { | ||
52 | we_can_only_play_mpeg_video_anyway = -1 | ||
53 | }; | ||
54 | |||
55 | /** | ||
56 | * Identifies the syntax and semantics of the bitstream. | ||
57 | * The principle is roughly: | ||
58 | * Two decoders with the same ID can decode the same streams. | ||
59 | * Two encoders with the same ID can encode compatible streams. | ||
60 | * There may be slight deviations from the principle due to implementation | ||
61 | * details. | ||
62 | * | ||
63 | * If you add a codec ID to this list, add it so that | ||
64 | * 1. no value of a existing codec ID changes (that would break ABI), | ||
65 | * 2. it is as close as possible to similar codecs. | ||
66 | */ | ||
67 | enum CodecID { | ||
68 | CODEC_ID_NONE, | ||
69 | |||
70 | /* video codecs */ | ||
71 | CODEC_ID_MPEG1VIDEO, | ||
72 | CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding | ||
73 | CODEC_ID_MPEG2VIDEO_XVMC, | ||
74 | CODEC_ID_H261, | ||
75 | CODEC_ID_H263, | ||
76 | CODEC_ID_RV10, | ||
77 | CODEC_ID_RV20, | ||
78 | CODEC_ID_MJPEG, | ||
79 | CODEC_ID_MJPEGB, | ||
80 | CODEC_ID_LJPEG, | ||
81 | CODEC_ID_SP5X, | ||
82 | CODEC_ID_JPEGLS, | ||
83 | CODEC_ID_MPEG4, | ||
84 | CODEC_ID_RAWVIDEO, | ||
85 | CODEC_ID_MSMPEG4V1, | ||
86 | CODEC_ID_MSMPEG4V2, | ||
87 | CODEC_ID_MSMPEG4V3, | ||
88 | CODEC_ID_WMV1, | ||
89 | CODEC_ID_WMV2, | ||
90 | CODEC_ID_H263P, | ||
91 | CODEC_ID_H263I, | ||
92 | CODEC_ID_FLV1, | ||
93 | CODEC_ID_SVQ1, | ||
94 | CODEC_ID_SVQ3, | ||
95 | CODEC_ID_DVVIDEO, | ||
96 | CODEC_ID_HUFFYUV, | ||
97 | CODEC_ID_CYUV, | ||
98 | CODEC_ID_H264, | ||
99 | CODEC_ID_INDEO3, | ||
100 | CODEC_ID_VP3, | ||
101 | CODEC_ID_THEORA, | ||
102 | CODEC_ID_ASV1, | ||
103 | CODEC_ID_ASV2, | ||
104 | CODEC_ID_FFV1, | ||
105 | CODEC_ID_4XM, | ||
106 | CODEC_ID_VCR1, | ||
107 | CODEC_ID_CLJR, | ||
108 | CODEC_ID_MDEC, | ||
109 | CODEC_ID_ROQ, | ||
110 | CODEC_ID_INTERPLAY_VIDEO, | ||
111 | CODEC_ID_XAN_WC3, | ||
112 | CODEC_ID_XAN_WC4, | ||
113 | CODEC_ID_RPZA, | ||
114 | CODEC_ID_CINEPAK, | ||
115 | CODEC_ID_WS_VQA, | ||
116 | CODEC_ID_MSRLE, | ||
117 | CODEC_ID_MSVIDEO1, | ||
118 | CODEC_ID_IDCIN, | ||
119 | CODEC_ID_8BPS, | ||
120 | CODEC_ID_SMC, | ||
121 | CODEC_ID_FLIC, | ||
122 | CODEC_ID_TRUEMOTION1, | ||
123 | CODEC_ID_VMDVIDEO, | ||
124 | CODEC_ID_MSZH, | ||
125 | CODEC_ID_ZLIB, | ||
126 | CODEC_ID_QTRLE, | ||
127 | CODEC_ID_SNOW, | ||
128 | CODEC_ID_TSCC, | ||
129 | CODEC_ID_ULTI, | ||
130 | CODEC_ID_QDRAW, | ||
131 | CODEC_ID_VIXL, | ||
132 | CODEC_ID_QPEG, | ||
133 | #if LIBAVCODEC_VERSION_MAJOR < 53 | ||
134 | CODEC_ID_XVID, | ||
135 | #endif | ||
136 | CODEC_ID_PNG, | ||
137 | CODEC_ID_PPM, | ||
138 | CODEC_ID_PBM, | ||
139 | CODEC_ID_PGM, | ||
140 | CODEC_ID_PGMYUV, | ||
141 | CODEC_ID_PAM, | ||
142 | CODEC_ID_FFVHUFF, | ||
143 | CODEC_ID_RV30, | ||
144 | CODEC_ID_RV40, | ||
145 | CODEC_ID_VC1, | ||
146 | CODEC_ID_WMV3, | ||
147 | CODEC_ID_LOCO, | ||
148 | CODEC_ID_WNV1, | ||
149 | CODEC_ID_AASC, | ||
150 | CODEC_ID_INDEO2, | ||
151 | CODEC_ID_FRAPS, | ||
152 | CODEC_ID_TRUEMOTION2, | ||
153 | CODEC_ID_BMP, | ||
154 | CODEC_ID_CSCD, | ||
155 | CODEC_ID_MMVIDEO, | ||
156 | CODEC_ID_ZMBV, | ||
157 | CODEC_ID_AVS, | ||
158 | CODEC_ID_SMACKVIDEO, | ||
159 | CODEC_ID_NUV, | ||
160 | CODEC_ID_KMVC, | ||
161 | CODEC_ID_FLASHSV, | ||
162 | CODEC_ID_CAVS, | ||
163 | CODEC_ID_JPEG2000, | ||
164 | CODEC_ID_VMNC, | ||
165 | CODEC_ID_VP5, | ||
166 | CODEC_ID_VP6, | ||
167 | CODEC_ID_VP6F, | ||
168 | CODEC_ID_TARGA, | ||
169 | CODEC_ID_DSICINVIDEO, | ||
170 | CODEC_ID_TIERTEXSEQVIDEO, | ||
171 | CODEC_ID_TIFF, | ||
172 | CODEC_ID_GIF, | ||
173 | CODEC_ID_FFH264, | ||
174 | CODEC_ID_DXA, | ||
175 | CODEC_ID_DNXHD, | ||
176 | CODEC_ID_THP, | ||
177 | CODEC_ID_SGI, | ||
178 | CODEC_ID_C93, | ||
179 | CODEC_ID_BETHSOFTVID, | ||
180 | CODEC_ID_PTX, | ||
181 | CODEC_ID_TXD, | ||
182 | CODEC_ID_VP6A, | ||
183 | CODEC_ID_AMV, | ||
184 | CODEC_ID_VB, | ||
185 | CODEC_ID_PCX, | ||
186 | CODEC_ID_SUNRAST, | ||
187 | CODEC_ID_INDEO4, | ||
188 | CODEC_ID_INDEO5, | ||
189 | CODEC_ID_MIMIC, | ||
190 | CODEC_ID_RL2, | ||
191 | CODEC_ID_8SVX_EXP, | ||
192 | CODEC_ID_8SVX_FIB, | ||
193 | CODEC_ID_ESCAPE124, | ||
194 | CODEC_ID_DIRAC, | ||
195 | CODEC_ID_BFI, | ||
196 | CODEC_ID_CMV, | ||
197 | CODEC_ID_MOTIONPIXELS, | ||
198 | CODEC_ID_TGV, | ||
199 | CODEC_ID_TGQ, | ||
200 | CODEC_ID_TQI, | ||
201 | CODEC_ID_AURA, | ||
202 | CODEC_ID_AURA2, | ||
203 | CODEC_ID_V210X, | ||
204 | CODEC_ID_TMV, | ||
205 | CODEC_ID_V210, | ||
206 | CODEC_ID_DPX, | ||
207 | CODEC_ID_MAD, | ||
208 | CODEC_ID_FRWU, | ||
209 | CODEC_ID_FLASHSV2, | ||
210 | CODEC_ID_CDGRAPHICS, | ||
211 | CODEC_ID_R210, | ||
212 | CODEC_ID_ANM, | ||
213 | CODEC_ID_BINKVIDEO, | ||
214 | CODEC_ID_IFF_ILBM, | ||
215 | CODEC_ID_IFF_BYTERUN1, | ||
216 | CODEC_ID_KGV1, | ||
217 | CODEC_ID_YOP, | ||
218 | |||
219 | /* various PCM "codecs" */ | ||
220 | CODEC_ID_PCM_S16LE= 0x10000, | ||
221 | CODEC_ID_PCM_S16BE, | ||
222 | CODEC_ID_PCM_U16LE, | ||
223 | CODEC_ID_PCM_U16BE, | ||
224 | CODEC_ID_PCM_S8, | ||
225 | CODEC_ID_PCM_U8, | ||
226 | CODEC_ID_PCM_MULAW, | ||
227 | CODEC_ID_PCM_ALAW, | ||
228 | CODEC_ID_PCM_S32LE, | ||
229 | CODEC_ID_PCM_S32BE, | ||
230 | CODEC_ID_PCM_U32LE, | ||
231 | CODEC_ID_PCM_U32BE, | ||
232 | CODEC_ID_PCM_S24LE, | ||
233 | CODEC_ID_PCM_S24BE, | ||
234 | CODEC_ID_PCM_U24LE, | ||
235 | CODEC_ID_PCM_U24BE, | ||
236 | CODEC_ID_PCM_S24DAUD, | ||
237 | CODEC_ID_PCM_ZORK, | ||
238 | CODEC_ID_PCM_S16LE_PLANAR, | ||
239 | CODEC_ID_PCM_DVD, | ||
240 | CODEC_ID_PCM_F32BE, | ||
241 | CODEC_ID_PCM_F32LE, | ||
242 | CODEC_ID_PCM_F64BE, | ||
243 | CODEC_ID_PCM_F64LE, | ||
244 | CODEC_ID_PCM_BLURAY, | ||
245 | |||
246 | /* various ADPCM codecs */ | ||
247 | CODEC_ID_ADPCM_IMA_QT= 0x11000, | ||
248 | CODEC_ID_ADPCM_IMA_WAV, | ||
249 | CODEC_ID_ADPCM_IMA_DK3, | ||
250 | CODEC_ID_ADPCM_IMA_DK4, | ||
251 | CODEC_ID_ADPCM_IMA_WS, | ||
252 | CODEC_ID_ADPCM_IMA_SMJPEG, | ||
253 | CODEC_ID_ADPCM_MS, | ||
254 | CODEC_ID_ADPCM_4XM, | ||
255 | CODEC_ID_ADPCM_XA, | ||
256 | CODEC_ID_ADPCM_ADX, | ||
257 | CODEC_ID_ADPCM_EA, | ||
258 | CODEC_ID_ADPCM_G726, | ||
259 | CODEC_ID_ADPCM_CT, | ||
260 | CODEC_ID_ADPCM_SWF, | ||
261 | CODEC_ID_ADPCM_YAMAHA, | ||
262 | CODEC_ID_ADPCM_SBPRO_4, | ||
263 | CODEC_ID_ADPCM_SBPRO_3, | ||
264 | CODEC_ID_ADPCM_SBPRO_2, | ||
265 | CODEC_ID_ADPCM_THP, | ||
266 | CODEC_ID_ADPCM_IMA_AMV, | ||
267 | CODEC_ID_ADPCM_EA_R1, | ||
268 | CODEC_ID_ADPCM_EA_R3, | ||
269 | CODEC_ID_ADPCM_EA_R2, | ||
270 | CODEC_ID_ADPCM_IMA_EA_SEAD, | ||
271 | CODEC_ID_ADPCM_IMA_EA_EACS, | ||
272 | CODEC_ID_ADPCM_EA_XAS, | ||
273 | CODEC_ID_ADPCM_EA_MAXIS_XA, | ||
274 | CODEC_ID_ADPCM_IMA_ISS, | ||
275 | |||
276 | /* AMR */ | ||
277 | CODEC_ID_AMR_NB= 0x12000, | ||
278 | CODEC_ID_AMR_WB, | ||
279 | |||
280 | /* RealAudio codecs*/ | ||
281 | CODEC_ID_RA_144= 0x13000, | ||
282 | CODEC_ID_RA_288, | ||
283 | |||
284 | /* various DPCM codecs */ | ||
285 | CODEC_ID_ROQ_DPCM= 0x14000, | ||
286 | CODEC_ID_INTERPLAY_DPCM, | ||
287 | CODEC_ID_XAN_DPCM, | ||
288 | CODEC_ID_SOL_DPCM, | ||
289 | |||
290 | /* audio codecs */ | ||
291 | CODEC_ID_MP2= 0x15000, | ||
292 | CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3 | ||
293 | CODEC_ID_AAC, | ||
294 | CODEC_ID_AC3, | ||
295 | CODEC_ID_DTS, | ||
296 | CODEC_ID_VORBIS, | ||
297 | CODEC_ID_DVAUDIO, | ||
298 | CODEC_ID_WMAV1, | ||
299 | CODEC_ID_WMAV2, | ||
300 | CODEC_ID_MACE3, | ||
301 | CODEC_ID_MACE6, | ||
302 | CODEC_ID_VMDAUDIO, | ||
303 | CODEC_ID_SONIC, | ||
304 | CODEC_ID_SONIC_LS, | ||
305 | CODEC_ID_FLAC, | ||
306 | CODEC_ID_MP3ADU, | ||
307 | CODEC_ID_MP3ON4, | ||
308 | CODEC_ID_SHORTEN, | ||
309 | CODEC_ID_ALAC, | ||
310 | CODEC_ID_WESTWOOD_SND1, | ||
311 | CODEC_ID_GSM, ///< as in Berlin toast format | ||
312 | CODEC_ID_QDM2, | ||
313 | CODEC_ID_COOK, | ||
314 | CODEC_ID_TRUESPEECH, | ||
315 | CODEC_ID_TTA, | ||
316 | CODEC_ID_SMACKAUDIO, | ||
317 | CODEC_ID_QCELP, | ||
318 | CODEC_ID_WAVPACK, | ||
319 | CODEC_ID_DSICINAUDIO, | ||
320 | CODEC_ID_IMC, | ||
321 | CODEC_ID_MUSEPACK7, | ||
322 | CODEC_ID_MLP, | ||
323 | CODEC_ID_GSM_MS, /* as found in WAV */ | ||
324 | CODEC_ID_ATRAC3, | ||
325 | CODEC_ID_VOXWARE, | ||
326 | CODEC_ID_APE, | ||
327 | CODEC_ID_NELLYMOSER, | ||
328 | CODEC_ID_MUSEPACK8, | ||
329 | CODEC_ID_SPEEX, | ||
330 | CODEC_ID_WMAVOICE, | ||
331 | CODEC_ID_WMAPRO, | ||
332 | CODEC_ID_WMALOSSLESS, | ||
333 | CODEC_ID_ATRAC3P, | ||
334 | CODEC_ID_EAC3, | ||
335 | CODEC_ID_SIPR, | ||
336 | CODEC_ID_MP1, | ||
337 | CODEC_ID_TWINVQ, | ||
338 | CODEC_ID_TRUEHD, | ||
339 | CODEC_ID_MP4ALS, | ||
340 | CODEC_ID_ATRAC1, | ||
341 | CODEC_ID_BINKAUDIO_RDFT, | ||
342 | CODEC_ID_BINKAUDIO_DCT, | ||
343 | |||
344 | /* subtitle codecs */ | ||
345 | CODEC_ID_DVD_SUBTITLE= 0x17000, | ||
346 | CODEC_ID_DVB_SUBTITLE, | ||
347 | CODEC_ID_TEXT, ///< raw UTF-8 text | ||
348 | CODEC_ID_XSUB, | ||
349 | CODEC_ID_SSA, | ||
350 | CODEC_ID_MOV_TEXT, | ||
351 | CODEC_ID_HDMV_PGS_SUBTITLE, | ||
352 | CODEC_ID_DVB_TELETEXT, | ||
353 | |||
354 | /* other specific kind of codecs (generally used for attachments) */ | ||
355 | CODEC_ID_TTF= 0x18000, | ||
356 | |||
357 | CODEC_ID_PROBE= 0x19000, ///< codec_id is not known (like CODEC_ID_NONE) but lavf should attempt to identify it | ||
358 | |||
359 | CODEC_ID_MPEG2TS= 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS | ||
360 | * stream (only used by libavformat) */ | ||
361 | }; | ||
362 | |||
363 | #if LIBAVCODEC_VERSION_MAJOR < 53 | ||
364 | #define CodecType AVMediaType | ||
365 | |||
366 | #define CODEC_TYPE_UNKNOWN AVMEDIA_TYPE_UNKNOWN | ||
367 | #define CODEC_TYPE_VIDEO AVMEDIA_TYPE_VIDEO | ||
368 | #define CODEC_TYPE_AUDIO AVMEDIA_TYPE_AUDIO | ||
369 | #define CODEC_TYPE_DATA AVMEDIA_TYPE_DATA | ||
370 | #define CODEC_TYPE_SUBTITLE AVMEDIA_TYPE_SUBTITLE | ||
371 | #define CODEC_TYPE_ATTACHMENT AVMEDIA_TYPE_ATTACHMENT | ||
372 | #define CODEC_TYPE_NB AVMEDIA_TYPE_NB | ||
373 | #endif | ||
374 | |||
375 | /** | ||
376 | * all in native-endian format | ||
377 | */ | ||
378 | enum SampleFormat { | ||
379 | SAMPLE_FMT_NONE = -1, | ||
380 | SAMPLE_FMT_U8, ///< unsigned 8 bits | ||
381 | SAMPLE_FMT_S16, ///< signed 16 bits | ||
382 | SAMPLE_FMT_S32, ///< signed 32 bits | ||
383 | SAMPLE_FMT_FLT, ///< float | ||
384 | SAMPLE_FMT_DBL, ///< double | ||
385 | SAMPLE_FMT_NB ///< Number of sample formats. DO NOT USE if dynamically linking to libavcodec | ||
386 | }; | ||
387 | |||
388 | /* Audio channel masks */ | ||
389 | #define CH_FRONT_LEFT 0x00000001 | ||
390 | #define CH_FRONT_RIGHT 0x00000002 | ||
391 | #define CH_FRONT_CENTER 0x00000004 | ||
392 | #define CH_LOW_FREQUENCY 0x00000008 | ||
393 | #define CH_BACK_LEFT 0x00000010 | ||
394 | #define CH_BACK_RIGHT 0x00000020 | ||
395 | #define CH_FRONT_LEFT_OF_CENTER 0x00000040 | ||
396 | #define CH_FRONT_RIGHT_OF_CENTER 0x00000080 | ||
397 | #define CH_BACK_CENTER 0x00000100 | ||
398 | #define CH_SIDE_LEFT 0x00000200 | ||
399 | #define CH_SIDE_RIGHT 0x00000400 | ||
400 | #define CH_TOP_CENTER 0x00000800 | ||
401 | #define CH_TOP_FRONT_LEFT 0x00001000 | ||
402 | #define CH_TOP_FRONT_CENTER 0x00002000 | ||
403 | #define CH_TOP_FRONT_RIGHT 0x00004000 | ||
404 | #define CH_TOP_BACK_LEFT 0x00008000 | ||
405 | #define CH_TOP_BACK_CENTER 0x00010000 | ||
406 | #define CH_TOP_BACK_RIGHT 0x00020000 | ||
407 | #define CH_STEREO_LEFT 0x20000000 ///< Stereo downmix. | ||
408 | #define CH_STEREO_RIGHT 0x40000000 ///< See CH_STEREO_LEFT. | ||
409 | |||
410 | /** Channel mask value used for AVCodecContext.request_channel_layout | ||
411 | to indicate that the user requests the channel order of the decoder output | ||
412 | to be the native codec channel order. */ | ||
413 | #define CH_LAYOUT_NATIVE 0x8000000000000000LL | ||
414 | |||
415 | /* Audio channel convenience macros */ | ||
416 | #define CH_LAYOUT_MONO (CH_FRONT_CENTER) | ||
417 | #define CH_LAYOUT_STEREO (CH_FRONT_LEFT|CH_FRONT_RIGHT) | ||
418 | #define CH_LAYOUT_2_1 (CH_LAYOUT_STEREO|CH_BACK_CENTER) | ||
419 | #define CH_LAYOUT_SURROUND (CH_LAYOUT_STEREO|CH_FRONT_CENTER) | ||
420 | #define CH_LAYOUT_4POINT0 (CH_LAYOUT_SURROUND|CH_BACK_CENTER) | ||
421 | #define CH_LAYOUT_2_2 (CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT) | ||
422 | #define CH_LAYOUT_QUAD (CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT) | ||
423 | #define CH_LAYOUT_5POINT0 (CH_LAYOUT_SURROUND|CH_SIDE_LEFT|CH_SIDE_RIGHT) | ||
424 | #define CH_LAYOUT_5POINT1 (CH_LAYOUT_5POINT0|CH_LOW_FREQUENCY) | ||
425 | #define CH_LAYOUT_5POINT0_BACK (CH_LAYOUT_SURROUND|CH_BACK_LEFT|CH_BACK_RIGHT) | ||
426 | #define CH_LAYOUT_5POINT1_BACK (CH_LAYOUT_5POINT0_BACK|CH_LOW_FREQUENCY) | ||
427 | #define CH_LAYOUT_7POINT0 (CH_LAYOUT_5POINT0|CH_BACK_LEFT|CH_BACK_RIGHT) | ||
428 | #define CH_LAYOUT_7POINT1 (CH_LAYOUT_5POINT1|CH_BACK_LEFT|CH_BACK_RIGHT) | ||
429 | #define CH_LAYOUT_7POINT1_WIDE (CH_LAYOUT_5POINT1_BACK|\ | ||
430 | CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER) | ||
431 | #define CH_LAYOUT_STEREO_DOWNMIX (CH_STEREO_LEFT|CH_STEREO_RIGHT) | ||
432 | |||
433 | /* in bytes */ | ||
434 | #define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio | ||
435 | |||
436 | /** | ||
437 | * Required number of additionally allocated bytes at the end of the input bitstream for decoding. | ||
438 | * This is mainly needed because some optimized bitstream readers read | ||
439 | * 32 or 64 bit at once and could read over the end.<br> | ||
440 | * Note: If the first 23 bits of the additional bytes are not 0, then damaged | ||
441 | * MPEG bitstreams could cause overread and segfault. | ||
442 | */ | ||
443 | #define FF_INPUT_BUFFER_PADDING_SIZE 8 | ||
444 | |||
445 | /** | ||
446 | * minimum encoding buffer size | ||
447 | * Used to avoid some checks during header writing. | ||
448 | */ | ||
449 | #define FF_MIN_BUFFER_SIZE 16384 | ||
450 | |||
451 | |||
452 | /** | ||
453 | * motion estimation type. | ||
454 | */ | ||
455 | enum Motion_Est_ID { | ||
456 | ME_ZERO = 1, ///< no search, that is use 0,0 vector whenever one is needed | ||
457 | ME_FULL, | ||
458 | ME_LOG, | ||
459 | ME_PHODS, | ||
460 | ME_EPZS, ///< enhanced predictive zonal search | ||
461 | ME_X1, ///< reserved for experiments | ||
462 | ME_HEX, ///< hexagon based search | ||
463 | ME_UMH, ///< uneven multi-hexagon search | ||
464 | ME_ITER, ///< iterative search | ||
465 | ME_TESA, ///< transformed exhaustive search algorithm | ||
466 | }; | ||
467 | |||
468 | enum AVDiscard{ | ||
469 | /* We leave some space between them for extensions (drop some | ||
470 | * keyframes for intra-only or drop just some bidir frames). */ | ||
471 | AVDISCARD_NONE =-16, ///< discard nothing | ||
472 | AVDISCARD_DEFAULT= 0, ///< discard useless packets like 0 size packets in avi | ||
473 | AVDISCARD_NONREF = 8, ///< discard all non reference | ||
474 | AVDISCARD_BIDIR = 16, ///< discard all bidirectional frames | ||
475 | AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes | ||
476 | AVDISCARD_ALL = 48, ///< discard all | ||
477 | }; | ||
478 | |||
479 | enum AVColorPrimaries{ | ||
480 | AVCOL_PRI_BT709 =1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B | ||
481 | AVCOL_PRI_UNSPECIFIED=2, | ||
482 | AVCOL_PRI_BT470M =4, | ||
483 | AVCOL_PRI_BT470BG =5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM | ||
484 | AVCOL_PRI_SMPTE170M =6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC | ||
485 | AVCOL_PRI_SMPTE240M =7, ///< functionally identical to above | ||
486 | AVCOL_PRI_FILM =8, | ||
487 | AVCOL_PRI_NB , ///< Not part of ABI | ||
488 | }; | ||
489 | |||
490 | enum AVColorTransferCharacteristic{ | ||
491 | AVCOL_TRC_BT709 =1, ///< also ITU-R BT1361 | ||
492 | AVCOL_TRC_UNSPECIFIED=2, | ||
493 | AVCOL_TRC_GAMMA22 =4, ///< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM | ||
494 | AVCOL_TRC_GAMMA28 =5, ///< also ITU-R BT470BG | ||
495 | AVCOL_TRC_NB , ///< Not part of ABI | ||
496 | }; | ||
497 | |||
498 | enum AVColorSpace{ | ||
499 | AVCOL_SPC_RGB =0, | ||
500 | AVCOL_SPC_BT709 =1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B | ||
501 | AVCOL_SPC_UNSPECIFIED=2, | ||
502 | AVCOL_SPC_FCC =4, | ||
503 | AVCOL_SPC_BT470BG =5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 | ||
504 | AVCOL_SPC_SMPTE170M =6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above | ||
505 | AVCOL_SPC_SMPTE240M =7, | ||
506 | AVCOL_SPC_NB , ///< Not part of ABI | ||
507 | }; | ||
508 | |||
509 | enum AVColorRange{ | ||
510 | AVCOL_RANGE_UNSPECIFIED=0, | ||
511 | AVCOL_RANGE_MPEG =1, ///< the normal 219*2^(n-8) "MPEG" YUV ranges | ||
512 | AVCOL_RANGE_JPEG =2, ///< the normal 2^n-1 "JPEG" YUV ranges | ||
513 | AVCOL_RANGE_NB , ///< Not part of ABI | ||
514 | }; | ||
515 | |||
516 | /** | ||
517 | * X X 3 4 X X are luma samples, | ||
518 | * 1 2 1-6 are possible chroma positions | ||
519 | * X X 5 6 X 0 is undefined/unknown position | ||
520 | */ | ||
521 | enum AVChromaLocation{ | ||
522 | AVCHROMA_LOC_UNSPECIFIED=0, | ||
523 | AVCHROMA_LOC_LEFT =1, ///< mpeg2/4, h264 default | ||
524 | AVCHROMA_LOC_CENTER =2, ///< mpeg1, jpeg, h263 | ||
525 | AVCHROMA_LOC_TOPLEFT =3, ///< DV | ||
526 | AVCHROMA_LOC_TOP =4, | ||
527 | AVCHROMA_LOC_BOTTOMLEFT =5, | ||
528 | AVCHROMA_LOC_BOTTOM =6, | ||
529 | AVCHROMA_LOC_NB , ///< Not part of ABI | ||
530 | }; | ||
531 | |||
532 | typedef struct RcOverride{ | ||
533 | int start_frame; | ||
534 | int end_frame; | ||
535 | int qscale; // If this is 0 then quality_factor will be used instead. | ||
536 | float quality_factor; | ||
537 | } RcOverride; | ||
538 | |||
539 | #define FF_MAX_B_FRAMES 16 | ||
540 | |||
541 | /* encoding support | ||
542 | These flags can be passed in AVCodecContext.flags before initialization. | ||
543 | Note: Not everything is supported yet. | ||
544 | */ | ||
545 | |||
546 | #define CODEC_FLAG_QSCALE 0x0002 ///< Use fixed qscale. | ||
547 | #define CODEC_FLAG_4MV 0x0004 ///< 4 MV per MB allowed / advanced prediction for H.263. | ||
548 | #define CODEC_FLAG_QPEL 0x0010 ///< Use qpel MC. | ||
549 | #define CODEC_FLAG_GMC 0x0020 ///< Use GMC. | ||
550 | #define CODEC_FLAG_MV0 0x0040 ///< Always try a MB with MV=<0,0>. | ||
551 | #define CODEC_FLAG_PART 0x0080 ///< Use data partitioning. | ||
552 | /** | ||
553 | * The parent program guarantees that the input for B-frames containing | ||
554 | * streams is not written to for at least s->max_b_frames+1 frames, if | ||
555 | * this is not set the input will be copied. | ||
556 | */ | ||
557 | #define CODEC_FLAG_INPUT_PRESERVED 0x0100 | ||
558 | #define CODEC_FLAG_PASS1 0x0200 ///< Use internal 2pass ratecontrol in first pass mode. | ||
559 | #define CODEC_FLAG_PASS2 0x0400 ///< Use internal 2pass ratecontrol in second pass mode. | ||
560 | #define CODEC_FLAG_EXTERN_HUFF 0x1000 ///< Use external Huffman table (for MJPEG). | ||
561 | #define CODEC_FLAG_GRAY 0x2000 ///< Only decode/encode grayscale. | ||
562 | #define CODEC_FLAG_EMU_EDGE 0x4000 ///< Don't draw edges. | ||
563 | #define CODEC_FLAG_PSNR 0x8000 ///< error[?] variables will be set during encoding. | ||
564 | #define CODEC_FLAG_TRUNCATED 0x00010000 /** Input bitstream might be truncated at a random | ||
565 | location instead of only at frame boundaries. */ | ||
566 | #define CODEC_FLAG_NORMALIZE_AQP 0x00020000 ///< Normalize adaptive quantization. | ||
567 | #define CODEC_FLAG_INTERLACED_DCT 0x00040000 ///< Use interlaced DCT. | ||
568 | #define CODEC_FLAG_LOW_DELAY 0x00080000 ///< Force low delay. | ||
569 | #define CODEC_FLAG_ALT_SCAN 0x00100000 ///< Use alternate scan. | ||
570 | #define CODEC_FLAG_GLOBAL_HEADER 0x00400000 ///< Place global headers in extradata instead of every keyframe. | ||
571 | #define CODEC_FLAG_BITEXACT 0x00800000 ///< Use only bitexact stuff (except (I)DCT). | ||
572 | /* Fx : Flag for h263+ extra options */ | ||
573 | #define CODEC_FLAG_AC_PRED 0x01000000 ///< H.263 advanced intra coding / MPEG-4 AC prediction | ||
574 | #define CODEC_FLAG_H263P_UMV 0x02000000 ///< unlimited motion vector | ||
575 | #define CODEC_FLAG_CBP_RD 0x04000000 ///< Use rate distortion optimization for cbp. | ||
576 | #define CODEC_FLAG_QP_RD 0x08000000 ///< Use rate distortion optimization for qp selectioon. | ||
577 | #define CODEC_FLAG_H263P_AIV 0x00000008 ///< H.263 alternative inter VLC | ||
578 | #define CODEC_FLAG_OBMC 0x00000001 ///< OBMC | ||
579 | #define CODEC_FLAG_LOOP_FILTER 0x00000800 ///< loop filter | ||
580 | #define CODEC_FLAG_H263P_SLICE_STRUCT 0x10000000 | ||
581 | #define CODEC_FLAG_INTERLACED_ME 0x20000000 ///< interlaced motion estimation | ||
582 | #define CODEC_FLAG_SVCD_SCAN_OFFSET 0x40000000 ///< Will reserve space for SVCD scan offset user data. | ||
583 | #define CODEC_FLAG_CLOSED_GOP 0x80000000 | ||
584 | #define CODEC_FLAG2_FAST 0x00000001 ///< Allow non spec compliant speedup tricks. | ||
585 | #define CODEC_FLAG2_STRICT_GOP 0x00000002 ///< Strictly enforce GOP size. | ||
586 | #define CODEC_FLAG2_NO_OUTPUT 0x00000004 ///< Skip bitstream encoding. | ||
587 | #define CODEC_FLAG2_LOCAL_HEADER 0x00000008 ///< Place global headers at every keyframe instead of in extradata. | ||
588 | #define CODEC_FLAG2_BPYRAMID 0x00000010 ///< H.264 allow B-frames to be used as references. | ||
589 | #define CODEC_FLAG2_WPRED 0x00000020 ///< H.264 weighted biprediction for B-frames | ||
590 | #define CODEC_FLAG2_MIXED_REFS 0x00000040 ///< H.264 one reference per partition, as opposed to one reference per macroblock | ||
591 | #define CODEC_FLAG2_8X8DCT 0x00000080 ///< H.264 high profile 8x8 transform | ||
592 | #define CODEC_FLAG2_FASTPSKIP 0x00000100 ///< H.264 fast pskip | ||
593 | #define CODEC_FLAG2_AUD 0x00000200 ///< H.264 access unit delimiters | ||
594 | #define CODEC_FLAG2_BRDO 0x00000400 ///< B-frame rate-distortion optimization | ||
595 | #define CODEC_FLAG2_INTRA_VLC 0x00000800 ///< Use MPEG-2 intra VLC table. | ||
596 | #define CODEC_FLAG2_MEMC_ONLY 0x00001000 ///< Only do ME/MC (I frames -> ref, P frame -> ME+MC). | ||
597 | #define CODEC_FLAG2_DROP_FRAME_TIMECODE 0x00002000 ///< timecode is in drop frame format. | ||
598 | #define CODEC_FLAG2_SKIP_RD 0x00004000 ///< RD optimal MB level residual skipping | ||
599 | #define CODEC_FLAG2_CHUNKS 0x00008000 ///< Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries. | ||
600 | #define CODEC_FLAG2_NON_LINEAR_QUANT 0x00010000 ///< Use MPEG-2 nonlinear quantizer. | ||
601 | #define CODEC_FLAG2_BIT_RESERVOIR 0x00020000 ///< Use a bit reservoir when encoding if possible | ||
602 | #define CODEC_FLAG2_MBTREE 0x00040000 ///< Use macroblock tree ratecontrol (x264 only) | ||
603 | #define CODEC_FLAG2_PSY 0x00080000 ///< Use psycho visual optimizations. | ||
604 | #define CODEC_FLAG2_SSIM 0x00100000 ///< Compute SSIM during encoding, error[] values are undefined. | ||
605 | |||
606 | /* Unsupported options : | ||
607 | * Syntax Arithmetic coding (SAC) | ||
608 | * Reference Picture Selection | ||
609 | * Independent Segment Decoding */ | ||
610 | /* /Fx */ | ||
611 | /* codec capabilities */ | ||
612 | |||
613 | #define CODEC_CAP_DRAW_HORIZ_BAND 0x0001 ///< Decoder can use draw_horiz_band callback. | ||
614 | /** | ||
615 | * Codec uses get_buffer() for allocating buffers and supports custom allocators. | ||
616 | * If not set, it might not use get_buffer() at all or use operations that | ||
617 | * assume the buffer was allocated by avcodec_default_get_buffer. | ||
618 | */ | ||
619 | #define CODEC_CAP_DR1 0x0002 | ||
620 | /* If 'parse_only' field is true, then avcodec_parse_frame() can be used. */ | ||
621 | #define CODEC_CAP_PARSE_ONLY 0x0004 | ||
622 | #define CODEC_CAP_TRUNCATED 0x0008 | ||
623 | /* Codec can export data for HW decoding (XvMC). */ | ||
624 | #define CODEC_CAP_HWACCEL 0x0010 | ||
625 | /** | ||
626 | * Codec has a nonzero delay and needs to be fed with NULL at the end to get the delayed data. | ||
627 | * If this is not set, the codec is guaranteed to never be fed with NULL data. | ||
628 | */ | ||
629 | #define CODEC_CAP_DELAY 0x0020 | ||
630 | /** | ||
631 | * Codec can be fed a final frame with a smaller size. | ||
632 | * This can be used to prevent truncation of the last audio samples. | ||
633 | */ | ||
634 | #define CODEC_CAP_SMALL_LAST_FRAME 0x0040 | ||
635 | /** | ||
636 | * Codec can export data for HW decoding (VDPAU). | ||
637 | */ | ||
638 | #define CODEC_CAP_HWACCEL_VDPAU 0x0080 | ||
639 | /** | ||
640 | * Codec can output multiple frames per AVPacket | ||
641 | * Normally demuxers return one frame at a time, demuxers which do not do | ||
642 | * are connected to a parser to split what they return into proper frames. | ||
643 | * This flag is reserved to the very rare category of codecs which have a | ||
644 | * bitstream that cannot be split into frames without timeconsuming | ||
645 | * operations like full decoding. Demuxers carring such bitstreams thus | ||
646 | * may return multiple frames in a packet. This has many disadvantages like | ||
647 | * prohibiting stream copy in many cases thus it should only be considered | ||
648 | * as a last resort. | ||
649 | */ | ||
650 | #define CODEC_CAP_SUBFRAMES 0x0100 | ||
651 | |||
652 | //The following defines may change, don't expect compatibility if you use them. | ||
653 | #define MB_TYPE_INTRA4x4 0x0001 | ||
654 | #define MB_TYPE_INTRA16x16 0x0002 //FIXME H.264-specific | ||
655 | #define MB_TYPE_INTRA_PCM 0x0004 //FIXME H.264-specific | ||
656 | #define MB_TYPE_16x16 0x0008 | ||
657 | #define MB_TYPE_16x8 0x0010 | ||
658 | #define MB_TYPE_8x16 0x0020 | ||
659 | #define MB_TYPE_8x8 0x0040 | ||
660 | #define MB_TYPE_INTERLACED 0x0080 | ||
661 | #define MB_TYPE_DIRECT2 0x0100 //FIXME | ||
662 | #define MB_TYPE_ACPRED 0x0200 | ||
663 | #define MB_TYPE_GMC 0x0400 | ||
664 | #define MB_TYPE_SKIP 0x0800 | ||
665 | #define MB_TYPE_P0L0 0x1000 | ||
666 | #define MB_TYPE_P1L0 0x2000 | ||
667 | #define MB_TYPE_P0L1 0x4000 | ||
668 | #define MB_TYPE_P1L1 0x8000 | ||
669 | #define MB_TYPE_L0 (MB_TYPE_P0L0 | MB_TYPE_P1L0) | ||
670 | #define MB_TYPE_L1 (MB_TYPE_P0L1 | MB_TYPE_P1L1) | ||
671 | #define MB_TYPE_L0L1 (MB_TYPE_L0 | MB_TYPE_L1) | ||
672 | #define MB_TYPE_QUANT 0x00010000 | ||
673 | #define MB_TYPE_CBP 0x00020000 | ||
674 | //Note bits 24-31 are reserved for codec specific use (h264 ref0, mpeg1 0mv, ...) | ||
675 | |||
676 | /** | ||
677 | * Pan Scan area. | ||
678 | * This specifies the area which should be displayed. | ||
679 | * Note there may be multiple such areas for one frame. | ||
680 | */ | ||
681 | typedef struct AVPanScan{ | ||
682 | /** | ||
683 | * id | ||
684 | * - encoding: Set by user. | ||
685 | * - decoding: Set by libavcodec. | ||
686 | */ | ||
687 | int id; | ||
688 | |||
689 | /** | ||
690 | * width and height in 1/16 pel | ||
691 | * - encoding: Set by user. | ||
692 | * - decoding: Set by libavcodec. | ||
693 | */ | ||
694 | int width; | ||
695 | int height; | ||
696 | |||
697 | /** | ||
698 | * position of the top left corner in 1/16 pel for up to 3 fields/frames | ||
699 | * - encoding: Set by user. | ||
700 | * - decoding: Set by libavcodec. | ||
701 | */ | ||
702 | int16_t position[3][2]; | ||
703 | }AVPanScan; | ||
704 | |||
705 | #define FF_COMMON_FRAME \ | ||
706 | /**\ | ||
707 | * pointer to the picture planes.\ | ||
708 | * This might be different from the first allocated byte\ | ||
709 | * - encoding: \ | ||
710 | * - decoding: \ | ||
711 | */\ | ||
712 | uint8_t *data[4];\ | ||
713 | int linesize[4];\ | ||
714 | /**\ | ||
715 | * pointer to the first allocated byte of the picture. Can be used in get_buffer/release_buffer.\ | ||
716 | * This isn't used by libavcodec unless the default get/release_buffer() is used.\ | ||
717 | * - encoding: \ | ||
718 | * - decoding: \ | ||
719 | */\ | ||
720 | uint8_t *base[4];\ | ||
721 | /**\ | ||
722 | * 1 -> keyframe, 0-> not\ | ||
723 | * - encoding: Set by libavcodec.\ | ||
724 | * - decoding: Set by libavcodec.\ | ||
725 | */\ | ||
726 | int key_frame;\ | ||
727 | \ | ||
728 | /**\ | ||
729 | * Picture type of the frame, see ?_TYPE below.\ | ||
730 | * - encoding: Set by libavcodec. for coded_picture (and set by user for input).\ | ||
731 | * - decoding: Set by libavcodec.\ | ||
732 | */\ | ||
733 | int pict_type;\ | ||
734 | \ | ||
735 | /**\ | ||
736 | * presentation timestamp in time_base units (time when frame should be shown to user)\ | ||
737 | * If AV_NOPTS_VALUE then frame_rate = 1/time_base will be assumed.\ | ||
738 | * - encoding: MUST be set by user.\ | ||
739 | * - decoding: Set by libavcodec.\ | ||
740 | */\ | ||
741 | int64_t pts;\ | ||
742 | \ | ||
743 | /**\ | ||
744 | * picture number in bitstream order\ | ||
745 | * - encoding: set by\ | ||
746 | * - decoding: Set by libavcodec.\ | ||
747 | */\ | ||
748 | int coded_picture_number;\ | ||
749 | /**\ | ||
750 | * picture number in display order\ | ||
751 | * - encoding: set by\ | ||
752 | * - decoding: Set by libavcodec.\ | ||
753 | */\ | ||
754 | int display_picture_number;\ | ||
755 | \ | ||
756 | /**\ | ||
757 | * quality (between 1 (good) and FF_LAMBDA_MAX (bad)) \ | ||
758 | * - encoding: Set by libavcodec. for coded_picture (and set by user for input).\ | ||
759 | * - decoding: Set by libavcodec.\ | ||
760 | */\ | ||
761 | int quality; \ | ||
762 | \ | ||
763 | /**\ | ||
764 | * buffer age (1->was last buffer and dint change, 2->..., ...).\ | ||
765 | * Set to INT_MAX if the buffer has not been used yet.\ | ||
766 | * - encoding: unused\ | ||
767 | * - decoding: MUST be set by get_buffer().\ | ||
768 | */\ | ||
769 | int age;\ | ||
770 | \ | ||
771 | /**\ | ||
772 | * is this picture used as reference\ | ||
773 | * The values for this are the same as the MpegEncContext.picture_structure\ | ||
774 | * variable, that is 1->top field, 2->bottom field, 3->frame/both fields.\ | ||
775 | * Set to 4 for delayed, non-reference frames.\ | ||
776 | * - encoding: unused\ | ||
777 | * - decoding: Set by libavcodec. (before get_buffer() call)).\ | ||
778 | */\ | ||
779 | int reference;\ | ||
780 | \ | ||
781 | /**\ | ||
782 | * QP table\ | ||
783 | * - encoding: unused\ | ||
784 | * - decoding: Set by libavcodec.\ | ||
785 | */\ | ||
786 | int8_t *qscale_table;\ | ||
787 | /**\ | ||
788 | * QP store stride\ | ||
789 | * - encoding: unused\ | ||
790 | * - decoding: Set by libavcodec.\ | ||
791 | */\ | ||
792 | int qstride;\ | ||
793 | \ | ||
794 | /**\ | ||
795 | * mbskip_table[mb]>=1 if MB didn't change\ | ||
796 | * stride= mb_width = (width+15)>>4\ | ||
797 | * - encoding: unused\ | ||
798 | * - decoding: Set by libavcodec.\ | ||
799 | */\ | ||
800 | uint8_t *mbskip_table;\ | ||
801 | \ | ||
802 | /**\ | ||
803 | * motion vector table\ | ||
804 | * @code\ | ||
805 | * example:\ | ||
806 | * int mv_sample_log2= 4 - motion_subsample_log2;\ | ||
807 | * int mb_width= (width+15)>>4;\ | ||
808 | * int mv_stride= (mb_width << mv_sample_log2) + 1;\ | ||
809 | * motion_val[direction][x + y*mv_stride][0->mv_x, 1->mv_y];\ | ||
810 | * @endcode\ | ||
811 | * - encoding: Set by user.\ | ||
812 | * - decoding: Set by libavcodec.\ | ||
813 | */\ | ||
814 | int16_t (*motion_val[2])[2];\ | ||
815 | \ | ||
816 | /**\ | ||
817 | * macroblock type table\ | ||
818 | * mb_type_base + mb_width + 2\ | ||
819 | * - encoding: Set by user.\ | ||
820 | * - decoding: Set by libavcodec.\ | ||
821 | */\ | ||
822 | uint32_t *mb_type;\ | ||
823 | \ | ||
824 | /**\ | ||
825 | * log2 of the size of the block which a single vector in motion_val represents: \ | ||
826 | * (4->16x16, 3->8x8, 2-> 4x4, 1-> 2x2)\ | ||
827 | * - encoding: unused\ | ||
828 | * - decoding: Set by libavcodec.\ | ||
829 | */\ | ||
830 | uint8_t motion_subsample_log2;\ | ||
831 | \ | ||
832 | /**\ | ||
833 | * for some private data of the user\ | ||
834 | * - encoding: unused\ | ||
835 | * - decoding: Set by user.\ | ||
836 | */\ | ||
837 | void *opaque;\ | ||
838 | \ | ||
839 | /**\ | ||
840 | * error\ | ||
841 | * - encoding: Set by libavcodec. if flags&CODEC_FLAG_PSNR.\ | ||
842 | * - decoding: unused\ | ||
843 | */\ | ||
844 | uint64_t error[4];\ | ||
845 | \ | ||
846 | /**\ | ||
847 | * type of the buffer (to keep track of who has to deallocate data[*])\ | ||
848 | * - encoding: Set by the one who allocates it.\ | ||
849 | * - decoding: Set by the one who allocates it.\ | ||
850 | * Note: User allocated (direct rendering) & internal buffers cannot coexist currently.\ | ||
851 | */\ | ||
852 | int type;\ | ||
853 | \ | ||
854 | /**\ | ||
855 | * When decoding, this signals how much the picture must be delayed.\ | ||
856 | * extra_delay = repeat_pict / (2*fps)\ | ||
857 | * - encoding: unused\ | ||
858 | * - decoding: Set by libavcodec.\ | ||
859 | */\ | ||
860 | int repeat_pict;\ | ||
861 | \ | ||
862 | /**\ | ||
863 | * \ | ||
864 | */\ | ||
865 | int qscale_type;\ | ||
866 | \ | ||
867 | /**\ | ||
868 | * The content of the picture is interlaced.\ | ||
869 | * - encoding: Set by user.\ | ||
870 | * - decoding: Set by libavcodec. (default 0)\ | ||
871 | */\ | ||
872 | int interlaced_frame;\ | ||
873 | \ | ||
874 | /**\ | ||
875 | * If the content is interlaced, is top field displayed first.\ | ||
876 | * - encoding: Set by user.\ | ||
877 | * - decoding: Set by libavcodec.\ | ||
878 | */\ | ||
879 | int top_field_first;\ | ||
880 | \ | ||
881 | /**\ | ||
882 | * Pan scan.\ | ||
883 | * - encoding: Set by user.\ | ||
884 | * - decoding: Set by libavcodec.\ | ||
885 | */\ | ||
886 | AVPanScan *pan_scan;\ | ||
887 | \ | ||
888 | /**\ | ||
889 | * Tell user application that palette has changed from previous frame.\ | ||
890 | * - encoding: ??? (no palette-enabled encoder yet)\ | ||
891 | * - decoding: Set by libavcodec. (default 0).\ | ||
892 | */\ | ||
893 | int palette_has_changed;\ | ||
894 | \ | ||
895 | /**\ | ||
896 | * codec suggestion on buffer type if != 0\ | ||
897 | * - encoding: unused\ | ||
898 | * - decoding: Set by libavcodec. (before get_buffer() call)).\ | ||
899 | */\ | ||
900 | int buffer_hints;\ | ||
901 | \ | ||
902 | /**\ | ||
903 | * DCT coefficients\ | ||
904 | * - encoding: unused\ | ||
905 | * - decoding: Set by libavcodec.\ | ||
906 | */\ | ||
907 | short *dct_coeff;\ | ||
908 | \ | ||
909 | /**\ | ||
910 | * motion reference frame index\ | ||
911 | * the order in which these are stored can depend on the codec.\ | ||
912 | * - encoding: Set by user.\ | ||
913 | * - decoding: Set by libavcodec.\ | ||
914 | */\ | ||
915 | int8_t *ref_index[2];\ | ||
916 | \ | ||
917 | /**\ | ||
918 | * reordered opaque 64bit number (generally a PTS) from AVCodecContext.reordered_opaque\ | ||
919 | * output in AVFrame.reordered_opaque\ | ||
920 | * - encoding: unused\ | ||
921 | * - decoding: Read by user.\ | ||
922 | */\ | ||
923 | int64_t reordered_opaque;\ | ||
924 | \ | ||
925 | /**\ | ||
926 | * hardware accelerator private data (FFmpeg allocated)\ | ||
927 | * - encoding: unused\ | ||
928 | * - decoding: Set by libavcodec\ | ||
929 | */\ | ||
930 | void *hwaccel_picture_private;\ | ||
931 | |||
932 | |||
933 | #define FF_QSCALE_TYPE_MPEG1 0 | ||
934 | #define FF_QSCALE_TYPE_MPEG2 1 | ||
935 | #define FF_QSCALE_TYPE_H264 2 | ||
936 | #define FF_QSCALE_TYPE_VP56 3 | ||
937 | |||
938 | #define FF_BUFFER_TYPE_INTERNAL 1 | ||
939 | #define FF_BUFFER_TYPE_USER 2 ///< direct rendering buffers (image is (de)allocated by user) | ||
940 | #define FF_BUFFER_TYPE_SHARED 4 ///< Buffer from somewhere else; don't deallocate image (data/base), all other tables are not shared. | ||
941 | #define FF_BUFFER_TYPE_COPY 8 ///< Just a (modified) copy of some other buffer, don't deallocate anything. | ||
942 | |||
943 | |||
944 | #define FF_I_TYPE 1 ///< Intra | ||
945 | #define FF_P_TYPE 2 ///< Predicted | ||
946 | #define FF_B_TYPE 3 ///< Bi-dir predicted | ||
947 | #define FF_S_TYPE 4 ///< S(GMC)-VOP MPEG4 | ||
948 | #define FF_SI_TYPE 5 ///< Switching Intra | ||
949 | #define FF_SP_TYPE 6 ///< Switching Predicted | ||
950 | #define FF_BI_TYPE 7 | ||
951 | |||
952 | #define FF_BUFFER_HINTS_VALID 0x01 // Buffer hints value is meaningful (if 0 ignore). | ||
953 | #define FF_BUFFER_HINTS_READABLE 0x02 // Codec will read from buffer. | ||
954 | #define FF_BUFFER_HINTS_PRESERVE 0x04 // User must not alter buffer content. | ||
955 | #define FF_BUFFER_HINTS_REUSABLE 0x08 // Codec will reuse the buffer (update). | ||
956 | |||
957 | typedef struct AVPacket { | ||
958 | /** | ||
959 | * Presentation timestamp in AVStream->time_base units; the time at which | ||
960 | * the decompressed packet will be presented to the user. | ||
961 | * Can be AV_NOPTS_VALUE if it is not stored in the file. | ||
962 | * pts MUST be larger or equal to dts as presentation cannot happen before | ||
963 | * decompression, unless one wants to view hex dumps. Some formats misuse | ||
964 | * the terms dts and pts/cts to mean something different. Such timestamps | ||
965 | * must be converted to true pts/dts before they are stored in AVPacket. | ||
966 | */ | ||
967 | int64_t pts; | ||
968 | /** | ||
969 | * Decompression timestamp in AVStream->time_base units; the time at which | ||
970 | * the packet is decompressed. | ||
971 | * Can be AV_NOPTS_VALUE if it is not stored in the file. | ||
972 | */ | ||
973 | int64_t dts; | ||
974 | uint8_t *data; | ||
975 | int size; | ||
976 | int stream_index; | ||
977 | int flags; | ||
978 | /** | ||
979 | * Duration of this packet in AVStream->time_base units, 0 if unknown. | ||
980 | * Equals next_pts - this_pts in presentation order. | ||
981 | */ | ||
982 | int duration; | ||
983 | void (*destruct)(struct AVPacket *); | ||
984 | void *priv; | ||
985 | int64_t pos; ///< byte position in stream, -1 if unknown | ||
986 | |||
987 | /** | ||
988 | * Time difference in AVStream->time_base units from the pts of this | ||
989 | * packet to the point at which the output from the decoder has converged | ||
990 | * independent from the availability of previous frames. That is, the | ||
991 | * frames are virtually identical no matter if decoding started from | ||
992 | * the very first frame or from this keyframe. | ||
993 | * Is AV_NOPTS_VALUE if unknown. | ||
994 | * This field is not the display duration of the current packet. | ||
995 | * | ||
996 | * The purpose of this field is to allow seeking in streams that have no | ||
997 | * keyframes in the conventional sense. It corresponds to the | ||
998 | * recovery point SEI in H.264 and match_time_delta in NUT. It is also | ||
999 | * essential for some types of subtitle streams to ensure that all | ||
1000 | * subtitles are correctly displayed after seeking. | ||
1001 | */ | ||
1002 | int64_t convergence_duration; | ||
1003 | } AVPacket; | ||
1004 | #define AV_PKT_FLAG_KEY 0x0001 | ||
1005 | #if LIBAVCODEC_VERSION_MAJOR < 53 | ||
1006 | #define PKT_FLAG_KEY AV_PKT_FLAG_KEY | ||
1007 | #endif | ||
1008 | |||
1009 | /** | ||
1010 | * Audio Video Frame. | ||
1011 | * New fields can be added to the end of FF_COMMON_FRAME with minor version | ||
1012 | * bumps. | ||
1013 | * Removal, reordering and changes to existing fields require a major | ||
1014 | * version bump. No fields should be added into AVFrame before or after | ||
1015 | * FF_COMMON_FRAME! | ||
1016 | * sizeof(AVFrame) must not be used outside libav*. | ||
1017 | */ | ||
1018 | typedef struct AVFrame { | ||
1019 | FF_COMMON_FRAME | ||
1020 | } AVFrame; | ||
1021 | |||
1022 | /** | ||
1023 | * main external API structure. | ||
1024 | * New fields can be added to the end with minor version bumps. | ||
1025 | * Removal, reordering and changes to existing fields require a major | ||
1026 | * version bump. | ||
1027 | * sizeof(AVCodecContext) must not be used outside libav*. | ||
1028 | */ | ||
1029 | typedef struct AVCodecContext { | ||
1030 | /** | ||
1031 | * information on struct for av_log | ||
1032 | * - set by avcodec_alloc_context | ||
1033 | */ | ||
1034 | const AVClass *av_class; | ||
1035 | /** | ||
1036 | * the average bitrate | ||
1037 | * - encoding: Set by user; unused for constant quantizer encoding. | ||
1038 | * - decoding: Set by libavcodec. 0 or some bitrate if this info is available in the stream. | ||
1039 | */ | ||
1040 | int bit_rate; | ||
1041 | |||
1042 | /** | ||
1043 | * number of bits the bitstream is allowed to diverge from the reference. | ||
1044 | * the reference can be CBR (for CBR pass1) or VBR (for pass2) | ||
1045 | * - encoding: Set by user; unused for constant quantizer encoding. | ||
1046 | * - decoding: unused | ||
1047 | */ | ||
1048 | int bit_rate_tolerance; | ||
1049 | |||
1050 | /** | ||
1051 | * CODEC_FLAG_*. | ||
1052 | * - encoding: Set by user. | ||
1053 | * - decoding: Set by user. | ||
1054 | */ | ||
1055 | int flags; | ||
1056 | |||
1057 | /** | ||
1058 | * Some codecs need additional format info. It is stored here. | ||
1059 | * If any muxer uses this then ALL demuxers/parsers AND encoders for the | ||
1060 | * specific codec MUST set it correctly otherwise stream copy breaks. | ||
1061 | * In general use of this field by muxers is not recommanded. | ||
1062 | * - encoding: Set by libavcodec. | ||
1063 | * - decoding: Set by libavcodec. (FIXME: Is this OK?) | ||
1064 | */ | ||
1065 | int sub_id; | ||
1066 | |||
1067 | /** | ||
1068 | * Motion estimation algorithm used for video coding. | ||
1069 | * 1 (zero), 2 (full), 3 (log), 4 (phods), 5 (epzs), 6 (x1), 7 (hex), | ||
1070 | * 8 (umh), 9 (iter), 10 (tesa) [7, 8, 10 are x264 specific, 9 is snow specific] | ||
1071 | * - encoding: MUST be set by user. | ||
1072 | * - decoding: unused | ||
1073 | */ | ||
1074 | int me_method; | ||
1075 | |||
1076 | /** | ||
1077 | * some codecs need / can use extradata like Huffman tables. | ||
1078 | * mjpeg: Huffman tables | ||
1079 | * rv10: additional flags | ||
1080 | * mpeg4: global headers (they can be in the bitstream or here) | ||
1081 | * The allocated memory should be FF_INPUT_BUFFER_PADDING_SIZE bytes larger | ||
1082 | * than extradata_size to avoid prolems if it is read with the bitstream reader. | ||
1083 | * The bytewise contents of extradata must not depend on the architecture or CPU endianness. | ||
1084 | * - encoding: Set/allocated/freed by libavcodec. | ||
1085 | * - decoding: Set/allocated/freed by user. | ||
1086 | */ | ||
1087 | uint8_t *extradata; | ||
1088 | int extradata_size; | ||
1089 | |||
1090 | /** | ||
1091 | * This is the fundamental unit of time (in seconds) in terms | ||
1092 | * of which frame timestamps are represented. For fixed-fps content, | ||
1093 | * timebase should be 1/framerate and timestamp increments should be | ||
1094 | * identically 1. | ||
1095 | * - encoding: MUST be set by user. | ||
1096 | * - decoding: Set by libavcodec. | ||
1097 | */ | ||
1098 | //AVRational time_base; | ||
1099 | |||
1100 | /* video only */ | ||
1101 | /** | ||
1102 | * picture width / height. | ||
1103 | * - encoding: MUST be set by user. | ||
1104 | * - decoding: Set by libavcodec. | ||
1105 | * Note: For compatibility it is possible to set this instead of | ||
1106 | * coded_width/height before decoding. | ||
1107 | */ | ||
1108 | int width, height; | ||
1109 | |||
1110 | #define FF_ASPECT_EXTENDED 15 | ||
1111 | |||
1112 | /** | ||
1113 | * the number of pictures in a group of pictures, or 0 for intra_only | ||
1114 | * - encoding: Set by user. | ||
1115 | * - decoding: unused | ||
1116 | */ | ||
1117 | int gop_size; | ||
1118 | |||
1119 | /** | ||
1120 | * Pixel format, see PIX_FMT_xxx. | ||
1121 | * - encoding: Set by user. | ||
1122 | * - decoding: Set by libavcodec. | ||
1123 | */ | ||
1124 | //enum PixelFormat pix_fmt; | ||
1125 | |||
1126 | /** | ||
1127 | * Frame rate emulation. If not zero, the lower layer (i.e. format handler) | ||
1128 | * has to read frames at native frame rate. | ||
1129 | * - encoding: Set by user. | ||
1130 | * - decoding: unused | ||
1131 | */ | ||
1132 | int rate_emu; | ||
1133 | |||
1134 | /** | ||
1135 | * If non NULL, 'draw_horiz_band' is called by the libavcodec | ||
1136 | * decoder to draw a horizontal band. It improves cache usage. Not | ||
1137 | * all codecs can do that. You must check the codec capabilities | ||
1138 | * beforehand. | ||
1139 | * The function is also used by hardware acceleration APIs. | ||
1140 | * It is called at least once during frame decoding to pass | ||
1141 | * the data needed for hardware render. | ||
1142 | * In that mode instead of pixel data, AVFrame points to | ||
1143 | * a structure specific to the acceleration API. The application | ||
1144 | * reads the structure and can change some fields to indicate progress | ||
1145 | * or mark state. | ||
1146 | * - encoding: unused | ||
1147 | * - decoding: Set by user. | ||
1148 | * @param height the height of the slice | ||
1149 | * @param y the y position of the slice | ||
1150 | * @param type 1->top field, 2->bottom field, 3->frame | ||
1151 | * @param offset offset into the AVFrame.data from which the slice should be read | ||
1152 | */ | ||
1153 | void (*draw_horiz_band)(struct AVCodecContext *s, | ||
1154 | const AVFrame *src, int offset[4], | ||
1155 | int y, int type, int height); | ||
1156 | |||
1157 | /* audio only */ | ||
1158 | int sample_rate; ///< samples per second | ||
1159 | int channels; ///< number of audio channels | ||
1160 | |||
1161 | /** | ||
1162 | * audio sample format | ||
1163 | * - encoding: Set by user. | ||
1164 | * - decoding: Set by libavcodec. | ||
1165 | */ | ||
1166 | enum SampleFormat sample_fmt; ///< sample format | ||
1167 | |||
1168 | /* The following data should not be initialized. */ | ||
1169 | /** | ||
1170 | * Samples per packet, initialized when calling 'init'. | ||
1171 | */ | ||
1172 | int frame_size; | ||
1173 | int frame_number; ///< audio or video frame number | ||
1174 | #if LIBAVCODEC_VERSION_MAJOR < 53 | ||
1175 | int real_pict_num; ///< Returns the real picture number of previous encoded frame. | ||
1176 | #endif | ||
1177 | |||
1178 | /** | ||
1179 | * Number of frames the decoded output will be delayed relative to | ||
1180 | * the encoded input. | ||
1181 | * - encoding: Set by libavcodec. | ||
1182 | * - decoding: unused | ||
1183 | */ | ||
1184 | int delay; | ||
1185 | |||
1186 | /* - encoding parameters */ | ||
1187 | float qcompress; ///< amount of qscale change between easy & hard scenes (0.0-1.0) | ||
1188 | float qblur; ///< amount of qscale smoothing over time (0.0-1.0) | ||
1189 | |||
1190 | /** | ||
1191 | * minimum quantizer | ||
1192 | * - encoding: Set by user. | ||
1193 | * - decoding: unused | ||
1194 | */ | ||
1195 | int qmin; | ||
1196 | |||
1197 | /** | ||
1198 | * maximum quantizer | ||
1199 | * - encoding: Set by user. | ||
1200 | * - decoding: unused | ||
1201 | */ | ||
1202 | int qmax; | ||
1203 | |||
1204 | /** | ||
1205 | * maximum quantizer difference between frames | ||
1206 | * - encoding: Set by user. | ||
1207 | * - decoding: unused | ||
1208 | */ | ||
1209 | int max_qdiff; | ||
1210 | |||
1211 | /** | ||
1212 | * maximum number of B-frames between non-B-frames | ||
1213 | * Note: The output will be delayed by max_b_frames+1 relative to the input. | ||
1214 | * - encoding: Set by user. | ||
1215 | * - decoding: unused | ||
1216 | */ | ||
1217 | int max_b_frames; | ||
1218 | |||
1219 | /** | ||
1220 | * qscale factor between IP and B-frames | ||
1221 | * If > 0 then the last P-frame quantizer will be used (q= lastp_q*factor+offset). | ||
1222 | * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset). | ||
1223 | * - encoding: Set by user. | ||
1224 | * - decoding: unused | ||
1225 | */ | ||
1226 | float b_quant_factor; | ||
1227 | |||
1228 | /** obsolete FIXME remove */ | ||
1229 | int rc_strategy; | ||
1230 | #define FF_RC_STRATEGY_XVID 1 | ||
1231 | |||
1232 | int b_frame_strategy; | ||
1233 | |||
1234 | /** | ||
1235 | * hurry up amount | ||
1236 | * - encoding: unused | ||
1237 | * - decoding: Set by user. 1-> Skip B-frames, 2-> Skip IDCT/dequant too, 5-> Skip everything except header | ||
1238 | * @deprecated Deprecated in favor of skip_idct and skip_frame. | ||
1239 | */ | ||
1240 | int hurry_up; | ||
1241 | |||
1242 | struct AVCodec *codec; | ||
1243 | |||
1244 | void *priv_data; | ||
1245 | |||
1246 | int rtp_payload_size; /* The size of the RTP payload: the coder will */ | ||
1247 | /* do its best to deliver a chunk with size */ | ||
1248 | /* below rtp_payload_size, the chunk will start */ | ||
1249 | /* with a start code on some codecs like H.263. */ | ||
1250 | /* This doesn't take account of any particular */ | ||
1251 | /* headers inside the transmitted RTP payload. */ | ||
1252 | |||
1253 | |||
1254 | /* The RTP callback: This function is called */ | ||
1255 | /* every time the encoder has a packet to send. */ | ||
1256 | /* It depends on the encoder if the data starts */ | ||
1257 | /* with a Start Code (it should). H.263 does. */ | ||
1258 | /* mb_nb contains the number of macroblocks */ | ||
1259 | /* encoded in the RTP payload. */ | ||
1260 | void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb); | ||
1261 | |||
1262 | /* statistics, used for 2-pass encoding */ | ||
1263 | int mv_bits; | ||
1264 | int header_bits; | ||
1265 | int i_tex_bits; | ||
1266 | int p_tex_bits; | ||
1267 | int i_count; | ||
1268 | int p_count; | ||
1269 | int skip_count; | ||
1270 | int misc_bits; | ||
1271 | |||
1272 | /** | ||
1273 | * number of bits used for the previously encoded frame | ||
1274 | * - encoding: Set by libavcodec. | ||
1275 | * - decoding: unused | ||
1276 | */ | ||
1277 | int frame_bits; | ||
1278 | |||
1279 | /** | ||
1280 | * Private data of the user, can be used to carry app specific stuff. | ||
1281 | * - encoding: Set by user. | ||
1282 | * - decoding: Set by user. | ||
1283 | */ | ||
1284 | void *opaque; | ||
1285 | |||
1286 | char codec_name[32]; | ||
1287 | enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */ | ||
1288 | enum CodecID codec_id; /* see CODEC_ID_xxx */ | ||
1289 | |||
1290 | /** | ||
1291 | * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). | ||
1292 | * This is used to work around some encoder bugs. | ||
1293 | * A demuxer should set this to what is stored in the field used to identify the codec. | ||
1294 | * If there are multiple such fields in a container then the demuxer should choose the one | ||
1295 | * which maximizes the information about the used codec. | ||
1296 | * If the codec tag field in a container is larger then 32 bits then the demuxer should | ||
1297 | * remap the longer ID to 32 bits with a table or other structure. Alternatively a new | ||
1298 | * extra_codec_tag + size could be added but for this a clear advantage must be demonstrated | ||
1299 | * first. | ||
1300 | * - encoding: Set by user, if not then the default based on codec_id will be used. | ||
1301 | * - decoding: Set by user, will be converted to uppercase by libavcodec during init. | ||
1302 | */ | ||
1303 | unsigned int codec_tag; | ||
1304 | |||
1305 | /** | ||
1306 | * Work around bugs in encoders which sometimes cannot be detected automatically. | ||
1307 | * - encoding: Set by user | ||
1308 | * - decoding: Set by user | ||
1309 | */ | ||
1310 | int workaround_bugs; | ||
1311 | #define FF_BUG_AUTODETECT 1 ///< autodetection | ||
1312 | #define FF_BUG_OLD_MSMPEG4 2 | ||
1313 | #define FF_BUG_XVID_ILACE 4 | ||
1314 | #define FF_BUG_UMP4 8 | ||
1315 | #define FF_BUG_NO_PADDING 16 | ||
1316 | #define FF_BUG_AMV 32 | ||
1317 | #define FF_BUG_AC_VLC 0 ///< Will be removed, libavcodec can now handle these non-compliant files by default. | ||
1318 | #define FF_BUG_QPEL_CHROMA 64 | ||
1319 | #define FF_BUG_STD_QPEL 128 | ||
1320 | #define FF_BUG_QPEL_CHROMA2 256 | ||
1321 | #define FF_BUG_DIRECT_BLOCKSIZE 512 | ||
1322 | #define FF_BUG_EDGE 1024 | ||
1323 | #define FF_BUG_HPEL_CHROMA 2048 | ||
1324 | #define FF_BUG_DC_CLIP 4096 | ||
1325 | #define FF_BUG_MS 8192 ///< Work around various bugs in Microsoft's broken decoders. | ||
1326 | #define FF_BUG_TRUNCATED 16384 | ||
1327 | //#define FF_BUG_FAKE_SCALABILITY 16 //Autodetection should work 100%. | ||
1328 | |||
1329 | /** | ||
1330 | * luma single coefficient elimination threshold | ||
1331 | * - encoding: Set by user. | ||
1332 | * - decoding: unused | ||
1333 | */ | ||
1334 | int luma_elim_threshold; | ||
1335 | |||
1336 | /** | ||
1337 | * chroma single coeff elimination threshold | ||
1338 | * - encoding: Set by user. | ||
1339 | * - decoding: unused | ||
1340 | */ | ||
1341 | int chroma_elim_threshold; | ||
1342 | |||
1343 | /** | ||
1344 | * strictly follow the standard (MPEG4, ...). | ||
1345 | * - encoding: Set by user. | ||
1346 | * - decoding: Set by user. | ||
1347 | * Setting this to STRICT or higher means the encoder and decoder will | ||
1348 | * generally do stupid things. While setting it to inofficial or lower | ||
1349 | * will mean the encoder might use things that are not supported by all | ||
1350 | * spec compliant decoders. Decoders make no difference between normal, | ||
1351 | * inofficial and experimental, that is they always try to decode things | ||
1352 | * when they can unless they are explicitly asked to behave stupid | ||
1353 | * (=strictly conform to the specs) | ||
1354 | */ | ||
1355 | int strict_std_compliance; | ||
1356 | #define FF_COMPLIANCE_VERY_STRICT 2 ///< Strictly conform to a older more strict version of the spec or reference software. | ||
1357 | #define FF_COMPLIANCE_STRICT 1 ///< Strictly conform to all the things in the spec no matter what consequences. | ||
1358 | #define FF_COMPLIANCE_NORMAL 0 | ||
1359 | #define FF_COMPLIANCE_INOFFICIAL -1 ///< Allow inofficial extensions. | ||
1360 | #define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things. | ||
1361 | |||
1362 | /** | ||
1363 | * qscale offset between IP and B-frames | ||
1364 | * - encoding: Set by user. | ||
1365 | * - decoding: unused | ||
1366 | */ | ||
1367 | float b_quant_offset; | ||
1368 | |||
1369 | /** | ||
1370 | * Error recognization; higher values will detect more errors but may | ||
1371 | * misdetect some more or less valid parts as errors. | ||
1372 | * - encoding: unused | ||
1373 | * - decoding: Set by user. | ||
1374 | */ | ||
1375 | int error_recognition; | ||
1376 | #define FF_ER_CAREFUL 1 | ||
1377 | #define FF_ER_COMPLIANT 2 | ||
1378 | #define FF_ER_AGGRESSIVE 3 | ||
1379 | #define FF_ER_VERY_AGGRESSIVE 4 | ||
1380 | |||
1381 | /** | ||
1382 | * Called at the beginning of each frame to get a buffer for it. | ||
1383 | * If pic.reference is set then the frame will be read later by libavcodec. | ||
1384 | * avcodec_align_dimensions2() should be used to find the required width and | ||
1385 | * height, as they normally need to be rounded up to the next multiple of 16. | ||
1386 | * if CODEC_CAP_DR1 is not set then get_buffer() must call | ||
1387 | * avcodec_default_get_buffer() instead of providing buffers allocated by | ||
1388 | * some other means. | ||
1389 | * - encoding: unused | ||
1390 | * - decoding: Set by libavcodec., user can override. | ||
1391 | */ | ||
1392 | int (*get_buffer)(struct AVCodecContext *c, AVFrame *pic); | ||
1393 | |||
1394 | /** | ||
1395 | * Called to release buffers which were allocated with get_buffer. | ||
1396 | * A released buffer can be reused in get_buffer(). | ||
1397 | * pic.data[*] must be set to NULL. | ||
1398 | * - encoding: unused | ||
1399 | * - decoding: Set by libavcodec., user can override. | ||
1400 | */ | ||
1401 | void (*release_buffer)(struct AVCodecContext *c, AVFrame *pic); | ||
1402 | |||
1403 | /** | ||
1404 | * Size of the frame reordering buffer in the decoder. | ||
1405 | * For MPEG-2 it is 1 IPB or 0 low delay IP. | ||
1406 | * - encoding: Set by libavcodec. | ||
1407 | * - decoding: Set by libavcodec. | ||
1408 | */ | ||
1409 | int has_b_frames; | ||
1410 | |||
1411 | /** | ||
1412 | * number of bytes per packet if constant and known or 0 | ||
1413 | * Used by some WAV based audio codecs. | ||
1414 | */ | ||
1415 | int block_align; | ||
1416 | |||
1417 | int parse_only; /* - decoding only: If true, only parsing is done | ||
1418 | (function avcodec_parse_frame()). The frame | ||
1419 | data is returned. Only MPEG codecs support this now. */ | ||
1420 | |||
1421 | /** | ||
1422 | * 0-> h263 quant 1-> mpeg quant | ||
1423 | * - encoding: Set by user. | ||
1424 | * - decoding: unused | ||
1425 | */ | ||
1426 | int mpeg_quant; | ||
1427 | |||
1428 | /** | ||
1429 | * pass1 encoding statistics output buffer | ||
1430 | * - encoding: Set by libavcodec. | ||
1431 | * - decoding: unused | ||
1432 | */ | ||
1433 | char *stats_out; | ||
1434 | |||
1435 | /** | ||
1436 | * pass2 encoding statistics input buffer | ||
1437 | * Concatenated stuff from stats_out of pass1 should be placed here. | ||
1438 | * - encoding: Allocated/set/freed by user. | ||
1439 | * - decoding: unused | ||
1440 | */ | ||
1441 | char *stats_in; | ||
1442 | |||
1443 | /** | ||
1444 | * ratecontrol qmin qmax limiting method | ||
1445 | * 0-> clipping, 1-> use a nice continous function to limit qscale wthin qmin/qmax. | ||
1446 | * - encoding: Set by user. | ||
1447 | * - decoding: unused | ||
1448 | */ | ||
1449 | float rc_qsquish; | ||
1450 | |||
1451 | float rc_qmod_amp; | ||
1452 | int rc_qmod_freq; | ||
1453 | |||
1454 | /** | ||
1455 | * ratecontrol override, see RcOverride | ||
1456 | * - encoding: Allocated/set/freed by user. | ||
1457 | * - decoding: unused | ||
1458 | */ | ||
1459 | RcOverride *rc_override; | ||
1460 | int rc_override_count; | ||
1461 | |||
1462 | /** | ||
1463 | * rate control equation | ||
1464 | * - encoding: Set by user | ||
1465 | * - decoding: unused | ||
1466 | */ | ||
1467 | const char *rc_eq; | ||
1468 | |||
1469 | /** | ||
1470 | * maximum bitrate | ||
1471 | * - encoding: Set by user. | ||
1472 | * - decoding: unused | ||
1473 | */ | ||
1474 | int rc_max_rate; | ||
1475 | |||
1476 | /** | ||
1477 | * minimum bitrate | ||
1478 | * - encoding: Set by user. | ||
1479 | * - decoding: unused | ||
1480 | */ | ||
1481 | int rc_min_rate; | ||
1482 | |||
1483 | /** | ||
1484 | * decoder bitstream buffer size | ||
1485 | * - encoding: Set by user. | ||
1486 | * - decoding: unused | ||
1487 | */ | ||
1488 | int rc_buffer_size; | ||
1489 | float rc_buffer_aggressivity; | ||
1490 | |||
1491 | /** | ||
1492 | * qscale factor between P and I-frames | ||
1493 | * If > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset). | ||
1494 | * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset). | ||
1495 | * - encoding: Set by user. | ||
1496 | * - decoding: unused | ||
1497 | */ | ||
1498 | float i_quant_factor; | ||
1499 | |||
1500 | /** | ||
1501 | * qscale offset between P and I-frames | ||
1502 | * - encoding: Set by user. | ||
1503 | * - decoding: unused | ||
1504 | */ | ||
1505 | float i_quant_offset; | ||
1506 | |||
1507 | /** | ||
1508 | * initial complexity for pass1 ratecontrol | ||
1509 | * - encoding: Set by user. | ||
1510 | * - decoding: unused | ||
1511 | */ | ||
1512 | float rc_initial_cplx; | ||
1513 | |||
1514 | /** | ||
1515 | * DCT algorithm, see FF_DCT_* below | ||
1516 | * - encoding: Set by user. | ||
1517 | * - decoding: unused | ||
1518 | */ | ||
1519 | int dct_algo; | ||
1520 | #define FF_DCT_AUTO 0 | ||
1521 | #define FF_DCT_FASTINT 1 | ||
1522 | #define FF_DCT_INT 2 | ||
1523 | #define FF_DCT_MMX 3 | ||
1524 | #define FF_DCT_MLIB 4 | ||
1525 | #define FF_DCT_ALTIVEC 5 | ||
1526 | #define FF_DCT_FAAN 6 | ||
1527 | |||
1528 | /** | ||
1529 | * luminance masking (0-> disabled) | ||
1530 | * - encoding: Set by user. | ||
1531 | * - decoding: unused | ||
1532 | */ | ||
1533 | float lumi_masking; | ||
1534 | |||
1535 | /** | ||
1536 | * temporary complexity masking (0-> disabled) | ||
1537 | * - encoding: Set by user. | ||
1538 | * - decoding: unused | ||
1539 | */ | ||
1540 | float temporal_cplx_masking; | ||
1541 | |||
1542 | /** | ||
1543 | * spatial complexity masking (0-> disabled) | ||
1544 | * - encoding: Set by user. | ||
1545 | * - decoding: unused | ||
1546 | */ | ||
1547 | float spatial_cplx_masking; | ||
1548 | |||
1549 | /** | ||
1550 | * p block masking (0-> disabled) | ||
1551 | * - encoding: Set by user. | ||
1552 | * - decoding: unused | ||
1553 | */ | ||
1554 | float p_masking; | ||
1555 | |||
1556 | /** | ||
1557 | * darkness masking (0-> disabled) | ||
1558 | * - encoding: Set by user. | ||
1559 | * - decoding: unused | ||
1560 | */ | ||
1561 | float dark_masking; | ||
1562 | |||
1563 | /** | ||
1564 | * IDCT algorithm, see FF_IDCT_* below. | ||
1565 | * - encoding: Set by user. | ||
1566 | * - decoding: Set by user. | ||
1567 | */ | ||
1568 | int idct_algo; | ||
1569 | #define FF_IDCT_AUTO 0 | ||
1570 | #define FF_IDCT_INT 1 | ||
1571 | #define FF_IDCT_SIMPLE 2 | ||
1572 | #define FF_IDCT_SIMPLEMMX 3 | ||
1573 | #define FF_IDCT_LIBMPEG2MMX 4 | ||
1574 | #define FF_IDCT_PS2 5 | ||
1575 | #define FF_IDCT_MLIB 6 | ||
1576 | #define FF_IDCT_ARM 7 | ||
1577 | #define FF_IDCT_ALTIVEC 8 | ||
1578 | #define FF_IDCT_SH4 9 | ||
1579 | #define FF_IDCT_SIMPLEARM 10 | ||
1580 | #define FF_IDCT_H264 11 | ||
1581 | #define FF_IDCT_VP3 12 | ||
1582 | #define FF_IDCT_IPP 13 | ||
1583 | #define FF_IDCT_XVIDMMX 14 | ||
1584 | #define FF_IDCT_CAVS 15 | ||
1585 | #define FF_IDCT_SIMPLEARMV5TE 16 | ||
1586 | #define FF_IDCT_SIMPLEARMV6 17 | ||
1587 | #define FF_IDCT_SIMPLEVIS 18 | ||
1588 | #define FF_IDCT_WMV2 19 | ||
1589 | #define FF_IDCT_FAAN 20 | ||
1590 | #define FF_IDCT_EA 21 | ||
1591 | #define FF_IDCT_SIMPLENEON 22 | ||
1592 | #define FF_IDCT_SIMPLEALPHA 23 | ||
1593 | #define FF_IDCT_BINK 24 | ||
1594 | |||
1595 | /** | ||
1596 | * slice count | ||
1597 | * - encoding: Set by libavcodec. | ||
1598 | * - decoding: Set by user (or 0). | ||
1599 | */ | ||
1600 | int slice_count; | ||
1601 | /** | ||
1602 | * slice offsets in the frame in bytes | ||
1603 | * - encoding: Set/allocated by libavcodec. | ||
1604 | * - decoding: Set/allocated by user (or NULL). | ||
1605 | */ | ||
1606 | int *slice_offset; | ||
1607 | |||
1608 | /** | ||
1609 | * error concealment flags | ||
1610 | * - encoding: unused | ||
1611 | * - decoding: Set by user. | ||
1612 | */ | ||
1613 | int error_concealment; | ||
1614 | #define FF_EC_GUESS_MVS 1 | ||
1615 | #define FF_EC_DEBLOCK 2 | ||
1616 | |||
1617 | /** | ||
1618 | * dsp_mask could be add used to disable unwanted CPU features | ||
1619 | * CPU features (i.e. MMX, SSE. ...) | ||
1620 | * | ||
1621 | * With the FORCE flag you may instead enable given CPU features. | ||
1622 | * (Dangerous: Usable in case of misdetection, improper usage however will | ||
1623 | * result into program crash.) | ||
1624 | */ | ||
1625 | unsigned dsp_mask; | ||
1626 | #define FF_MM_FORCE 0x80000000 /* Force usage of selected flags (OR) */ | ||
1627 | /* lower 16 bits - CPU features */ | ||
1628 | #define FF_MM_MMX 0x0001 ///< standard MMX | ||
1629 | #define FF_MM_3DNOW 0x0004 ///< AMD 3DNOW | ||
1630 | #if LIBAVCODEC_VERSION_MAJOR < 53 | ||
1631 | #define FF_MM_MMXEXT 0x0002 ///< SSE integer functions or AMD MMX ext | ||
1632 | #endif | ||
1633 | #define FF_MM_MMX2 0x0002 ///< SSE integer functions or AMD MMX ext | ||
1634 | #define FF_MM_SSE 0x0008 ///< SSE functions | ||
1635 | #define FF_MM_SSE2 0x0010 ///< PIV SSE2 functions | ||
1636 | #define FF_MM_3DNOWEXT 0x0020 ///< AMD 3DNowExt | ||
1637 | #define FF_MM_SSE3 0x0040 ///< Prescott SSE3 functions | ||
1638 | #define FF_MM_SSSE3 0x0080 ///< Conroe SSSE3 functions | ||
1639 | #define FF_MM_SSE4 0x0100 ///< Penryn SSE4.1 functions | ||
1640 | #define FF_MM_SSE42 0x0200 ///< Nehalem SSE4.2 functions | ||
1641 | #define FF_MM_IWMMXT 0x0100 ///< XScale IWMMXT | ||
1642 | #define FF_MM_ALTIVEC 0x0001 ///< standard AltiVec | ||
1643 | |||
1644 | /** | ||
1645 | * bits per sample/pixel from the demuxer (needed for huffyuv). | ||
1646 | * - encoding: Set by libavcodec. | ||
1647 | * - decoding: Set by user. | ||
1648 | */ | ||
1649 | int bits_per_coded_sample; | ||
1650 | |||
1651 | /** | ||
1652 | * prediction method (needed for huffyuv) | ||
1653 | * - encoding: Set by user. | ||
1654 | * - decoding: unused | ||
1655 | */ | ||
1656 | int prediction_method; | ||
1657 | #define FF_PRED_LEFT 0 | ||
1658 | #define FF_PRED_PLANE 1 | ||
1659 | #define FF_PRED_MEDIAN 2 | ||
1660 | |||
1661 | /** | ||
1662 | * sample aspect ratio (0 if unknown) | ||
1663 | * That is the width of a pixel divided by the height of the pixel. | ||
1664 | * Numerator and denominator must be relatively prime and smaller than 256 for some video standards. | ||
1665 | * - encoding: Set by user. | ||
1666 | * - decoding: Set by libavcodec. | ||
1667 | */ | ||
1668 | //AVRational sample_aspect_ratio; | ||
1669 | |||
1670 | /** | ||
1671 | * the picture in the bitstream | ||
1672 | * - encoding: Set by libavcodec. | ||
1673 | * - decoding: Set by libavcodec. | ||
1674 | */ | ||
1675 | AVFrame *coded_frame; | ||
1676 | |||
1677 | /** | ||
1678 | * debug | ||
1679 | * - encoding: Set by user. | ||
1680 | * - decoding: Set by user. | ||
1681 | */ | ||
1682 | int debug; | ||
1683 | #define FF_DEBUG_PICT_INFO 1 | ||
1684 | #define FF_DEBUG_RC 2 | ||
1685 | #define FF_DEBUG_BITSTREAM 4 | ||
1686 | #define FF_DEBUG_MB_TYPE 8 | ||
1687 | #define FF_DEBUG_QP 16 | ||
1688 | #define FF_DEBUG_MV 32 | ||
1689 | #define FF_DEBUG_DCT_COEFF 0x00000040 | ||
1690 | #define FF_DEBUG_SKIP 0x00000080 | ||
1691 | #define FF_DEBUG_STARTCODE 0x00000100 | ||
1692 | #define FF_DEBUG_PTS 0x00000200 | ||
1693 | #define FF_DEBUG_ER 0x00000400 | ||
1694 | #define FF_DEBUG_MMCO 0x00000800 | ||
1695 | #define FF_DEBUG_BUGS 0x00001000 | ||
1696 | #define FF_DEBUG_VIS_QP 0x00002000 | ||
1697 | #define FF_DEBUG_VIS_MB_TYPE 0x00004000 | ||
1698 | #define FF_DEBUG_BUFFERS 0x00008000 | ||
1699 | |||
1700 | /** | ||
1701 | * debug | ||
1702 | * - encoding: Set by user. | ||
1703 | * - decoding: Set by user. | ||
1704 | */ | ||
1705 | int debug_mv; | ||
1706 | #define FF_DEBUG_VIS_MV_P_FOR 0x00000001 //visualize forward predicted MVs of P frames | ||
1707 | #define FF_DEBUG_VIS_MV_B_FOR 0x00000002 //visualize forward predicted MVs of B frames | ||
1708 | #define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames | ||
1709 | |||
1710 | /** | ||
1711 | * error | ||
1712 | * - encoding: Set by libavcodec if flags&CODEC_FLAG_PSNR. | ||
1713 | * - decoding: unused | ||
1714 | */ | ||
1715 | uint64_t error[4]; | ||
1716 | |||
1717 | /** | ||
1718 | * minimum MB quantizer | ||
1719 | * - encoding: unused | ||
1720 | * - decoding: unused | ||
1721 | */ | ||
1722 | int mb_qmin; | ||
1723 | |||
1724 | /** | ||
1725 | * maximum MB quantizer | ||
1726 | * - encoding: unused | ||
1727 | * - decoding: unused | ||
1728 | */ | ||
1729 | int mb_qmax; | ||
1730 | |||
1731 | /** | ||
1732 | * motion estimation comparison function | ||
1733 | * - encoding: Set by user. | ||
1734 | * - decoding: unused | ||
1735 | */ | ||
1736 | int me_cmp; | ||
1737 | /** | ||
1738 | * subpixel motion estimation comparison function | ||
1739 | * - encoding: Set by user. | ||
1740 | * - decoding: unused | ||
1741 | */ | ||
1742 | int me_sub_cmp; | ||
1743 | /** | ||
1744 | * macroblock comparison function (not supported yet) | ||
1745 | * - encoding: Set by user. | ||
1746 | * - decoding: unused | ||
1747 | */ | ||
1748 | int mb_cmp; | ||
1749 | /** | ||
1750 | * interlaced DCT comparison function | ||
1751 | * - encoding: Set by user. | ||
1752 | * - decoding: unused | ||
1753 | */ | ||
1754 | int ildct_cmp; | ||
1755 | #define FF_CMP_SAD 0 | ||
1756 | #define FF_CMP_SSE 1 | ||
1757 | #define FF_CMP_SATD 2 | ||
1758 | #define FF_CMP_DCT 3 | ||
1759 | #define FF_CMP_PSNR 4 | ||
1760 | #define FF_CMP_BIT 5 | ||
1761 | #define FF_CMP_RD 6 | ||
1762 | #define FF_CMP_ZERO 7 | ||
1763 | #define FF_CMP_VSAD 8 | ||
1764 | #define FF_CMP_VSSE 9 | ||
1765 | #define FF_CMP_NSSE 10 | ||
1766 | #define FF_CMP_W53 11 | ||
1767 | #define FF_CMP_W97 12 | ||
1768 | #define FF_CMP_DCTMAX 13 | ||
1769 | #define FF_CMP_DCT264 14 | ||
1770 | #define FF_CMP_CHROMA 256 | ||
1771 | |||
1772 | /** | ||
1773 | * ME diamond size & shape | ||
1774 | * - encoding: Set by user. | ||
1775 | * - decoding: unused | ||
1776 | */ | ||
1777 | int dia_size; | ||
1778 | |||
1779 | /** | ||
1780 | * amount of previous MV predictors (2a+1 x 2a+1 square) | ||
1781 | * - encoding: Set by user. | ||
1782 | * - decoding: unused | ||
1783 | */ | ||
1784 | int last_predictor_count; | ||
1785 | |||
1786 | /** | ||
1787 | * prepass for motion estimation | ||
1788 | * - encoding: Set by user. | ||
1789 | * - decoding: unused | ||
1790 | */ | ||
1791 | int pre_me; | ||
1792 | |||
1793 | /** | ||
1794 | * motion estimation prepass comparison function | ||
1795 | * - encoding: Set by user. | ||
1796 | * - decoding: unused | ||
1797 | */ | ||
1798 | int me_pre_cmp; | ||
1799 | |||
1800 | /** | ||
1801 | * ME prepass diamond size & shape | ||
1802 | * - encoding: Set by user. | ||
1803 | * - decoding: unused | ||
1804 | */ | ||
1805 | int pre_dia_size; | ||
1806 | |||
1807 | /** | ||
1808 | * subpel ME quality | ||
1809 | * - encoding: Set by user. | ||
1810 | * - decoding: unused | ||
1811 | */ | ||
1812 | int me_subpel_quality; | ||
1813 | |||
1814 | /** | ||
1815 | * callback to negotiate the pixelFormat | ||
1816 | * @param fmt is the list of formats which are supported by the codec, | ||
1817 | * it is terminated by -1 as 0 is a valid format, the formats are ordered by quality. | ||
1818 | * The first is always the native one. | ||
1819 | * @return the chosen format | ||
1820 | * - encoding: unused | ||
1821 | * - decoding: Set by user, if not set the native format will be chosen. | ||
1822 | */ | ||
1823 | enum PixelFormat (*get_format)(struct AVCodecContext *s, const enum PixelFormat * fmt); | ||
1824 | |||
1825 | /** | ||
1826 | * DTG active format information (additional aspect ratio | ||
1827 | * information only used in DVB MPEG-2 transport streams) | ||
1828 | * 0 if not set. | ||
1829 | * | ||
1830 | * - encoding: unused | ||
1831 | * - decoding: Set by decoder. | ||
1832 | */ | ||
1833 | int dtg_active_format; | ||
1834 | #define FF_DTG_AFD_SAME 8 | ||
1835 | #define FF_DTG_AFD_4_3 9 | ||
1836 | #define FF_DTG_AFD_16_9 10 | ||
1837 | #define FF_DTG_AFD_14_9 11 | ||
1838 | #define FF_DTG_AFD_4_3_SP_14_9 13 | ||
1839 | #define FF_DTG_AFD_16_9_SP_14_9 14 | ||
1840 | #define FF_DTG_AFD_SP_4_3 15 | ||
1841 | |||
1842 | /** | ||
1843 | * maximum motion estimation search range in subpel units | ||
1844 | * If 0 then no limit. | ||
1845 | * | ||
1846 | * - encoding: Set by user. | ||
1847 | * - decoding: unused | ||
1848 | */ | ||
1849 | int me_range; | ||
1850 | |||
1851 | /** | ||
1852 | * intra quantizer bias | ||
1853 | * - encoding: Set by user. | ||
1854 | * - decoding: unused | ||
1855 | */ | ||
1856 | int intra_quant_bias; | ||
1857 | #define FF_DEFAULT_QUANT_BIAS 999999 | ||
1858 | |||
1859 | /** | ||
1860 | * inter quantizer bias | ||
1861 | * - encoding: Set by user. | ||
1862 | * - decoding: unused | ||
1863 | */ | ||
1864 | int inter_quant_bias; | ||
1865 | |||
1866 | /** | ||
1867 | * color table ID | ||
1868 | * - encoding: unused | ||
1869 | * - decoding: Which clrtable should be used for 8bit RGB images. | ||
1870 | * Tables have to be stored somewhere. FIXME | ||
1871 | */ | ||
1872 | int color_table_id; | ||
1873 | |||
1874 | /** | ||
1875 | * internal_buffer count | ||
1876 | * Don't touch, used by libavcodec default_get_buffer(). | ||
1877 | */ | ||
1878 | int internal_buffer_count; | ||
1879 | |||
1880 | /** | ||
1881 | * internal_buffers | ||
1882 | * Don't touch, used by libavcodec default_get_buffer(). | ||
1883 | */ | ||
1884 | void *internal_buffer; | ||
1885 | |||
1886 | #define FF_LAMBDA_SHIFT 7 | ||
1887 | #define FF_LAMBDA_SCALE (1<<FF_LAMBDA_SHIFT) | ||
1888 | #define FF_QP2LAMBDA 118 ///< factor to convert from H.263 QP to lambda | ||
1889 | #define FF_LAMBDA_MAX (256*128-1) | ||
1890 | |||
1891 | #define FF_QUALITY_SCALE FF_LAMBDA_SCALE //FIXME maybe remove | ||
1892 | /** | ||
1893 | * Global quality for codecs which cannot change it per frame. | ||
1894 | * This should be proportional to MPEG-1/2/4 qscale. | ||
1895 | * - encoding: Set by user. | ||
1896 | * - decoding: unused | ||
1897 | */ | ||
1898 | int global_quality; | ||
1899 | |||
1900 | #define FF_CODER_TYPE_VLC 0 | ||
1901 | #define FF_CODER_TYPE_AC 1 | ||
1902 | #define FF_CODER_TYPE_RAW 2 | ||
1903 | #define FF_CODER_TYPE_RLE 3 | ||
1904 | #define FF_CODER_TYPE_DEFLATE 4 | ||
1905 | /** | ||
1906 | * coder type | ||
1907 | * - encoding: Set by user. | ||
1908 | * - decoding: unused | ||
1909 | */ | ||
1910 | int coder_type; | ||
1911 | |||
1912 | /** | ||
1913 | * context model | ||
1914 | * - encoding: Set by user. | ||
1915 | * - decoding: unused | ||
1916 | */ | ||
1917 | int context_model; | ||
1918 | #if 0 | ||
1919 | /** | ||
1920 | * | ||
1921 | * - encoding: unused | ||
1922 | * - decoding: Set by user. | ||
1923 | */ | ||
1924 | uint8_t * (*realloc)(struct AVCodecContext *s, uint8_t *buf, int buf_size); | ||
1925 | #endif | ||
1926 | |||
1927 | /** | ||
1928 | * slice flags | ||
1929 | * - encoding: unused | ||
1930 | * - decoding: Set by user. | ||
1931 | */ | ||
1932 | int slice_flags; | ||
1933 | #define SLICE_FLAG_CODED_ORDER 0x0001 ///< draw_horiz_band() is called in coded order instead of display | ||
1934 | #define SLICE_FLAG_ALLOW_FIELD 0x0002 ///< allow draw_horiz_band() with field slices (MPEG2 field pics) | ||
1935 | #define SLICE_FLAG_ALLOW_PLANE 0x0004 ///< allow draw_horiz_band() with 1 component at a time (SVQ1) | ||
1936 | |||
1937 | /** | ||
1938 | * XVideo Motion Acceleration | ||
1939 | * - encoding: forbidden | ||
1940 | * - decoding: set by decoder | ||
1941 | */ | ||
1942 | int xvmc_acceleration; | ||
1943 | |||
1944 | /** | ||
1945 | * macroblock decision mode | ||
1946 | * - encoding: Set by user. | ||
1947 | * - decoding: unused | ||
1948 | */ | ||
1949 | int mb_decision; | ||
1950 | #define FF_MB_DECISION_SIMPLE 0 ///< uses mb_cmp | ||
1951 | #define FF_MB_DECISION_BITS 1 ///< chooses the one which needs the fewest bits | ||
1952 | #define FF_MB_DECISION_RD 2 ///< rate distortion | ||
1953 | |||
1954 | /** | ||
1955 | * custom intra quantization matrix | ||
1956 | * - encoding: Set by user, can be NULL. | ||
1957 | * - decoding: Set by libavcodec. | ||
1958 | */ | ||
1959 | uint16_t *intra_matrix; | ||
1960 | |||
1961 | /** | ||
1962 | * custom inter quantization matrix | ||
1963 | * - encoding: Set by user, can be NULL. | ||
1964 | * - decoding: Set by libavcodec. | ||
1965 | */ | ||
1966 | uint16_t *inter_matrix; | ||
1967 | |||
1968 | /** | ||
1969 | * fourcc from the AVI stream header (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). | ||
1970 | * This is used to work around some encoder bugs. | ||
1971 | * - encoding: unused | ||
1972 | * - decoding: Set by user, will be converted to uppercase by libavcodec during init. | ||
1973 | */ | ||
1974 | unsigned int stream_codec_tag; | ||
1975 | |||
1976 | /** | ||
1977 | * scene change detection threshold | ||
1978 | * 0 is default, larger means fewer detected scene changes. | ||
1979 | * - encoding: Set by user. | ||
1980 | * - decoding: unused | ||
1981 | */ | ||
1982 | int scenechange_threshold; | ||
1983 | |||
1984 | /** | ||
1985 | * minimum Lagrange multipler | ||
1986 | * - encoding: Set by user. | ||
1987 | * - decoding: unused | ||
1988 | */ | ||
1989 | int lmin; | ||
1990 | |||
1991 | /** | ||
1992 | * maximum Lagrange multipler | ||
1993 | * - encoding: Set by user. | ||
1994 | * - decoding: unused | ||
1995 | */ | ||
1996 | int lmax; | ||
1997 | |||
1998 | /** | ||
1999 | * palette control structure | ||
2000 | * - encoding: ??? (no palette-enabled encoder yet) | ||
2001 | * - decoding: Set by user. | ||
2002 | */ | ||
2003 | struct AVPaletteControl *palctrl; | ||
2004 | |||
2005 | /** | ||
2006 | * noise reduction strength | ||
2007 | * - encoding: Set by user. | ||
2008 | * - decoding: unused | ||
2009 | */ | ||
2010 | int noise_reduction; | ||
2011 | |||
2012 | /** | ||
2013 | * Called at the beginning of a frame to get cr buffer for it. | ||
2014 | * Buffer type (size, hints) must be the same. libavcodec won't check it. | ||
2015 | * libavcodec will pass previous buffer in pic, function should return | ||
2016 | * same buffer or new buffer with old frame "painted" into it. | ||
2017 | * If pic.data[0] == NULL must behave like get_buffer(). | ||
2018 | * if CODEC_CAP_DR1 is not set then reget_buffer() must call | ||
2019 | * avcodec_default_reget_buffer() instead of providing buffers allocated by | ||
2020 | * some other means. | ||
2021 | * - encoding: unused | ||
2022 | * - decoding: Set by libavcodec., user can override | ||
2023 | */ | ||
2024 | int (*reget_buffer)(struct AVCodecContext *c, AVFrame *pic); | ||
2025 | |||
2026 | /** | ||
2027 | * Number of bits which should be loaded into the rc buffer before decoding starts. | ||
2028 | * - encoding: Set by user. | ||
2029 | * - decoding: unused | ||
2030 | */ | ||
2031 | int rc_initial_buffer_occupancy; | ||
2032 | |||
2033 | /** | ||
2034 | * | ||
2035 | * - encoding: Set by user. | ||
2036 | * - decoding: unused | ||
2037 | */ | ||
2038 | int inter_threshold; | ||
2039 | |||
2040 | /** | ||
2041 | * CODEC_FLAG2_* | ||
2042 | * - encoding: Set by user. | ||
2043 | * - decoding: Set by user. | ||
2044 | */ | ||
2045 | int flags2; | ||
2046 | |||
2047 | /** | ||
2048 | * Simulates errors in the bitstream to test error concealment. | ||
2049 | * - encoding: Set by user. | ||
2050 | * - decoding: unused | ||
2051 | */ | ||
2052 | int error_rate; | ||
2053 | |||
2054 | /** | ||
2055 | * MP3 antialias algorithm, see FF_AA_* below. | ||
2056 | * - encoding: unused | ||
2057 | * - decoding: Set by user. | ||
2058 | */ | ||
2059 | int antialias_algo; | ||
2060 | #define FF_AA_AUTO 0 | ||
2061 | #define FF_AA_FASTINT 1 //not implemented yet | ||
2062 | #define FF_AA_INT 2 | ||
2063 | #define FF_AA_FLOAT 3 | ||
2064 | /** | ||
2065 | * quantizer noise shaping | ||
2066 | * - encoding: Set by user. | ||
2067 | * - decoding: unused | ||
2068 | */ | ||
2069 | int quantizer_noise_shaping; | ||
2070 | |||
2071 | /** | ||
2072 | * thread count | ||
2073 | * is used to decide how many independent tasks should be passed to execute() | ||
2074 | * - encoding: Set by user. | ||
2075 | * - decoding: Set by user. | ||
2076 | */ | ||
2077 | int thread_count; | ||
2078 | |||
2079 | /** | ||
2080 | * The codec may call this to execute several independent things. | ||
2081 | * It will return only after finishing all tasks. | ||
2082 | * The user may replace this with some multithreaded implementation, | ||
2083 | * the default implementation will execute the parts serially. | ||
2084 | * @param count the number of things to execute | ||
2085 | * - encoding: Set by libavcodec, user can override. | ||
2086 | * - decoding: Set by libavcodec, user can override. | ||
2087 | */ | ||
2088 | int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size); | ||
2089 | |||
2090 | /** | ||
2091 | * thread opaque | ||
2092 | * Can be used by execute() to store some per AVCodecContext stuff. | ||
2093 | * - encoding: set by execute() | ||
2094 | * - decoding: set by execute() | ||
2095 | */ | ||
2096 | void *thread_opaque; | ||
2097 | |||
2098 | /** | ||
2099 | * Motion estimation threshold below which no motion estimation is | ||
2100 | * performed, but instead the user specified motion vectors are used. | ||
2101 | * | ||
2102 | * - encoding: Set by user. | ||
2103 | * - decoding: unused | ||
2104 | */ | ||
2105 | int me_threshold; | ||
2106 | |||
2107 | /** | ||
2108 | * Macroblock threshold below which the user specified macroblock types will be used. | ||
2109 | * - encoding: Set by user. | ||
2110 | * - decoding: unused | ||
2111 | */ | ||
2112 | int mb_threshold; | ||
2113 | |||
2114 | /** | ||
2115 | * precision of the intra DC coefficient - 8 | ||
2116 | * - encoding: Set by user. | ||
2117 | * - decoding: unused | ||
2118 | */ | ||
2119 | int intra_dc_precision; | ||
2120 | |||
2121 | /** | ||
2122 | * noise vs. sse weight for the nsse comparsion function | ||
2123 | * - encoding: Set by user. | ||
2124 | * - decoding: unused | ||
2125 | */ | ||
2126 | int nsse_weight; | ||
2127 | |||
2128 | /** | ||
2129 | * Number of macroblock rows at the top which are skipped. | ||
2130 | * - encoding: unused | ||
2131 | * - decoding: Set by user. | ||
2132 | */ | ||
2133 | int skip_top; | ||
2134 | |||
2135 | /** | ||
2136 | * Number of macroblock rows at the bottom which are skipped. | ||
2137 | * - encoding: unused | ||
2138 | * - decoding: Set by user. | ||
2139 | */ | ||
2140 | int skip_bottom; | ||
2141 | |||
2142 | /** | ||
2143 | * profile | ||
2144 | * - encoding: Set by user. | ||
2145 | * - decoding: Set by libavcodec. | ||
2146 | */ | ||
2147 | int profile; | ||
2148 | #define FF_PROFILE_UNKNOWN -99 | ||
2149 | |||
2150 | #define FF_PROFILE_AAC_MAIN 0 | ||
2151 | #define FF_PROFILE_AAC_LOW 1 | ||
2152 | #define FF_PROFILE_AAC_SSR 2 | ||
2153 | #define FF_PROFILE_AAC_LTP 3 | ||
2154 | |||
2155 | #define FF_PROFILE_H264_BASELINE 66 | ||
2156 | #define FF_PROFILE_H264_MAIN 77 | ||
2157 | #define FF_PROFILE_H264_EXTENDED 88 | ||
2158 | #define FF_PROFILE_H264_HIGH 100 | ||
2159 | #define FF_PROFILE_H264_HIGH_10 110 | ||
2160 | #define FF_PROFILE_H264_HIGH_422 122 | ||
2161 | #define FF_PROFILE_H264_HIGH_444 244 | ||
2162 | #define FF_PROFILE_H264_CAVLC_444 44 | ||
2163 | |||
2164 | /** | ||
2165 | * level | ||
2166 | * - encoding: Set by user. | ||
2167 | * - decoding: Set by libavcodec. | ||
2168 | */ | ||
2169 | int level; | ||
2170 | #define FF_LEVEL_UNKNOWN -99 | ||
2171 | |||
2172 | /** | ||
2173 | * low resolution decoding, 1-> 1/2 size, 2->1/4 size | ||
2174 | * - encoding: unused | ||
2175 | * - decoding: Set by user. | ||
2176 | */ | ||
2177 | int lowres; | ||
2178 | |||
2179 | /** | ||
2180 | * Bitstream width / height, may be different from width/height if lowres | ||
2181 | * or other things are used. | ||
2182 | * - encoding: unused | ||
2183 | * - decoding: Set by user before init if known. Codec should override / dynamically change if needed. | ||
2184 | */ | ||
2185 | int coded_width, coded_height; | ||
2186 | |||
2187 | /** | ||
2188 | * frame skip threshold | ||
2189 | * - encoding: Set by user. | ||
2190 | * - decoding: unused | ||
2191 | */ | ||
2192 | int frame_skip_threshold; | ||
2193 | |||
2194 | /** | ||
2195 | * frame skip factor | ||
2196 | * - encoding: Set by user. | ||
2197 | * - decoding: unused | ||
2198 | */ | ||
2199 | int frame_skip_factor; | ||
2200 | |||
2201 | /** | ||
2202 | * frame skip exponent | ||
2203 | * - encoding: Set by user. | ||
2204 | * - decoding: unused | ||
2205 | */ | ||
2206 | int frame_skip_exp; | ||
2207 | |||
2208 | /** | ||
2209 | * frame skip comparison function | ||
2210 | * - encoding: Set by user. | ||
2211 | * - decoding: unused | ||
2212 | */ | ||
2213 | int frame_skip_cmp; | ||
2214 | |||
2215 | /** | ||
2216 | * Border processing masking, raises the quantizer for mbs on the borders | ||
2217 | * of the picture. | ||
2218 | * - encoding: Set by user. | ||
2219 | * - decoding: unused | ||
2220 | */ | ||
2221 | float border_masking; | ||
2222 | |||
2223 | /** | ||
2224 | * minimum MB lagrange multipler | ||
2225 | * - encoding: Set by user. | ||
2226 | * - decoding: unused | ||
2227 | */ | ||
2228 | int mb_lmin; | ||
2229 | |||
2230 | /** | ||
2231 | * maximum MB lagrange multipler | ||
2232 | * - encoding: Set by user. | ||
2233 | * - decoding: unused | ||
2234 | */ | ||
2235 | int mb_lmax; | ||
2236 | |||
2237 | /** | ||
2238 | * | ||
2239 | * - encoding: Set by user. | ||
2240 | * - decoding: unused | ||
2241 | */ | ||
2242 | int me_penalty_compensation; | ||
2243 | |||
2244 | /** | ||
2245 | * | ||
2246 | * - encoding: unused | ||
2247 | * - decoding: Set by user. | ||
2248 | */ | ||
2249 | enum AVDiscard skip_loop_filter; | ||
2250 | |||
2251 | /** | ||
2252 | * | ||
2253 | * - encoding: unused | ||
2254 | * - decoding: Set by user. | ||
2255 | */ | ||
2256 | enum AVDiscard skip_idct; | ||
2257 | |||
2258 | /** | ||
2259 | * | ||
2260 | * - encoding: unused | ||
2261 | * - decoding: Set by user. | ||
2262 | */ | ||
2263 | enum AVDiscard skip_frame; | ||
2264 | |||
2265 | /** | ||
2266 | * | ||
2267 | * - encoding: Set by user. | ||
2268 | * - decoding: unused | ||
2269 | */ | ||
2270 | int bidir_refine; | ||
2271 | |||
2272 | /** | ||
2273 | * | ||
2274 | * - encoding: Set by user. | ||
2275 | * - decoding: unused | ||
2276 | */ | ||
2277 | int brd_scale; | ||
2278 | |||
2279 | /** | ||
2280 | * constant rate factor - quality-based VBR - values ~correspond to qps | ||
2281 | * - encoding: Set by user. | ||
2282 | * - decoding: unused | ||
2283 | */ | ||
2284 | float crf; | ||
2285 | |||
2286 | /** | ||
2287 | * constant quantization parameter rate control method | ||
2288 | * - encoding: Set by user. | ||
2289 | * - decoding: unused | ||
2290 | */ | ||
2291 | int cqp; | ||
2292 | |||
2293 | /** | ||
2294 | * minimum GOP size | ||
2295 | * - encoding: Set by user. | ||
2296 | * - decoding: unused | ||
2297 | */ | ||
2298 | int keyint_min; | ||
2299 | |||
2300 | /** | ||
2301 | * number of reference frames | ||
2302 | * - encoding: Set by user. | ||
2303 | * - decoding: Set by lavc. | ||
2304 | */ | ||
2305 | int refs; | ||
2306 | |||
2307 | /** | ||
2308 | * chroma qp offset from luma | ||
2309 | * - encoding: Set by user. | ||
2310 | * - decoding: unused | ||
2311 | */ | ||
2312 | int chromaoffset; | ||
2313 | |||
2314 | /** | ||
2315 | * Influences how often B-frames are used. | ||
2316 | * - encoding: Set by user. | ||
2317 | * - decoding: unused | ||
2318 | */ | ||
2319 | int bframebias; | ||
2320 | |||
2321 | /** | ||
2322 | * trellis RD quantization | ||
2323 | * - encoding: Set by user. | ||
2324 | * - decoding: unused | ||
2325 | */ | ||
2326 | int trellis; | ||
2327 | |||
2328 | /** | ||
2329 | * Reduce fluctuations in qp (before curve compression). | ||
2330 | * - encoding: Set by user. | ||
2331 | * - decoding: unused | ||
2332 | */ | ||
2333 | float complexityblur; | ||
2334 | |||
2335 | /** | ||
2336 | * in-loop deblocking filter alphac0 parameter | ||
2337 | * alpha is in the range -6...6 | ||
2338 | * - encoding: Set by user. | ||
2339 | * - decoding: unused | ||
2340 | */ | ||
2341 | int deblockalpha; | ||
2342 | |||
2343 | /** | ||
2344 | * in-loop deblocking filter beta parameter | ||
2345 | * beta is in the range -6...6 | ||
2346 | * - encoding: Set by user. | ||
2347 | * - decoding: unused | ||
2348 | */ | ||
2349 | int deblockbeta; | ||
2350 | |||
2351 | /** | ||
2352 | * macroblock subpartition sizes to consider - p8x8, p4x4, b8x8, i8x8, i4x4 | ||
2353 | * - encoding: Set by user. | ||
2354 | * - decoding: unused | ||
2355 | */ | ||
2356 | int partitions; | ||
2357 | #define X264_PART_I4X4 0x001 /* Analyze i4x4 */ | ||
2358 | #define X264_PART_I8X8 0x002 /* Analyze i8x8 (requires 8x8 transform) */ | ||
2359 | #define X264_PART_P8X8 0x010 /* Analyze p16x8, p8x16 and p8x8 */ | ||
2360 | #define X264_PART_P4X4 0x020 /* Analyze p8x4, p4x8, p4x4 */ | ||
2361 | #define X264_PART_B8X8 0x100 /* Analyze b16x8, b8x16 and b8x8 */ | ||
2362 | |||
2363 | /** | ||
2364 | * direct MV prediction mode - 0 (none), 1 (spatial), 2 (temporal), 3 (auto) | ||
2365 | * - encoding: Set by user. | ||
2366 | * - decoding: unused | ||
2367 | */ | ||
2368 | int directpred; | ||
2369 | |||
2370 | /** | ||
2371 | * Audio cutoff bandwidth (0 means "automatic") | ||
2372 | * - encoding: Set by user. | ||
2373 | * - decoding: unused | ||
2374 | */ | ||
2375 | int cutoff; | ||
2376 | |||
2377 | /** | ||
2378 | * Multiplied by qscale for each frame and added to scene_change_score. | ||
2379 | * - encoding: Set by user. | ||
2380 | * - decoding: unused | ||
2381 | */ | ||
2382 | int scenechange_factor; | ||
2383 | |||
2384 | /** | ||
2385 | * | ||
2386 | * Note: Value depends upon the compare function used for fullpel ME. | ||
2387 | * - encoding: Set by user. | ||
2388 | * - decoding: unused | ||
2389 | */ | ||
2390 | int mv0_threshold; | ||
2391 | |||
2392 | /** | ||
2393 | * Adjusts sensitivity of b_frame_strategy 1. | ||
2394 | * - encoding: Set by user. | ||
2395 | * - decoding: unused | ||
2396 | */ | ||
2397 | int b_sensitivity; | ||
2398 | |||
2399 | /** | ||
2400 | * - encoding: Set by user. | ||
2401 | * - decoding: unused | ||
2402 | */ | ||
2403 | int compression_level; | ||
2404 | #define FF_COMPRESSION_DEFAULT -1 | ||
2405 | |||
2406 | /** | ||
2407 | * Sets whether to use LPC mode - used by FLAC encoder. | ||
2408 | * - encoding: Set by user. | ||
2409 | * - decoding: unused | ||
2410 | */ | ||
2411 | int use_lpc; | ||
2412 | |||
2413 | /** | ||
2414 | * LPC coefficient precision - used by FLAC encoder | ||
2415 | * - encoding: Set by user. | ||
2416 | * - decoding: unused | ||
2417 | */ | ||
2418 | int lpc_coeff_precision; | ||
2419 | |||
2420 | /** | ||
2421 | * - encoding: Set by user. | ||
2422 | * - decoding: unused | ||
2423 | */ | ||
2424 | int min_prediction_order; | ||
2425 | |||
2426 | /** | ||
2427 | * - encoding: Set by user. | ||
2428 | * - decoding: unused | ||
2429 | */ | ||
2430 | int max_prediction_order; | ||
2431 | |||
2432 | /** | ||
2433 | * search method for selecting prediction order | ||
2434 | * - encoding: Set by user. | ||
2435 | * - decoding: unused | ||
2436 | */ | ||
2437 | int prediction_order_method; | ||
2438 | |||
2439 | /** | ||
2440 | * - encoding: Set by user. | ||
2441 | * - decoding: unused | ||
2442 | */ | ||
2443 | int min_partition_order; | ||
2444 | |||
2445 | /** | ||
2446 | * - encoding: Set by user. | ||
2447 | * - decoding: unused | ||
2448 | */ | ||
2449 | int max_partition_order; | ||
2450 | |||
2451 | /** | ||
2452 | * GOP timecode frame start number, in non drop frame format | ||
2453 | * - encoding: Set by user. | ||
2454 | * - decoding: unused | ||
2455 | */ | ||
2456 | int64_t timecode_frame_start; | ||
2457 | |||
2458 | #if LIBAVCODEC_VERSION_MAJOR < 53 | ||
2459 | /** | ||
2460 | * Decoder should decode to this many channels if it can (0 for default) | ||
2461 | * - encoding: unused | ||
2462 | * - decoding: Set by user. | ||
2463 | * @deprecated Deprecated in favor of request_channel_layout. | ||
2464 | */ | ||
2465 | int request_channels; | ||
2466 | #endif | ||
2467 | |||
2468 | /** | ||
2469 | * Percentage of dynamic range compression to be applied by the decoder. | ||
2470 | * The default value is 1.0, corresponding to full compression. | ||
2471 | * - encoding: unused | ||
2472 | * - decoding: Set by user. | ||
2473 | */ | ||
2474 | float drc_scale; | ||
2475 | |||
2476 | /** | ||
2477 | * opaque 64bit number (generally a PTS) that will be reordered and | ||
2478 | * output in AVFrame.reordered_opaque | ||
2479 | * - encoding: unused | ||
2480 | * - decoding: Set by user. | ||
2481 | */ | ||
2482 | int64_t reordered_opaque; | ||
2483 | |||
2484 | /** | ||
2485 | * Bits per sample/pixel of internal libavcodec pixel/sample format. | ||
2486 | * This field is applicable only when sample_fmt is SAMPLE_FMT_S32. | ||
2487 | * - encoding: set by user. | ||
2488 | * - decoding: set by libavcodec. | ||
2489 | */ | ||
2490 | int bits_per_raw_sample; | ||
2491 | |||
2492 | /** | ||
2493 | * Audio channel layout. | ||
2494 | * - encoding: set by user. | ||
2495 | * - decoding: set by libavcodec. | ||
2496 | */ | ||
2497 | int64_t channel_layout; | ||
2498 | |||
2499 | /** | ||
2500 | * Request decoder to use this channel layout if it can (0 for default) | ||
2501 | * - encoding: unused | ||
2502 | * - decoding: Set by user. | ||
2503 | */ | ||
2504 | int64_t request_channel_layout; | ||
2505 | |||
2506 | /** | ||
2507 | * Ratecontrol attempt to use, at maximum, <value> of what can be used without an underflow. | ||
2508 | * - encoding: Set by user. | ||
2509 | * - decoding: unused. | ||
2510 | */ | ||
2511 | float rc_max_available_vbv_use; | ||
2512 | |||
2513 | /** | ||
2514 | * Ratecontrol attempt to use, at least, <value> times the amount needed to prevent a vbv overflow. | ||
2515 | * - encoding: Set by user. | ||
2516 | * - decoding: unused. | ||
2517 | */ | ||
2518 | float rc_min_vbv_overflow_use; | ||
2519 | |||
2520 | /** | ||
2521 | * Hardware accelerator in use | ||
2522 | * - encoding: unused. | ||
2523 | * - decoding: Set by libavcodec | ||
2524 | */ | ||
2525 | struct AVHWAccel *hwaccel; | ||
2526 | |||
2527 | /** | ||
2528 | * For some codecs, the time base is closer to the field rate than the frame rate. | ||
2529 | * Most notably, H.264 and MPEG-2 specify time_base as half of frame duration | ||
2530 | * if no telecine is used ... | ||
2531 | * | ||
2532 | * Set to time_base ticks per frame. Default 1, e.g., H.264/MPEG-2 set it to 2. | ||
2533 | */ | ||
2534 | int ticks_per_frame; | ||
2535 | |||
2536 | /** | ||
2537 | * Hardware accelerator context. | ||
2538 | * For some hardware accelerators, a global context needs to be | ||
2539 | * provided by the user. In that case, this holds display-dependent | ||
2540 | * data FFmpeg cannot instantiate itself. Please refer to the | ||
2541 | * FFmpeg HW accelerator documentation to know how to fill this | ||
2542 | * is. e.g. for VA API, this is a struct vaapi_context. | ||
2543 | * - encoding: unused | ||
2544 | * - decoding: Set by user | ||
2545 | */ | ||
2546 | void *hwaccel_context; | ||
2547 | |||
2548 | /** | ||
2549 | * Chromaticity coordinates of the source primaries. | ||
2550 | * - encoding: Set by user | ||
2551 | * - decoding: Set by libavcodec | ||
2552 | */ | ||
2553 | enum AVColorPrimaries color_primaries; | ||
2554 | |||
2555 | /** | ||
2556 | * Color Transfer Characteristic. | ||
2557 | * - encoding: Set by user | ||
2558 | * - decoding: Set by libavcodec | ||
2559 | */ | ||
2560 | enum AVColorTransferCharacteristic color_trc; | ||
2561 | |||
2562 | /** | ||
2563 | * YUV colorspace type. | ||
2564 | * - encoding: Set by user | ||
2565 | * - decoding: Set by libavcodec | ||
2566 | */ | ||
2567 | enum AVColorSpace colorspace; | ||
2568 | |||
2569 | /** | ||
2570 | * MPEG vs JPEG YUV range. | ||
2571 | * - encoding: Set by user | ||
2572 | * - decoding: Set by libavcodec | ||
2573 | */ | ||
2574 | enum AVColorRange color_range; | ||
2575 | |||
2576 | /** | ||
2577 | * This defines the location of chroma samples. | ||
2578 | * - encoding: Set by user | ||
2579 | * - decoding: Set by libavcodec | ||
2580 | */ | ||
2581 | enum AVChromaLocation chroma_sample_location; | ||
2582 | |||
2583 | /** | ||
2584 | * The codec may call this to execute several independent things. | ||
2585 | * It will return only after finishing all tasks. | ||
2586 | * The user may replace this with some multithreaded implementation, | ||
2587 | * the default implementation will execute the parts serially. | ||
2588 | * Also see avcodec_thread_init and e.g. the --enable-pthread configure option. | ||
2589 | * @param c context passed also to func | ||
2590 | * @param count the number of things to execute | ||
2591 | * @param arg2 argument passed unchanged to func | ||
2592 | * @param ret return values of executed functions, must have space for "count" values. May be NULL. | ||
2593 | * @param func function that will be called count times, with jobnr from 0 to count-1. | ||
2594 | * threadnr will be in the range 0 to c->thread_count-1 < MAX_THREADS and so that no | ||
2595 | * two instances of func executing at the same time will have the same threadnr. | ||
2596 | * @return always 0 currently, but code should handle a future improvement where when any call to func | ||
2597 | * returns < 0 no further calls to func may be done and < 0 is returned. | ||
2598 | * - encoding: Set by libavcodec, user can override. | ||
2599 | * - decoding: Set by libavcodec, user can override. | ||
2600 | */ | ||
2601 | int (*execute2)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count); | ||
2602 | |||
2603 | /** | ||
2604 | * explicit P-frame weighted prediction analysis method | ||
2605 | * 0: off | ||
2606 | * 1: fast blind weighting (one reference duplicate with -1 offset) | ||
2607 | * 2: smart weighting (full fade detection analysis) | ||
2608 | * - encoding: Set by user. | ||
2609 | * - decoding: unused | ||
2610 | */ | ||
2611 | int weighted_p_pred; | ||
2612 | |||
2613 | /** | ||
2614 | * AQ mode | ||
2615 | * 0: Disabled | ||
2616 | * 1: Variance AQ (complexity mask) | ||
2617 | * 2: Auto-variance AQ (experimental) | ||
2618 | * - encoding: Set by user | ||
2619 | * - decoding: unused | ||
2620 | */ | ||
2621 | int aq_mode; | ||
2622 | |||
2623 | /** | ||
2624 | * AQ strength | ||
2625 | * Reduces blocking and blurring in flat and textured areas. | ||
2626 | * - encoding: Set by user | ||
2627 | * - decoding: unused | ||
2628 | */ | ||
2629 | float aq_strength; | ||
2630 | |||
2631 | /** | ||
2632 | * PSY RD | ||
2633 | * Strength of psychovisual optimization | ||
2634 | * - encoding: Set by user | ||
2635 | * - decoding: unused | ||
2636 | */ | ||
2637 | float psy_rd; | ||
2638 | |||
2639 | /** | ||
2640 | * PSY trellis | ||
2641 | * Strength of psychovisual optimization | ||
2642 | * - encoding: Set by user | ||
2643 | * - decoding: unused | ||
2644 | */ | ||
2645 | float psy_trellis; | ||
2646 | |||
2647 | /** | ||
2648 | * RC lookahead | ||
2649 | * Number of frames for frametype and ratecontrol lookahead | ||
2650 | * - encoding: Set by user | ||
2651 | * - decoding: unused | ||
2652 | */ | ||
2653 | int rc_lookahead; | ||
2654 | } AVCodecContext; | ||
2655 | |||
2656 | /** | ||
2657 | * AVCodec. | ||
2658 | */ | ||
2659 | typedef struct AVCodec { | ||
2660 | /** | ||
2661 | * Name of the codec implementation. | ||
2662 | * The name is globally unique among encoders and among decoders (but an | ||
2663 | * encoder and a decoder can share the same name). | ||
2664 | * This is the primary way to find a codec from the user perspective. | ||
2665 | */ | ||
2666 | const char *name; | ||
2667 | enum AVMediaType type; | ||
2668 | enum CodecID id; | ||
2669 | int priv_data_size; | ||
2670 | int (*init)(AVCodecContext *); | ||
2671 | int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data); | ||
2672 | int (*close)(AVCodecContext *); | ||
2673 | int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt); | ||
2674 | /** | ||
2675 | * Codec capabilities. | ||
2676 | * see CODEC_CAP_* | ||
2677 | */ | ||
2678 | int capabilities; | ||
2679 | struct AVCodec *next; | ||
2680 | /** | ||
2681 | * Flush buffers. | ||
2682 | * Will be called when seeking | ||
2683 | */ | ||
2684 | void (*flush)(AVCodecContext *); | ||
2685 | //const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0} | ||
2686 | const enum PixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1 | ||
2687 | /** | ||
2688 | * Descriptive name for the codec, meant to be more human readable than name. | ||
2689 | * You should use the NULL_IF_CONFIG_SMALL() macro to define it. | ||
2690 | */ | ||
2691 | const char *long_name; | ||
2692 | const int *supported_samplerates; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0 | ||
2693 | const enum SampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1 | ||
2694 | const int64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0 | ||
2695 | } AVCodec; | ||
2696 | |||
2697 | /** | ||
2698 | * AVHWAccel. | ||
2699 | */ | ||
2700 | typedef struct AVHWAccel { | ||
2701 | /** | ||
2702 | * Name of the hardware accelerated codec. | ||
2703 | * The name is globally unique among encoders and among decoders (but an | ||
2704 | * encoder and a decoder can share the same name). | ||
2705 | */ | ||
2706 | const char *name; | ||
2707 | |||
2708 | /** | ||
2709 | * Type of codec implemented by the hardware accelerator. | ||
2710 | * | ||
2711 | * See AVMEDIA_TYPE_xxx | ||
2712 | */ | ||
2713 | enum AVMediaType type; | ||
2714 | |||
2715 | /** | ||
2716 | * Codec implemented by the hardware accelerator. | ||
2717 | * | ||
2718 | * See CODEC_ID_xxx | ||
2719 | */ | ||
2720 | enum CodecID id; | ||
2721 | |||
2722 | /** | ||
2723 | * Supported pixel format. | ||
2724 | * | ||
2725 | * Only hardware accelerated formats are supported here. | ||
2726 | */ | ||
2727 | //enum PixelFormat pix_fmt; | ||
2728 | |||
2729 | /** | ||
2730 | * Hardware accelerated codec capabilities. | ||
2731 | * see FF_HWACCEL_CODEC_CAP_* | ||
2732 | */ | ||
2733 | int capabilities; | ||
2734 | |||
2735 | struct AVHWAccel *next; | ||
2736 | |||
2737 | /** | ||
2738 | * Called at the beginning of each frame or field picture. | ||
2739 | * | ||
2740 | * Meaningful frame information (codec specific) is guaranteed to | ||
2741 | * be parsed at this point. This function is mandatory. | ||
2742 | * | ||
2743 | * Note that buf can be NULL along with buf_size set to 0. | ||
2744 | * Otherwise, this means the whole frame is available at this point. | ||
2745 | * | ||
2746 | * @param avctx the codec context | ||
2747 | * @param buf the frame data buffer base | ||
2748 | * @param buf_size the size of the frame in bytes | ||
2749 | * @return zero if successful, a negative value otherwise | ||
2750 | */ | ||
2751 | int (*start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size); | ||
2752 | |||
2753 | /** | ||
2754 | * Callback for each slice. | ||
2755 | * | ||
2756 | * Meaningful slice information (codec specific) is guaranteed to | ||
2757 | * be parsed at this point. This function is mandatory. | ||
2758 | * | ||
2759 | * @param avctx the codec context | ||
2760 | * @param buf the slice data buffer base | ||
2761 | * @param buf_size the size of the slice in bytes | ||
2762 | * @return zero if successful, a negative value otherwise | ||
2763 | */ | ||
2764 | int (*decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size); | ||
2765 | |||
2766 | /** | ||
2767 | * Called at the end of each frame or field picture. | ||
2768 | * | ||
2769 | * The whole picture is parsed at this point and can now be sent | ||
2770 | * to the hardware accelerator. This function is mandatory. | ||
2771 | * | ||
2772 | * @param avctx the codec context | ||
2773 | * @return zero if successful, a negative value otherwise | ||
2774 | */ | ||
2775 | int (*end_frame)(AVCodecContext *avctx); | ||
2776 | |||
2777 | /** | ||
2778 | * Size of HW accelerator private data. | ||
2779 | * | ||
2780 | * Private data is allocated with av_mallocz() before | ||
2781 | * AVCodecContext.get_buffer() and deallocated after | ||
2782 | * AVCodecContext.release_buffer(). | ||
2783 | */ | ||
2784 | int priv_data_size; | ||
2785 | } AVHWAccel; | ||
2786 | |||
2787 | /** | ||
2788 | * four components are given, that's all. | ||
2789 | * the last component is alpha | ||
2790 | */ | ||
2791 | typedef struct AVPicture { | ||
2792 | uint8_t *data[4]; | ||
2793 | int linesize[4]; ///< number of bytes per line | ||
2794 | } AVPicture; | ||
2795 | |||
2796 | #if LIBAVCODEC_VERSION_MAJOR < 53 | ||
2797 | /** | ||
2798 | * AVPaletteControl | ||
2799 | * This structure defines a method for communicating palette changes | ||
2800 | * between and demuxer and a decoder. | ||
2801 | * | ||
2802 | * @deprecated Use AVPacket to send palette changes instead. | ||
2803 | * This is totally broken. | ||
2804 | */ | ||
2805 | #define AVPALETTE_SIZE 1024 | ||
2806 | #define AVPALETTE_COUNT 256 | ||
2807 | typedef struct AVPaletteControl { | ||
2808 | |||
2809 | /* Demuxer sets this to 1 to indicate the palette has changed; | ||
2810 | * decoder resets to 0. */ | ||
2811 | int palette_changed; | ||
2812 | |||
2813 | /* 4-byte ARGB palette entries, stored in native byte order; note that | ||
2814 | * the individual palette components should be on a 8-bit scale; if | ||
2815 | * the palette data comes from an IBM VGA native format, the component | ||
2816 | * data is probably 6 bits in size and needs to be scaled. */ | ||
2817 | unsigned int palette[AVPALETTE_COUNT]; | ||
2818 | |||
2819 | } AVPaletteControl attribute_deprecated; | ||
2820 | #endif | ||
2821 | |||
2822 | enum AVSubtitleType { | ||
2823 | SUBTITLE_NONE, | ||
2824 | |||
2825 | SUBTITLE_BITMAP, ///< A bitmap, pict will be set | ||
2826 | |||
2827 | /** | ||
2828 | * Plain text, the text field must be set by the decoder and is | ||
2829 | * authoritative. ass and pict fields may contain approximations. | ||
2830 | */ | ||
2831 | SUBTITLE_TEXT, | ||
2832 | |||
2833 | /** | ||
2834 | * Formatted text, the ass field must be set by the decoder and is | ||
2835 | * authoritative. pict and text fields may contain approximations. | ||
2836 | */ | ||
2837 | SUBTITLE_ASS, | ||
2838 | }; | ||
2839 | |||
2840 | typedef struct AVSubtitleRect { | ||
2841 | int x; ///< top left corner of pict, undefined when pict is not set | ||
2842 | int y; ///< top left corner of pict, undefined when pict is not set | ||
2843 | int w; ///< width of pict, undefined when pict is not set | ||
2844 | int h; ///< height of pict, undefined when pict is not set | ||
2845 | int nb_colors; ///< number of colors in pict, undefined when pict is not set | ||
2846 | |||
2847 | /** | ||
2848 | * data+linesize for the bitmap of this subtitle. | ||
2849 | * can be set for text/ass as well once they where rendered | ||
2850 | */ | ||
2851 | AVPicture pict; | ||
2852 | enum AVSubtitleType type; | ||
2853 | |||
2854 | char *text; ///< 0 terminated plain UTF-8 text | ||
2855 | |||
2856 | /** | ||
2857 | * 0 terminated ASS/SSA compatible event line. | ||
2858 | * The pressentation of this is unaffected by the other values in this | ||
2859 | * struct. | ||
2860 | */ | ||
2861 | char *ass; | ||
2862 | } AVSubtitleRect; | ||
2863 | |||
2864 | typedef struct AVSubtitle { | ||
2865 | uint16_t format; /* 0 = graphics */ | ||
2866 | uint32_t start_display_time; /* relative to packet pts, in ms */ | ||
2867 | uint32_t end_display_time; /* relative to packet pts, in ms */ | ||
2868 | unsigned num_rects; | ||
2869 | AVSubtitleRect **rects; | ||
2870 | int64_t pts; ///< Same as packet pts, in AV_TIME_BASE | ||
2871 | } AVSubtitle; | ||
2872 | |||
2873 | /* packet functions */ | ||
2874 | |||
2875 | /** | ||
2876 | * @deprecated use NULL instead | ||
2877 | */ | ||
2878 | attribute_deprecated void av_destruct_packet_nofree(AVPacket *pkt); | ||
2879 | |||
2880 | /** | ||
2881 | * Default packet destructor. | ||
2882 | */ | ||
2883 | void av_destruct_packet(AVPacket *pkt); | ||
2884 | |||
2885 | /** | ||
2886 | * Initialize optional fields of a packet with default values. | ||
2887 | * | ||
2888 | * @param pkt packet | ||
2889 | */ | ||
2890 | void av_init_packet(AVPacket *pkt); | ||
2891 | |||
2892 | /** | ||
2893 | * Allocate the payload of a packet and initialize its fields with | ||
2894 | * default values. | ||
2895 | * | ||
2896 | * @param pkt packet | ||
2897 | * @param size wanted payload size | ||
2898 | * @return 0 if OK, AVERROR_xxx otherwise | ||
2899 | */ | ||
2900 | int av_new_packet(AVPacket *pkt, int size); | ||
2901 | |||
2902 | /** | ||
2903 | * Reduce packet size, correctly zeroing padding | ||
2904 | * | ||
2905 | * @param pkt packet | ||
2906 | * @param size new size | ||
2907 | */ | ||
2908 | void av_shrink_packet(AVPacket *pkt, int size); | ||
2909 | |||
2910 | /** | ||
2911 | * @warning This is a hack - the packet memory allocation stuff is broken. The | ||
2912 | * packet is allocated if it was not really allocated. | ||
2913 | */ | ||
2914 | int av_dup_packet(AVPacket *pkt); | ||
2915 | |||
2916 | /** | ||
2917 | * Free a packet. | ||
2918 | * | ||
2919 | * @param pkt packet to free | ||
2920 | */ | ||
2921 | void av_free_packet(AVPacket *pkt); | ||
2922 | |||
2923 | /* resample.c */ | ||
2924 | |||
2925 | struct ReSampleContext; | ||
2926 | struct AVResampleContext; | ||
2927 | |||
2928 | typedef struct ReSampleContext ReSampleContext; | ||
2929 | |||
2930 | #if LIBAVCODEC_VERSION_MAJOR < 53 | ||
2931 | /** | ||
2932 | * @deprecated Use av_audio_resample_init() instead. | ||
2933 | */ | ||
2934 | attribute_deprecated ReSampleContext *audio_resample_init(int output_channels, int input_channels, | ||
2935 | int output_rate, int input_rate); | ||
2936 | #endif | ||
2937 | /** | ||
2938 | * Initializes audio resampling context | ||
2939 | * | ||
2940 | * @param output_channels number of output channels | ||
2941 | * @param input_channels number of input channels | ||
2942 | * @param output_rate output sample rate | ||
2943 | * @param input_rate input sample rate | ||
2944 | * @param sample_fmt_out requested output sample format | ||
2945 | * @param sample_fmt_in input sample format | ||
2946 | * @param filter_length length of each FIR filter in the filterbank relative to the cutoff freq | ||
2947 | * @param log2_phase_count log2 of the number of entries in the polyphase filterbank | ||
2948 | * @param linear If 1 then the used FIR filter will be linearly interpolated | ||
2949 | between the 2 closest, if 0 the closest will be used | ||
2950 | * @param cutoff cutoff frequency, 1.0 corresponds to half the output sampling rate | ||
2951 | * @return allocated ReSampleContext, NULL if error occured | ||
2952 | */ | ||
2953 | ReSampleContext *av_audio_resample_init(int output_channels, int input_channels, | ||
2954 | int output_rate, int input_rate, | ||
2955 | enum SampleFormat sample_fmt_out, | ||
2956 | enum SampleFormat sample_fmt_in, | ||
2957 | int filter_length, int log2_phase_count, | ||
2958 | int linear, double cutoff); | ||
2959 | |||
2960 | int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples); | ||
2961 | void audio_resample_close(ReSampleContext *s); | ||
2962 | |||
2963 | |||
2964 | /** | ||
2965 | * Initializes an audio resampler. | ||
2966 | * Note, if either rate is not an integer then simply scale both rates up so they are. | ||
2967 | * @param filter_length length of each FIR filter in the filterbank relative to the cutoff freq | ||
2968 | * @param log2_phase_count log2 of the number of entries in the polyphase filterbank | ||
2969 | * @param linear If 1 then the used FIR filter will be linearly interpolated | ||
2970 | between the 2 closest, if 0 the closest will be used | ||
2971 | * @param cutoff cutoff frequency, 1.0 corresponds to half the output sampling rate | ||
2972 | */ | ||
2973 | struct AVResampleContext *av_resample_init(int out_rate, int in_rate, int filter_length, int log2_phase_count, int linear, double cutoff); | ||
2974 | |||
2975 | /** | ||
2976 | * resamples. | ||
2977 | * @param src an array of unconsumed samples | ||
2978 | * @param consumed the number of samples of src which have been consumed are returned here | ||
2979 | * @param src_size the number of unconsumed samples available | ||
2980 | * @param dst_size the amount of space in samples available in dst | ||
2981 | * @param update_ctx If this is 0 then the context will not be modified, that way several channels can be resampled with the same context. | ||
2982 | * @return the number of samples written in dst or -1 if an error occurred | ||
2983 | */ | ||
2984 | int av_resample(struct AVResampleContext *c, short *dst, short *src, int *consumed, int src_size, int dst_size, int update_ctx); | ||
2985 | |||
2986 | |||
2987 | /** | ||
2988 | * Compensates samplerate/timestamp drift. The compensation is done by changing | ||
2989 | * the resampler parameters, so no audible clicks or similar distortions occur | ||
2990 | * @param compensation_distance distance in output samples over which the compensation should be performed | ||
2991 | * @param sample_delta number of output samples which should be output less | ||
2992 | * | ||
2993 | * example: av_resample_compensate(c, 10, 500) | ||
2994 | * here instead of 510 samples only 500 samples would be output | ||
2995 | * | ||
2996 | * note, due to rounding the actual compensation might be slightly different, | ||
2997 | * especially if the compensation_distance is large and the in_rate used during init is small | ||
2998 | */ | ||
2999 | void av_resample_compensate(struct AVResampleContext *c, int sample_delta, int compensation_distance); | ||
3000 | void av_resample_close(struct AVResampleContext *c); | ||
3001 | |||
3002 | /** | ||
3003 | * Allocate memory for a picture. Call avpicture_free to free it. | ||
3004 | * | ||
3005 | * @param picture the picture to be filled in | ||
3006 | * @param pix_fmt the format of the picture | ||
3007 | * @param width the width of the picture | ||
3008 | * @param height the height of the picture | ||
3009 | * @return zero if successful, a negative value if not | ||
3010 | */ | ||
3011 | int avpicture_alloc(AVPicture *picture, enum PixelFormat pix_fmt, int width, int height); | ||
3012 | |||
3013 | /** | ||
3014 | * Free a picture previously allocated by avpicture_alloc(). | ||
3015 | * | ||
3016 | * @param picture the AVPicture to be freed | ||
3017 | */ | ||
3018 | void avpicture_free(AVPicture *picture); | ||
3019 | |||
3020 | /** | ||
3021 | * Fill in the AVPicture fields. | ||
3022 | * The fields of the given AVPicture are filled in by using the 'ptr' address | ||
3023 | * which points to the image data buffer. Depending on the specified picture | ||
3024 | * format, one or multiple image data pointers and line sizes will be set. | ||
3025 | * If a planar format is specified, several pointers will be set pointing to | ||
3026 | * the different picture planes and the line sizes of the different planes | ||
3027 | * will be stored in the lines_sizes array. | ||
3028 | * Call with ptr == NULL to get the required size for the ptr buffer. | ||
3029 | * | ||
3030 | * @param picture AVPicture whose fields are to be filled in | ||
3031 | * @param ptr Buffer which will contain or contains the actual image data | ||
3032 | * @param pix_fmt The format in which the picture data is stored. | ||
3033 | * @param width the width of the image in pixels | ||
3034 | * @param height the height of the image in pixels | ||
3035 | * @return size of the image data in bytes | ||
3036 | */ | ||
3037 | int avpicture_fill(AVPicture *picture, uint8_t *ptr, | ||
3038 | enum PixelFormat pix_fmt, int width, int height); | ||
3039 | int avpicture_layout(const AVPicture* src, enum PixelFormat pix_fmt, int width, int height, | ||
3040 | unsigned char *dest, int dest_size); | ||
3041 | |||
3042 | /** | ||
3043 | * Calculate the size in bytes that a picture of the given width and height | ||
3044 | * would occupy if stored in the given picture format. | ||
3045 | * Note that this returns the size of a compact representation as generated | ||
3046 | * by avpicture_layout, which can be smaller than the size required for e.g. | ||
3047 | * avpicture_fill. | ||
3048 | * | ||
3049 | * @param pix_fmt the given picture format | ||
3050 | * @param width the width of the image | ||
3051 | * @param height the height of the image | ||
3052 | * @return Image data size in bytes or -1 on error (e.g. too large dimensions). | ||
3053 | */ | ||
3054 | int avpicture_get_size(enum PixelFormat pix_fmt, int width, int height); | ||
3055 | void avcodec_get_chroma_sub_sample(enum PixelFormat pix_fmt, int *h_shift, int *v_shift); | ||
3056 | const char *avcodec_get_pix_fmt_name(enum PixelFormat pix_fmt); | ||
3057 | void avcodec_set_dimensions(AVCodecContext *s, int width, int height); | ||
3058 | |||
3059 | #if LIBAVCODEC_VERSION_MAJOR < 53 | ||
3060 | /** | ||
3061 | * Returns the pixel format corresponding to the name name. | ||
3062 | * | ||
3063 | * If there is no pixel format with name name, then looks for a | ||
3064 | * pixel format with the name corresponding to the native endian | ||
3065 | * format of name. | ||
3066 | * For example in a little-endian system, first looks for "gray16", | ||
3067 | * then for "gray16le". | ||
3068 | * | ||
3069 | * Finally if no pixel format has been found, returns PIX_FMT_NONE. | ||
3070 | * | ||
3071 | * @deprecated Deprecated in favor of av_get_pix_fmt(). | ||
3072 | */ | ||
3073 | attribute_deprecated enum PixelFormat avcodec_get_pix_fmt(const char* name); | ||
3074 | #endif | ||
3075 | |||
3076 | /** | ||
3077 | * Returns a value representing the fourCC code associated to the | ||
3078 | * pixel format pix_fmt, or 0 if no associated fourCC code can be | ||
3079 | * found. | ||
3080 | */ | ||
3081 | unsigned int avcodec_pix_fmt_to_codec_tag(enum PixelFormat pix_fmt); | ||
3082 | |||
3083 | #define FF_LOSS_RESOLUTION 0x0001 /**< loss due to resolution change */ | ||
3084 | #define FF_LOSS_DEPTH 0x0002 /**< loss due to color depth change */ | ||
3085 | #define FF_LOSS_COLORSPACE 0x0004 /**< loss due to color space conversion */ | ||
3086 | #define FF_LOSS_ALPHA 0x0008 /**< loss of alpha bits */ | ||
3087 | #define FF_LOSS_COLORQUANT 0x0010 /**< loss due to color quantization */ | ||
3088 | #define FF_LOSS_CHROMA 0x0020 /**< loss of chroma (e.g. RGB to gray conversion) */ | ||
3089 | |||
3090 | /** | ||
3091 | * Computes what kind of losses will occur when converting from one specific | ||
3092 | * pixel format to another. | ||
3093 | * When converting from one pixel format to another, information loss may occur. | ||
3094 | * For example, when converting from RGB24 to GRAY, the color information will | ||
3095 | * be lost. Similarly, other losses occur when converting from some formats to | ||
3096 | * other formats. These losses can involve loss of chroma, but also loss of | ||
3097 | * resolution, loss of color depth, loss due to the color space conversion, loss | ||
3098 | * of the alpha bits or loss due to color quantization. | ||
3099 | * avcodec_get_fix_fmt_loss() informs you about the various types of losses | ||
3100 | * which will occur when converting from one pixel format to another. | ||
3101 | * | ||
3102 | * @param[in] dst_pix_fmt destination pixel format | ||
3103 | * @param[in] src_pix_fmt source pixel format | ||
3104 | * @param[in] has_alpha Whether the source pixel format alpha channel is used. | ||
3105 | * @return Combination of flags informing you what kind of losses will occur. | ||
3106 | */ | ||
3107 | int avcodec_get_pix_fmt_loss(enum PixelFormat dst_pix_fmt, enum PixelFormat src_pix_fmt, | ||
3108 | int has_alpha); | ||
3109 | |||
3110 | /** | ||
3111 | * Finds the best pixel format to convert to given a certain source pixel | ||
3112 | * format. When converting from one pixel format to another, information loss | ||
3113 | * may occur. For example, when converting from RGB24 to GRAY, the color | ||
3114 | * information will be lost. Similarly, other losses occur when converting from | ||
3115 | * some formats to other formats. avcodec_find_best_pix_fmt() searches which of | ||
3116 | * the given pixel formats should be used to suffer the least amount of loss. | ||
3117 | * The pixel formats from which it chooses one, are determined by the | ||
3118 | * pix_fmt_mask parameter. | ||
3119 | * | ||
3120 | * @code | ||
3121 | * src_pix_fmt = PIX_FMT_YUV420P; | ||
3122 | * pix_fmt_mask = (1 << PIX_FMT_YUV422P) || (1 << PIX_FMT_RGB24); | ||
3123 | * dst_pix_fmt = avcodec_find_best_pix_fmt(pix_fmt_mask, src_pix_fmt, alpha, &loss); | ||
3124 | * @endcode | ||
3125 | * | ||
3126 | * @param[in] pix_fmt_mask bitmask determining which pixel format to choose from | ||
3127 | * @param[in] src_pix_fmt source pixel format | ||
3128 | * @param[in] has_alpha Whether the source pixel format alpha channel is used. | ||
3129 | * @param[out] loss_ptr Combination of flags informing you what kind of losses will occur. | ||
3130 | * @return The best pixel format to convert to or -1 if none was found. | ||
3131 | */ | ||
3132 | enum PixelFormat avcodec_find_best_pix_fmt(int64_t pix_fmt_mask, enum PixelFormat src_pix_fmt, | ||
3133 | int has_alpha, int *loss_ptr); | ||
3134 | |||
3135 | |||
3136 | /** | ||
3137 | * Print in buf the string corresponding to the pixel format with | ||
3138 | * number pix_fmt, or an header if pix_fmt is negative. | ||
3139 | * | ||
3140 | * @param[in] buf the buffer where to write the string | ||
3141 | * @param[in] buf_size the size of buf | ||
3142 | * @param[in] pix_fmt the number of the pixel format to print the corresponding info string, or | ||
3143 | * a negative value to print the corresponding header. | ||
3144 | * Meaningful values for obtaining a pixel format info vary from 0 to PIX_FMT_NB -1. | ||
3145 | */ | ||
3146 | void avcodec_pix_fmt_string (char *buf, int buf_size, enum PixelFormat pix_fmt); | ||
3147 | |||
3148 | #define FF_ALPHA_TRANSP 0x0001 /* image has some totally transparent pixels */ | ||
3149 | #define FF_ALPHA_SEMI_TRANSP 0x0002 /* image has some transparent pixels */ | ||
3150 | |||
3151 | /** | ||
3152 | * Tell if an image really has transparent alpha values. | ||
3153 | * @return ored mask of FF_ALPHA_xxx constants | ||
3154 | */ | ||
3155 | int img_get_alpha_info(const AVPicture *src, | ||
3156 | enum PixelFormat pix_fmt, int width, int height); | ||
3157 | |||
3158 | /* deinterlace a picture */ | ||
3159 | /* deinterlace - if not supported return -1 */ | ||
3160 | int avpicture_deinterlace(AVPicture *dst, const AVPicture *src, | ||
3161 | enum PixelFormat pix_fmt, int width, int height); | ||
3162 | |||
3163 | /* external high level API */ | ||
3164 | |||
3165 | /** | ||
3166 | * If c is NULL, returns the first registered codec, | ||
3167 | * if c is non-NULL, returns the next registered codec after c, | ||
3168 | * or NULL if c is the last one. | ||
3169 | */ | ||
3170 | AVCodec *av_codec_next(AVCodec *c); | ||
3171 | |||
3172 | /** | ||
3173 | * Returns the LIBAVCODEC_VERSION_INT constant. | ||
3174 | */ | ||
3175 | unsigned avcodec_version(void); | ||
3176 | |||
3177 | /** | ||
3178 | * Returns the libavcodec build-time configuration. | ||
3179 | */ | ||
3180 | const char *avcodec_configuration(void); | ||
3181 | |||
3182 | /** | ||
3183 | * Returns the libavcodec license. | ||
3184 | */ | ||
3185 | const char *avcodec_license(void); | ||
3186 | |||
3187 | /** | ||
3188 | * Initializes libavcodec. | ||
3189 | * | ||
3190 | * @warning This function must be called before any other libavcodec | ||
3191 | * function. | ||
3192 | */ | ||
3193 | void avcodec_init(void); | ||
3194 | |||
3195 | #if LIBAVCODEC_VERSION_MAJOR < 53 | ||
3196 | /** | ||
3197 | * @deprecated Deprecated in favor of avcodec_register(). | ||
3198 | */ | ||
3199 | attribute_deprecated void register_avcodec(AVCodec *codec); | ||
3200 | #endif | ||
3201 | |||
3202 | /** | ||
3203 | * Register the codec codec and initialize libavcodec. | ||
3204 | * | ||
3205 | * @see avcodec_init() | ||
3206 | */ | ||
3207 | void avcodec_register(AVCodec *codec); | ||
3208 | |||
3209 | /** | ||
3210 | * Finds a registered encoder with a matching codec ID. | ||
3211 | * | ||
3212 | * @param id CodecID of the requested encoder | ||
3213 | * @return An encoder if one was found, NULL otherwise. | ||
3214 | */ | ||
3215 | AVCodec *avcodec_find_encoder(enum CodecID id); | ||
3216 | |||
3217 | /** | ||
3218 | * Finds a registered encoder with the specified name. | ||
3219 | * | ||
3220 | * @param name name of the requested encoder | ||
3221 | * @return An encoder if one was found, NULL otherwise. | ||
3222 | */ | ||
3223 | AVCodec *avcodec_find_encoder_by_name(const char *name); | ||
3224 | |||
3225 | /** | ||
3226 | * Finds a registered decoder with a matching codec ID. | ||
3227 | * | ||
3228 | * @param id CodecID of the requested decoder | ||
3229 | * @return A decoder if one was found, NULL otherwise. | ||
3230 | */ | ||
3231 | AVCodec *avcodec_find_decoder(enum CodecID id); | ||
3232 | |||
3233 | /** | ||
3234 | * Finds a registered decoder with the specified name. | ||
3235 | * | ||
3236 | * @param name name of the requested decoder | ||
3237 | * @return A decoder if one was found, NULL otherwise. | ||
3238 | */ | ||
3239 | AVCodec *avcodec_find_decoder_by_name(const char *name); | ||
3240 | void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode); | ||
3241 | |||
3242 | /** | ||
3243 | * Sets the fields of the given AVCodecContext to default values. | ||
3244 | * | ||
3245 | * @param s The AVCodecContext of which the fields should be set to default values. | ||
3246 | */ | ||
3247 | void avcodec_get_context_defaults(AVCodecContext *s); | ||
3248 | |||
3249 | /** THIS FUNCTION IS NOT YET PART OF THE PUBLIC API! | ||
3250 | * we WILL change its arguments and name a few times! */ | ||
3251 | void avcodec_get_context_defaults2(AVCodecContext *s, enum AVMediaType); | ||
3252 | |||
3253 | /** | ||
3254 | * Allocates an AVCodecContext and sets its fields to default values. The | ||
3255 | * resulting struct can be deallocated by simply calling av_free(). | ||
3256 | * | ||
3257 | * @return An AVCodecContext filled with default values or NULL on failure. | ||
3258 | * @see avcodec_get_context_defaults | ||
3259 | */ | ||
3260 | AVCodecContext *avcodec_alloc_context(void); | ||
3261 | |||
3262 | /** THIS FUNCTION IS NOT YET PART OF THE PUBLIC API! | ||
3263 | * we WILL change its arguments and name a few times! */ | ||
3264 | AVCodecContext *avcodec_alloc_context2(enum AVMediaType); | ||
3265 | |||
3266 | /** | ||
3267 | * Copy the settings of the source AVCodecContext into the destination | ||
3268 | * AVCodecContext. The resulting destination codec context will be | ||
3269 | * unopened, i.e. you are required to call avcodec_open() before you | ||
3270 | * can use this AVCodecContext to decode/encode video/audio data. | ||
3271 | * | ||
3272 | * @param dest target codec context, should be initialized with | ||
3273 | * avcodec_alloc_context(), but otherwise uninitialized | ||
3274 | * @param src source codec context | ||
3275 | * @return AVERROR() on error (e.g. memory allocation error), 0 on success | ||
3276 | */ | ||
3277 | int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src); | ||
3278 | |||
3279 | /** | ||
3280 | * Sets the fields of the given AVFrame to default values. | ||
3281 | * | ||
3282 | * @param pic The AVFrame of which the fields should be set to default values. | ||
3283 | */ | ||
3284 | void avcodec_get_frame_defaults(AVFrame *pic); | ||
3285 | |||
3286 | /** | ||
3287 | * Allocates an AVFrame and sets its fields to default values. The resulting | ||
3288 | * struct can be deallocated by simply calling av_free(). | ||
3289 | * | ||
3290 | * @return An AVFrame filled with default values or NULL on failure. | ||
3291 | * @see avcodec_get_frame_defaults | ||
3292 | */ | ||
3293 | AVFrame *avcodec_alloc_frame(void); | ||
3294 | |||
3295 | int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic); | ||
3296 | void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic); | ||
3297 | int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic); | ||
3298 | |||
3299 | /** | ||
3300 | * Returns the amount of padding in pixels which the get_buffer callback must | ||
3301 | * provide around the edge of the image for codecs which do not have the | ||
3302 | * CODEC_FLAG_EMU_EDGE flag. | ||
3303 | * | ||
3304 | * @return Required padding in pixels. | ||
3305 | */ | ||
3306 | unsigned avcodec_get_edge_width(void); | ||
3307 | /** | ||
3308 | * Modifies width and height values so that they will result in a memory | ||
3309 | * buffer that is acceptable for the codec if you do not use any horizontal | ||
3310 | * padding. | ||
3311 | */ | ||
3312 | void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height); | ||
3313 | /** | ||
3314 | * Modifies width and height values so that they will result in a memory | ||
3315 | * buffer that is acceptable for the codec if you also ensure that all | ||
3316 | * line sizes are a multiple of the respective linesize_align[i]. | ||
3317 | */ | ||
3318 | void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, | ||
3319 | int linesize_align[4]); | ||
3320 | |||
3321 | /** | ||
3322 | * Checks if the given dimension of a picture is valid, meaning that all | ||
3323 | * bytes of the picture can be addressed with a signed int. | ||
3324 | * | ||
3325 | * @param[in] w Width of the picture. | ||
3326 | * @param[in] h Height of the picture. | ||
3327 | * @return Zero if valid, a negative value if invalid. | ||
3328 | */ | ||
3329 | int avcodec_check_dimensions(void *av_log_ctx, unsigned int w, unsigned int h); | ||
3330 | enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat * fmt); | ||
3331 | |||
3332 | int avcodec_thread_init(AVCodecContext *s, int thread_count); | ||
3333 | void avcodec_thread_free(AVCodecContext *s); | ||
3334 | int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size); | ||
3335 | int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int, int),void *arg, int *ret, int count); | ||
3336 | //FIXME func typedef | ||
3337 | |||
3338 | /** | ||
3339 | * Initializes the AVCodecContext to use the given AVCodec. Prior to using this | ||
3340 | * function the context has to be allocated. | ||
3341 | * | ||
3342 | * The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(), | ||
3343 | * avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for | ||
3344 | * retrieving a codec. | ||
3345 | * | ||
3346 | * @warning This function is not thread safe! | ||
3347 | * | ||
3348 | * @code | ||
3349 | * avcodec_register_all(); | ||
3350 | * codec = avcodec_find_decoder(CODEC_ID_H264); | ||
3351 | * if (!codec) | ||
3352 | * exit(1); | ||
3353 | * | ||
3354 | * context = avcodec_alloc_context(); | ||
3355 | * | ||
3356 | * if (avcodec_open(context, codec) < 0) | ||
3357 | * exit(1); | ||
3358 | * @endcode | ||
3359 | * | ||
3360 | * @param avctx The context which will be set up to use the given codec. | ||
3361 | * @param codec The codec to use within the context. | ||
3362 | * @return zero on success, a negative value on error | ||
3363 | * @see avcodec_alloc_context, avcodec_find_decoder, avcodec_find_encoder | ||
3364 | */ | ||
3365 | int avcodec_open(AVCodecContext *avctx, AVCodec *codec); | ||
3366 | |||
3367 | #if LIBAVCODEC_VERSION_MAJOR < 53 | ||
3368 | /** | ||
3369 | * Decodes an audio frame from buf into samples. | ||
3370 | * Wrapper function which calls avcodec_decode_audio3. | ||
3371 | * | ||
3372 | * @deprecated Use avcodec_decode_audio3 instead. | ||
3373 | * @param avctx the codec context | ||
3374 | * @param[out] samples the output buffer | ||
3375 | * @param[in,out] frame_size_ptr the output buffer size in bytes | ||
3376 | * @param[in] buf the input buffer | ||
3377 | * @param[in] buf_size the input buffer size in bytes | ||
3378 | * @return On error a negative value is returned, otherwise the number of bytes | ||
3379 | * used or zero if no frame could be decompressed. | ||
3380 | */ | ||
3381 | attribute_deprecated int avcodec_decode_audio2(AVCodecContext *avctx, int16_t *samples, | ||
3382 | int *frame_size_ptr, | ||
3383 | const uint8_t *buf, int buf_size); | ||
3384 | #endif | ||
3385 | |||
3386 | /** | ||
3387 | * Decodes the audio frame of size avpkt->size from avpkt->data into samples. | ||
3388 | * Some decoders may support multiple frames in a single AVPacket, such | ||
3389 | * decoders would then just decode the first frame. In this case, | ||
3390 | * avcodec_decode_audio3 has to be called again with an AVPacket that contains | ||
3391 | * the remaining data in order to decode the second frame etc. | ||
3392 | * If no frame | ||
3393 | * could be outputted, frame_size_ptr is zero. Otherwise, it is the | ||
3394 | * decompressed frame size in bytes. | ||
3395 | * | ||
3396 | * @warning You must set frame_size_ptr to the allocated size of the | ||
3397 | * output buffer before calling avcodec_decode_audio3(). | ||
3398 | * | ||
3399 | * @warning The input buffer must be FF_INPUT_BUFFER_PADDING_SIZE larger than | ||
3400 | * the actual read bytes because some optimized bitstream readers read 32 or 64 | ||
3401 | * bits at once and could read over the end. | ||
3402 | * | ||
3403 | * @warning The end of the input buffer avpkt->data should be set to 0 to ensure that | ||
3404 | * no overreading happens for damaged MPEG streams. | ||
3405 | * | ||
3406 | * @note You might have to align the input buffer avpkt->data and output buffer | ||
3407 | * samples. The alignment requirements depend on the CPU: On some CPUs it isn't | ||
3408 | * necessary at all, on others it won't work at all if not aligned and on others | ||
3409 | * it will work but it will have an impact on performance. | ||
3410 | * | ||
3411 | * In practice, avpkt->data should have 4 byte alignment at minimum and | ||
3412 | * samples should be 16 byte aligned unless the CPU doesn't need it | ||
3413 | * (AltiVec and SSE do). | ||
3414 | * | ||
3415 | * @param avctx the codec context | ||
3416 | * @param[out] samples the output buffer, sample type in avctx->sample_fmt | ||
3417 | * @param[in,out] frame_size_ptr the output buffer size in bytes | ||
3418 | * @param[in] avpkt The input AVPacket containing the input buffer. | ||
3419 | * You can create such packet with av_init_packet() and by then setting | ||
3420 | * data and size, some decoders might in addition need other fields. | ||
3421 | * All decoders are designed to use the least fields possible though. | ||
3422 | * @return On error a negative value is returned, otherwise the number of bytes | ||
3423 | * used or zero if no frame data was decompressed (used) from the input AVPacket. | ||
3424 | */ | ||
3425 | int avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples, | ||
3426 | int *frame_size_ptr, | ||
3427 | AVPacket *avpkt); | ||
3428 | |||
3429 | #if LIBAVCODEC_VERSION_MAJOR < 53 | ||
3430 | /** | ||
3431 | * Decodes a video frame from buf into picture. | ||
3432 | * Wrapper function which calls avcodec_decode_video2. | ||
3433 | * | ||
3434 | * @deprecated Use avcodec_decode_video2 instead. | ||
3435 | * @param avctx the codec context | ||
3436 | * @param[out] picture The AVFrame in which the decoded video frame will be stored. | ||
3437 | * @param[in] buf the input buffer | ||
3438 | * @param[in] buf_size the size of the input buffer in bytes | ||
3439 | * @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero. | ||
3440 | * @return On error a negative value is returned, otherwise the number of bytes | ||
3441 | * used or zero if no frame could be decompressed. | ||
3442 | */ | ||
3443 | attribute_deprecated int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture, | ||
3444 | int *got_picture_ptr, | ||
3445 | const uint8_t *buf, int buf_size); | ||
3446 | #endif | ||
3447 | |||
3448 | /** | ||
3449 | * Decodes the video frame of size avpkt->size from avpkt->data into picture. | ||
3450 | * Some decoders may support multiple frames in a single AVPacket, such | ||
3451 | * decoders would then just decode the first frame. | ||
3452 | * | ||
3453 | * @warning The input buffer must be FF_INPUT_BUFFER_PADDING_SIZE larger than | ||
3454 | * the actual read bytes because some optimized bitstream readers read 32 or 64 | ||
3455 | * bits at once and could read over the end. | ||
3456 | * | ||
3457 | * @warning The end of the input buffer buf should be set to 0 to ensure that | ||
3458 | * no overreading happens for damaged MPEG streams. | ||
3459 | * | ||
3460 | * @note You might have to align the input buffer avpkt->data. | ||
3461 | * The alignment requirements depend on the CPU: on some CPUs it isn't | ||
3462 | * necessary at all, on others it won't work at all if not aligned and on others | ||
3463 | * it will work but it will have an impact on performance. | ||
3464 | * | ||
3465 | * In practice, avpkt->data should have 4 byte alignment at minimum. | ||
3466 | * | ||
3467 | * @note Some codecs have a delay between input and output, these need to be | ||
3468 | * fed with avpkt->data=NULL, avpkt->size=0 at the end to return the remaining frames. | ||
3469 | * | ||
3470 | * @param avctx the codec context | ||
3471 | * @param[out] picture The AVFrame in which the decoded video frame will be stored. | ||
3472 | * @param[in] avpkt The input AVpacket containing the input buffer. | ||
3473 | * You can create such packet with av_init_packet() and by then setting | ||
3474 | * data and size, some decoders might in addition need other fields like | ||
3475 | * flags&AV_PKT_FLAG_KEY. All decoders are designed to use the least | ||
3476 | * fields possible. | ||
3477 | * @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero. | ||
3478 | * @return On error a negative value is returned, otherwise the number of bytes | ||
3479 | * used or zero if no frame could be decompressed. | ||
3480 | */ | ||
3481 | int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, | ||
3482 | int *got_picture_ptr, | ||
3483 | AVPacket *avpkt); | ||
3484 | |||
3485 | #if LIBAVCODEC_VERSION_MAJOR < 53 | ||
3486 | /* Decode a subtitle message. Return -1 if error, otherwise return the | ||
3487 | * number of bytes used. If no subtitle could be decompressed, | ||
3488 | * got_sub_ptr is zero. Otherwise, the subtitle is stored in *sub. */ | ||
3489 | attribute_deprecated int avcodec_decode_subtitle(AVCodecContext *avctx, AVSubtitle *sub, | ||
3490 | int *got_sub_ptr, | ||
3491 | const uint8_t *buf, int buf_size); | ||
3492 | #endif | ||
3493 | |||
3494 | /** | ||
3495 | * Decodes a subtitle message. | ||
3496 | * Returns a negative value on error, otherwise returns the number of bytes used. | ||
3497 | * If no subtitle could be decompressed, got_sub_ptr is zero. | ||
3498 | * Otherwise, the subtitle is stored in *sub. | ||
3499 | * | ||
3500 | * @param avctx the codec context | ||
3501 | * @param[out] sub The AVSubtitle in which the decoded subtitle will be stored. | ||
3502 | * @param[in,out] got_sub_ptr Zero if no subtitle could be decompressed, otherwise, it is nonzero. | ||
3503 | * @param[in] avpkt The input AVPacket containing the input buffer. | ||
3504 | */ | ||
3505 | int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, | ||
3506 | int *got_sub_ptr, | ||
3507 | AVPacket *avpkt); | ||
3508 | int avcodec_parse_frame(AVCodecContext *avctx, uint8_t **pdata, | ||
3509 | int *data_size_ptr, | ||
3510 | uint8_t *buf, int buf_size); | ||
3511 | |||
3512 | /** | ||
3513 | * Encodes an audio frame from samples into buf. | ||
3514 | * | ||
3515 | * @note The output buffer should be at least FF_MIN_BUFFER_SIZE bytes large. | ||
3516 | * However, for PCM audio the user will know how much space is needed | ||
3517 | * because it depends on the value passed in buf_size as described | ||
3518 | * below. In that case a lower value can be used. | ||
3519 | * | ||
3520 | * @param avctx the codec context | ||
3521 | * @param[out] buf the output buffer | ||
3522 | * @param[in] buf_size the output buffer size | ||
3523 | * @param[in] samples the input buffer containing the samples | ||
3524 | * The number of samples read from this buffer is frame_size*channels, | ||
3525 | * both of which are defined in avctx. | ||
3526 | * For PCM audio the number of samples read from samples is equal to | ||
3527 | * buf_size * input_sample_size / output_sample_size. | ||
3528 | * @return On error a negative value is returned, on success zero or the number | ||
3529 | * of bytes used to encode the data read from the input buffer. | ||
3530 | */ | ||
3531 | int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size, | ||
3532 | const short *samples); | ||
3533 | |||
3534 | /** | ||
3535 | * Encodes a video frame from pict into buf. | ||
3536 | * The input picture should be | ||
3537 | * stored using a specific format, namely avctx.pix_fmt. | ||
3538 | * | ||
3539 | * @param avctx the codec context | ||
3540 | * @param[out] buf the output buffer for the bitstream of encoded frame | ||
3541 | * @param[in] buf_size the size of the output buffer in bytes | ||
3542 | * @param[in] pict the input picture to encode | ||
3543 | * @return On error a negative value is returned, on success zero or the number | ||
3544 | * of bytes used from the output buffer. | ||
3545 | */ | ||
3546 | int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size, | ||
3547 | const AVFrame *pict); | ||
3548 | int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, | ||
3549 | const AVSubtitle *sub); | ||
3550 | |||
3551 | int avcodec_close(AVCodecContext *avctx); | ||
3552 | |||
3553 | /** | ||
3554 | * Register all the codecs, parsers and bitstream filters which were enabled at | ||
3555 | * configuration time. If you do not call this function you can select exactly | ||
3556 | * which formats you want to support, by using the individual registration | ||
3557 | * functions. | ||
3558 | * | ||
3559 | * @see avcodec_register | ||
3560 | * @see av_register_codec_parser | ||
3561 | * @see av_register_bitstream_filter | ||
3562 | */ | ||
3563 | void avcodec_register_all(void); | ||
3564 | |||
3565 | /** | ||
3566 | * Flush buffers, should be called when seeking or when switching to a different stream. | ||
3567 | */ | ||
3568 | void avcodec_flush_buffers(AVCodecContext *avctx); | ||
3569 | |||
3570 | void avcodec_default_free_buffers(AVCodecContext *s); | ||
3571 | |||
3572 | /* misc useful functions */ | ||
3573 | |||
3574 | /** | ||
3575 | * Returns a single letter to describe the given picture type pict_type. | ||
3576 | * | ||
3577 | * @param[in] pict_type the picture type | ||
3578 | * @return A single character representing the picture type. | ||
3579 | */ | ||
3580 | char av_get_pict_type_char(int pict_type); | ||
3581 | |||
3582 | /** | ||
3583 | * Returns codec bits per sample. | ||
3584 | * | ||
3585 | * @param[in] codec_id the codec | ||
3586 | * @return Number of bits per sample or zero if unknown for the given codec. | ||
3587 | */ | ||
3588 | int av_get_bits_per_sample(enum CodecID codec_id); | ||
3589 | |||
3590 | /** | ||
3591 | * Returns sample format bits per sample. | ||
3592 | * | ||
3593 | * @param[in] sample_fmt the sample format | ||
3594 | * @return Number of bits per sample or zero if unknown for the given sample format. | ||
3595 | */ | ||
3596 | int av_get_bits_per_sample_format(enum SampleFormat sample_fmt); | ||
3597 | |||
3598 | /* frame parsing */ | ||
3599 | typedef struct AVCodecParserContext { | ||
3600 | void *priv_data; | ||
3601 | struct AVCodecParser *parser; | ||
3602 | int64_t frame_offset; /* offset of the current frame */ | ||
3603 | int64_t cur_offset; /* current offset | ||
3604 | (incremented by each av_parser_parse()) */ | ||
3605 | int64_t next_frame_offset; /* offset of the next frame */ | ||
3606 | /* video info */ | ||
3607 | int pict_type; /* XXX: Put it back in AVCodecContext. */ | ||
3608 | /** | ||
3609 | * This field is used for proper frame duration computation in lavf. | ||
3610 | * It signals, how much longer the frame duration of the current frame | ||
3611 | * is compared to normal frame duration. | ||
3612 | * | ||
3613 | * frame_duration = (1 + repeat_pict) * time_base | ||
3614 | * | ||
3615 | * It is used by codecs like H.264 to display telecined material. | ||
3616 | */ | ||
3617 | int repeat_pict; /* XXX: Put it back in AVCodecContext. */ | ||
3618 | int64_t pts; /* pts of the current frame */ | ||
3619 | int64_t dts; /* dts of the current frame */ | ||
3620 | |||
3621 | /* private data */ | ||
3622 | int64_t last_pts; | ||
3623 | int64_t last_dts; | ||
3624 | int fetch_timestamp; | ||
3625 | |||
3626 | #define AV_PARSER_PTS_NB 4 | ||
3627 | int cur_frame_start_index; | ||
3628 | int64_t cur_frame_offset[AV_PARSER_PTS_NB]; | ||
3629 | int64_t cur_frame_pts[AV_PARSER_PTS_NB]; | ||
3630 | int64_t cur_frame_dts[AV_PARSER_PTS_NB]; | ||
3631 | |||
3632 | int flags; | ||
3633 | #define PARSER_FLAG_COMPLETE_FRAMES 0x0001 | ||
3634 | |||
3635 | int64_t offset; ///< byte offset from starting packet start | ||
3636 | int64_t cur_frame_end[AV_PARSER_PTS_NB]; | ||
3637 | |||
3638 | /*! | ||
3639 | * Set by parser to 1 for key frames and 0 for non-key frames. | ||
3640 | * It is initialized to -1, so if the parser doesn't set this flag, | ||
3641 | * old-style fallback using FF_I_TYPE picture type as key frames | ||
3642 | * will be used. | ||
3643 | */ | ||
3644 | int key_frame; | ||
3645 | |||
3646 | /** | ||
3647 | * Time difference in stream time base units from the pts of this | ||
3648 | * packet to the point at which the output from the decoder has converged | ||
3649 | * independent from the availability of previous frames. That is, the | ||
3650 | * frames are virtually identical no matter if decoding started from | ||
3651 | * the very first frame or from this keyframe. | ||
3652 | * Is AV_NOPTS_VALUE if unknown. | ||
3653 | * This field is not the display duration of the current frame. | ||
3654 | * | ||
3655 | * The purpose of this field is to allow seeking in streams that have no | ||
3656 | * keyframes in the conventional sense. It corresponds to the | ||
3657 | * recovery point SEI in H.264 and match_time_delta in NUT. It is also | ||
3658 | * essential for some types of subtitle streams to ensure that all | ||
3659 | * subtitles are correctly displayed after seeking. | ||
3660 | */ | ||
3661 | int64_t convergence_duration; | ||
3662 | |||
3663 | // Timestamp generation support: | ||
3664 | /** | ||
3665 | * Synchronization point for start of timestamp generation. | ||
3666 | * | ||
3667 | * Set to >0 for sync point, 0 for no sync point and <0 for undefined | ||
3668 | * (default). | ||
3669 | * | ||
3670 | * For example, this corresponds to presence of H.264 buffering period | ||
3671 | * SEI message. | ||
3672 | */ | ||
3673 | int dts_sync_point; | ||
3674 | |||
3675 | /** | ||
3676 | * Offset of the current timestamp against last timestamp sync point in | ||
3677 | * units of AVCodecContext.time_base. | ||
3678 | * | ||
3679 | * Set to INT_MIN when dts_sync_point unused. Otherwise, it must | ||
3680 | * contain a valid timestamp offset. | ||
3681 | * | ||
3682 | * Note that the timestamp of sync point has usually a nonzero | ||
3683 | * dts_ref_dts_delta, which refers to the previous sync point. Offset of | ||
3684 | * the next frame after timestamp sync point will be usually 1. | ||
3685 | * | ||
3686 | * For example, this corresponds to H.264 cpb_removal_delay. | ||
3687 | */ | ||
3688 | int dts_ref_dts_delta; | ||
3689 | |||
3690 | /** | ||
3691 | * Presentation delay of current frame in units of AVCodecContext.time_base. | ||
3692 | * | ||
3693 | * Set to INT_MIN when dts_sync_point unused. Otherwise, it must | ||
3694 | * contain valid non-negative timestamp delta (presentation time of a frame | ||
3695 | * must not lie in the past). | ||
3696 | * | ||
3697 | * This delay represents the difference between decoding and presentation | ||
3698 | * time of the frame. | ||
3699 | * | ||
3700 | * For example, this corresponds to H.264 dpb_output_delay. | ||
3701 | */ | ||
3702 | int pts_dts_delta; | ||
3703 | |||
3704 | /** | ||
3705 | * Position of the packet in file. | ||
3706 | * | ||
3707 | * Analogous to cur_frame_pts/dts | ||
3708 | */ | ||
3709 | int64_t cur_frame_pos[AV_PARSER_PTS_NB]; | ||
3710 | |||
3711 | /** | ||
3712 | * Byte position of currently parsed frame in stream. | ||
3713 | */ | ||
3714 | int64_t pos; | ||
3715 | |||
3716 | /** | ||
3717 | * Previous frame byte position. | ||
3718 | */ | ||
3719 | int64_t last_pos; | ||
3720 | } AVCodecParserContext; | ||
3721 | |||
3722 | typedef struct AVCodecParser { | ||
3723 | int codec_ids[5]; /* several codec IDs are permitted */ | ||
3724 | int priv_data_size; | ||
3725 | int (*parser_init)(AVCodecParserContext *s); | ||
3726 | int (*parser_parse)(AVCodecParserContext *s, | ||
3727 | AVCodecContext *avctx, | ||
3728 | const uint8_t **poutbuf, int *poutbuf_size, | ||
3729 | const uint8_t *buf, int buf_size); | ||
3730 | void (*parser_close)(AVCodecParserContext *s); | ||
3731 | int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size); | ||
3732 | struct AVCodecParser *next; | ||
3733 | } AVCodecParser; | ||
3734 | |||
3735 | AVCodecParser *av_parser_next(AVCodecParser *c); | ||
3736 | |||
3737 | void av_register_codec_parser(AVCodecParser *parser); | ||
3738 | AVCodecParserContext *av_parser_init(int codec_id); | ||
3739 | |||
3740 | #if LIBAVCODEC_VERSION_MAJOR < 53 | ||
3741 | attribute_deprecated | ||
3742 | int av_parser_parse(AVCodecParserContext *s, | ||
3743 | AVCodecContext *avctx, | ||
3744 | uint8_t **poutbuf, int *poutbuf_size, | ||
3745 | const uint8_t *buf, int buf_size, | ||
3746 | int64_t pts, int64_t dts); | ||
3747 | #endif | ||
3748 | |||
3749 | /** | ||
3750 | * Parse a packet. | ||
3751 | * | ||
3752 | * @param s parser context. | ||
3753 | * @param avctx codec context. | ||
3754 | * @param poutbuf set to pointer to parsed buffer or NULL if not yet finished. | ||
3755 | * @param poutbuf_size set to size of parsed buffer or zero if not yet finished. | ||
3756 | * @param buf input buffer. | ||
3757 | * @param buf_size input length, to signal EOF, this should be 0 (so that the last frame can be output). | ||
3758 | * @param pts input presentation timestamp. | ||
3759 | * @param dts input decoding timestamp. | ||
3760 | * @param pos input byte position in stream. | ||
3761 | * @return the number of bytes of the input bitstream used. | ||
3762 | * | ||
3763 | * Example: | ||
3764 | * @code | ||
3765 | * while(in_len){ | ||
3766 | * len = av_parser_parse2(myparser, AVCodecContext, &data, &size, | ||
3767 | * in_data, in_len, | ||
3768 | * pts, dts, pos); | ||
3769 | * in_data += len; | ||
3770 | * in_len -= len; | ||
3771 | * | ||
3772 | * if(size) | ||
3773 | * decode_frame(data, size); | ||
3774 | * } | ||
3775 | * @endcode | ||
3776 | */ | ||
3777 | int av_parser_parse2(AVCodecParserContext *s, | ||
3778 | AVCodecContext *avctx, | ||
3779 | uint8_t **poutbuf, int *poutbuf_size, | ||
3780 | const uint8_t *buf, int buf_size, | ||
3781 | int64_t pts, int64_t dts, | ||
3782 | int64_t pos); | ||
3783 | |||
3784 | int av_parser_change(AVCodecParserContext *s, | ||
3785 | AVCodecContext *avctx, | ||
3786 | uint8_t **poutbuf, int *poutbuf_size, | ||
3787 | const uint8_t *buf, int buf_size, int keyframe); | ||
3788 | void av_parser_close(AVCodecParserContext *s); | ||
3789 | |||
3790 | |||
3791 | typedef struct AVBitStreamFilterContext { | ||
3792 | void *priv_data; | ||
3793 | struct AVBitStreamFilter *filter; | ||
3794 | AVCodecParserContext *parser; | ||
3795 | struct AVBitStreamFilterContext *next; | ||
3796 | } AVBitStreamFilterContext; | ||
3797 | |||
3798 | |||
3799 | typedef struct AVBitStreamFilter { | ||
3800 | const char *name; | ||
3801 | int priv_data_size; | ||
3802 | int (*filter)(AVBitStreamFilterContext *bsfc, | ||
3803 | AVCodecContext *avctx, const char *args, | ||
3804 | uint8_t **poutbuf, int *poutbuf_size, | ||
3805 | const uint8_t *buf, int buf_size, int keyframe); | ||
3806 | void (*close)(AVBitStreamFilterContext *bsfc); | ||
3807 | struct AVBitStreamFilter *next; | ||
3808 | } AVBitStreamFilter; | ||
3809 | |||
3810 | void av_register_bitstream_filter(AVBitStreamFilter *bsf); | ||
3811 | AVBitStreamFilterContext *av_bitstream_filter_init(const char *name); | ||
3812 | int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc, | ||
3813 | AVCodecContext *avctx, const char *args, | ||
3814 | uint8_t **poutbuf, int *poutbuf_size, | ||
3815 | const uint8_t *buf, int buf_size, int keyframe); | ||
3816 | void av_bitstream_filter_close(AVBitStreamFilterContext *bsf); | ||
3817 | |||
3818 | AVBitStreamFilter *av_bitstream_filter_next(AVBitStreamFilter *f); | ||
3819 | |||
3820 | /* memory */ | ||
3821 | |||
3822 | /** | ||
3823 | * Reallocates the given block if it is not large enough, otherwise it | ||
3824 | * does nothing. | ||
3825 | * | ||
3826 | * @see av_realloc | ||
3827 | */ | ||
3828 | void *av_fast_realloc(void *ptr, unsigned int *size, unsigned int min_size); | ||
3829 | |||
3830 | /** | ||
3831 | * Allocates a buffer, reusing the given one if large enough. | ||
3832 | * | ||
3833 | * Contrary to av_fast_realloc the current buffer contents might not be | ||
3834 | * preserved and on error the old buffer is freed, thus no special | ||
3835 | * handling to avoid memleaks is necessary. | ||
3836 | * | ||
3837 | * @param ptr pointer to pointer to already allocated buffer, overwritten with pointer to new buffer | ||
3838 | * @param size size of the buffer *ptr points to | ||
3839 | * @param min_size minimum size of *ptr buffer after returning, *ptr will be NULL and | ||
3840 | * *size 0 if an error occurred. | ||
3841 | */ | ||
3842 | void av_fast_malloc(void *ptr, unsigned int *size, unsigned int min_size); | ||
3843 | |||
3844 | /** | ||
3845 | * Copy image 'src' to 'dst'. | ||
3846 | */ | ||
3847 | void av_picture_copy(AVPicture *dst, const AVPicture *src, | ||
3848 | enum PixelFormat pix_fmt, int width, int height); | ||
3849 | |||
3850 | /** | ||
3851 | * Crop image top and left side. | ||
3852 | */ | ||
3853 | int av_picture_crop(AVPicture *dst, const AVPicture *src, | ||
3854 | enum PixelFormat pix_fmt, int top_band, int left_band); | ||
3855 | |||
3856 | /** | ||
3857 | * Pad image. | ||
3858 | */ | ||
3859 | int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, enum PixelFormat pix_fmt, | ||
3860 | int padtop, int padbottom, int padleft, int padright, int *color); | ||
3861 | |||
3862 | /** | ||
3863 | * Encodes extradata length to a buffer. Used by xiph codecs. | ||
3864 | * | ||
3865 | * @param s buffer to write to; must be at least (v/255+1) bytes long | ||
3866 | * @param v size of extradata in bytes | ||
3867 | * @return number of bytes written to the buffer. | ||
3868 | */ | ||
3869 | unsigned int av_xiphlacing(unsigned char *s, unsigned int v); | ||
3870 | |||
3871 | /** | ||
3872 | * Parses str and put in width_ptr and height_ptr the detected values. | ||
3873 | * | ||
3874 | * @return 0 in case of a successful parsing, a negative value otherwise | ||
3875 | * @param[in] str the string to parse: it has to be a string in the format | ||
3876 | * <width>x<height> or a valid video frame size abbreviation. | ||
3877 | * @param[in,out] width_ptr pointer to the variable which will contain the detected | ||
3878 | * frame width value | ||
3879 | * @param[in,out] height_ptr pointer to the variable which will contain the detected | ||
3880 | * frame height value | ||
3881 | */ | ||
3882 | int av_parse_video_frame_size(int *width_ptr, int *height_ptr, const char *str); | ||
3883 | |||
3884 | /** | ||
3885 | * Parses str and put in frame_rate the detected values. | ||
3886 | * | ||
3887 | * @return 0 in case of a successful parsing, a negative value otherwise | ||
3888 | * @param[in] str the string to parse: it has to be a string in the format | ||
3889 | * <frame_rate_num>/<frame_rate_den>, a float number or a valid video rate abbreviation | ||
3890 | * @param[in,out] frame_rate pointer to the AVRational which will contain the detected | ||
3891 | * frame rate | ||
3892 | */ | ||
3893 | //int av_parse_video_frame_rate(AVRational *frame_rate, const char *str); | ||
3894 | |||
3895 | /** | ||
3896 | * Logs a generic warning message about a missing feature. This function is | ||
3897 | * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.) | ||
3898 | * only, and would normally not be used by applications. | ||
3899 | * @param[in] avc a pointer to an arbitrary struct of which the first field is | ||
3900 | * a pointer to an AVClass struct | ||
3901 | * @param[in] feature string containing the name of the missing feature | ||
3902 | * @param[in] want_sample indicates if samples are wanted which exhibit this feature. | ||
3903 | * If want_sample is non-zero, additional verbage will be added to the log | ||
3904 | * message which tells the user how to report samples to the development | ||
3905 | * mailing list. | ||
3906 | */ | ||
3907 | void av_log_missing_feature(void *avc, const char *feature, int want_sample); | ||
3908 | |||
3909 | /** | ||
3910 | * Logs a generic warning message asking for a sample. This function is | ||
3911 | * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.) | ||
3912 | * only, and would normally not be used by applications. | ||
3913 | * @param[in] avc a pointer to an arbitrary struct of which the first field is | ||
3914 | * a pointer to an AVClass struct | ||
3915 | * @param[in] msg string containing an optional message, or NULL if no message | ||
3916 | */ | ||
3917 | void av_log_ask_for_sample(void *avc, const char *msg); | ||
3918 | |||
3919 | /** | ||
3920 | * Registers the hardware accelerator hwaccel. | ||
3921 | */ | ||
3922 | void av_register_hwaccel(AVHWAccel *hwaccel); | ||
3923 | |||
3924 | /** | ||
3925 | * If hwaccel is NULL, returns the first registered hardware accelerator, | ||
3926 | * if hwaccel is non-NULL, returns the next registered hardware accelerator | ||
3927 | * after hwaccel, or NULL if hwaccel is the last one. | ||
3928 | */ | ||
3929 | AVHWAccel *av_hwaccel_next(AVHWAccel *hwaccel); | ||
3930 | |||
3931 | |||
3932 | /** | ||
3933 | * Lock operation used by lockmgr | ||
3934 | */ | ||
3935 | enum AVLockOp { | ||
3936 | AV_LOCK_CREATE, ///< Create a mutex | ||
3937 | AV_LOCK_OBTAIN, ///< Lock the mutex | ||
3938 | AV_LOCK_RELEASE, ///< Unlock the mutex | ||
3939 | AV_LOCK_DESTROY, ///< Free mutex resources | ||
3940 | }; | ||
3941 | |||
3942 | /** | ||
3943 | * Register a user provided lock manager supporting the operations | ||
3944 | * specified by AVLockOp. mutex points to a (void *) where the | ||
3945 | * lockmgr should store/get a pointer to a user allocated mutex. It's | ||
3946 | * NULL upon AV_LOCK_CREATE and != NULL for all other ops. | ||
3947 | * | ||
3948 | * @param cb User defined callback. Note: FFmpeg may invoke calls to this | ||
3949 | * callback during the call to av_lockmgr_register(). | ||
3950 | * Thus, the application must be prepared to handle that. | ||
3951 | * If cb is set to NULL the lockmgr will be unregistered. | ||
3952 | * Also note that during unregistration the previously registered | ||
3953 | * lockmgr callback may also be invoked. | ||
3954 | */ | ||
3955 | int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op)); | ||
3956 | |||
3957 | #endif /* AVCODEC_AVCODEC_H */ | ||