You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

4525 lines
146KB

  1. /*
  2. * copyright (c) 2001 Fabrice Bellard
  3. *
  4. * This file is part of Libav.
  5. *
  6. * Libav 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. * Libav 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 Libav; if not, write to the Free Software
  18. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19. */
  20. #ifndef AVCODEC_AVCODEC_H
  21. #define AVCODEC_AVCODEC_H
  22. /**
  23. * @file
  24. * @ingroup libavc
  25. * Libavcodec external API header
  26. */
  27. #include <errno.h>
  28. #include "libavutil/samplefmt.h"
  29. #include "libavutil/attributes.h"
  30. #include "libavutil/avutil.h"
  31. #include "libavutil/buffer.h"
  32. #include "libavutil/cpu.h"
  33. #include "libavutil/dict.h"
  34. #include "libavutil/frame.h"
  35. #include "libavutil/log.h"
  36. #include "libavutil/pixfmt.h"
  37. #include "libavutil/rational.h"
  38. #include "version.h"
  39. #if FF_API_FAST_MALLOC
  40. // to provide fast_*alloc
  41. #include "libavutil/mem.h"
  42. #endif
  43. /**
  44. * @defgroup libavc Encoding/Decoding Library
  45. * @{
  46. *
  47. * @defgroup lavc_decoding Decoding
  48. * @{
  49. * @}
  50. *
  51. * @defgroup lavc_encoding Encoding
  52. * @{
  53. * @}
  54. *
  55. * @defgroup lavc_codec Codecs
  56. * @{
  57. * @defgroup lavc_codec_native Native Codecs
  58. * @{
  59. * @}
  60. * @defgroup lavc_codec_wrappers External library wrappers
  61. * @{
  62. * @}
  63. * @defgroup lavc_codec_hwaccel Hardware Accelerators bridge
  64. * @{
  65. * @}
  66. * @}
  67. * @defgroup lavc_internal Internal
  68. * @{
  69. * @}
  70. * @}
  71. *
  72. */
  73. /**
  74. * @defgroup lavc_core Core functions/structures.
  75. * @ingroup libavc
  76. *
  77. * Basic definitions, functions for querying libavcodec capabilities,
  78. * allocating core structures, etc.
  79. * @{
  80. */
  81. /**
  82. * Identify the syntax and semantics of the bitstream.
  83. * The principle is roughly:
  84. * Two decoders with the same ID can decode the same streams.
  85. * Two encoders with the same ID can encode compatible streams.
  86. * There may be slight deviations from the principle due to implementation
  87. * details.
  88. *
  89. * If you add a codec ID to this list, add it so that
  90. * 1. no value of a existing codec ID changes (that would break ABI),
  91. * 2. it is as close as possible to similar codecs.
  92. *
  93. * After adding new codec IDs, do not forget to add an entry to the codec
  94. * descriptor list and bump libavcodec minor version.
  95. */
  96. enum AVCodecID {
  97. AV_CODEC_ID_NONE,
  98. /* video codecs */
  99. AV_CODEC_ID_MPEG1VIDEO,
  100. AV_CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding
  101. #if FF_API_XVMC
  102. AV_CODEC_ID_MPEG2VIDEO_XVMC,
  103. #endif /* FF_API_XVMC */
  104. AV_CODEC_ID_H261,
  105. AV_CODEC_ID_H263,
  106. AV_CODEC_ID_RV10,
  107. AV_CODEC_ID_RV20,
  108. AV_CODEC_ID_MJPEG,
  109. AV_CODEC_ID_MJPEGB,
  110. AV_CODEC_ID_LJPEG,
  111. AV_CODEC_ID_SP5X,
  112. AV_CODEC_ID_JPEGLS,
  113. AV_CODEC_ID_MPEG4,
  114. AV_CODEC_ID_RAWVIDEO,
  115. AV_CODEC_ID_MSMPEG4V1,
  116. AV_CODEC_ID_MSMPEG4V2,
  117. AV_CODEC_ID_MSMPEG4V3,
  118. AV_CODEC_ID_WMV1,
  119. AV_CODEC_ID_WMV2,
  120. AV_CODEC_ID_H263P,
  121. AV_CODEC_ID_H263I,
  122. AV_CODEC_ID_FLV1,
  123. AV_CODEC_ID_SVQ1,
  124. AV_CODEC_ID_SVQ3,
  125. AV_CODEC_ID_DVVIDEO,
  126. AV_CODEC_ID_HUFFYUV,
  127. AV_CODEC_ID_CYUV,
  128. AV_CODEC_ID_H264,
  129. AV_CODEC_ID_INDEO3,
  130. AV_CODEC_ID_VP3,
  131. AV_CODEC_ID_THEORA,
  132. AV_CODEC_ID_ASV1,
  133. AV_CODEC_ID_ASV2,
  134. AV_CODEC_ID_FFV1,
  135. AV_CODEC_ID_4XM,
  136. AV_CODEC_ID_VCR1,
  137. AV_CODEC_ID_CLJR,
  138. AV_CODEC_ID_MDEC,
  139. AV_CODEC_ID_ROQ,
  140. AV_CODEC_ID_INTERPLAY_VIDEO,
  141. AV_CODEC_ID_XAN_WC3,
  142. AV_CODEC_ID_XAN_WC4,
  143. AV_CODEC_ID_RPZA,
  144. AV_CODEC_ID_CINEPAK,
  145. AV_CODEC_ID_WS_VQA,
  146. AV_CODEC_ID_MSRLE,
  147. AV_CODEC_ID_MSVIDEO1,
  148. AV_CODEC_ID_IDCIN,
  149. AV_CODEC_ID_8BPS,
  150. AV_CODEC_ID_SMC,
  151. AV_CODEC_ID_FLIC,
  152. AV_CODEC_ID_TRUEMOTION1,
  153. AV_CODEC_ID_VMDVIDEO,
  154. AV_CODEC_ID_MSZH,
  155. AV_CODEC_ID_ZLIB,
  156. AV_CODEC_ID_QTRLE,
  157. AV_CODEC_ID_TSCC,
  158. AV_CODEC_ID_ULTI,
  159. AV_CODEC_ID_QDRAW,
  160. AV_CODEC_ID_VIXL,
  161. AV_CODEC_ID_QPEG,
  162. AV_CODEC_ID_PNG,
  163. AV_CODEC_ID_PPM,
  164. AV_CODEC_ID_PBM,
  165. AV_CODEC_ID_PGM,
  166. AV_CODEC_ID_PGMYUV,
  167. AV_CODEC_ID_PAM,
  168. AV_CODEC_ID_FFVHUFF,
  169. AV_CODEC_ID_RV30,
  170. AV_CODEC_ID_RV40,
  171. AV_CODEC_ID_VC1,
  172. AV_CODEC_ID_WMV3,
  173. AV_CODEC_ID_LOCO,
  174. AV_CODEC_ID_WNV1,
  175. AV_CODEC_ID_AASC,
  176. AV_CODEC_ID_INDEO2,
  177. AV_CODEC_ID_FRAPS,
  178. AV_CODEC_ID_TRUEMOTION2,
  179. AV_CODEC_ID_BMP,
  180. AV_CODEC_ID_CSCD,
  181. AV_CODEC_ID_MMVIDEO,
  182. AV_CODEC_ID_ZMBV,
  183. AV_CODEC_ID_AVS,
  184. AV_CODEC_ID_SMACKVIDEO,
  185. AV_CODEC_ID_NUV,
  186. AV_CODEC_ID_KMVC,
  187. AV_CODEC_ID_FLASHSV,
  188. AV_CODEC_ID_CAVS,
  189. AV_CODEC_ID_JPEG2000,
  190. AV_CODEC_ID_VMNC,
  191. AV_CODEC_ID_VP5,
  192. AV_CODEC_ID_VP6,
  193. AV_CODEC_ID_VP6F,
  194. AV_CODEC_ID_TARGA,
  195. AV_CODEC_ID_DSICINVIDEO,
  196. AV_CODEC_ID_TIERTEXSEQVIDEO,
  197. AV_CODEC_ID_TIFF,
  198. AV_CODEC_ID_GIF,
  199. AV_CODEC_ID_DXA,
  200. AV_CODEC_ID_DNXHD,
  201. AV_CODEC_ID_THP,
  202. AV_CODEC_ID_SGI,
  203. AV_CODEC_ID_C93,
  204. AV_CODEC_ID_BETHSOFTVID,
  205. AV_CODEC_ID_PTX,
  206. AV_CODEC_ID_TXD,
  207. AV_CODEC_ID_VP6A,
  208. AV_CODEC_ID_AMV,
  209. AV_CODEC_ID_VB,
  210. AV_CODEC_ID_PCX,
  211. AV_CODEC_ID_SUNRAST,
  212. AV_CODEC_ID_INDEO4,
  213. AV_CODEC_ID_INDEO5,
  214. AV_CODEC_ID_MIMIC,
  215. AV_CODEC_ID_RL2,
  216. AV_CODEC_ID_ESCAPE124,
  217. AV_CODEC_ID_DIRAC,
  218. AV_CODEC_ID_BFI,
  219. AV_CODEC_ID_CMV,
  220. AV_CODEC_ID_MOTIONPIXELS,
  221. AV_CODEC_ID_TGV,
  222. AV_CODEC_ID_TGQ,
  223. AV_CODEC_ID_TQI,
  224. AV_CODEC_ID_AURA,
  225. AV_CODEC_ID_AURA2,
  226. AV_CODEC_ID_V210X,
  227. AV_CODEC_ID_TMV,
  228. AV_CODEC_ID_V210,
  229. AV_CODEC_ID_DPX,
  230. AV_CODEC_ID_MAD,
  231. AV_CODEC_ID_FRWU,
  232. AV_CODEC_ID_FLASHSV2,
  233. AV_CODEC_ID_CDGRAPHICS,
  234. AV_CODEC_ID_R210,
  235. AV_CODEC_ID_ANM,
  236. AV_CODEC_ID_BINKVIDEO,
  237. AV_CODEC_ID_IFF_ILBM,
  238. AV_CODEC_ID_IFF_BYTERUN1,
  239. AV_CODEC_ID_KGV1,
  240. AV_CODEC_ID_YOP,
  241. AV_CODEC_ID_VP8,
  242. AV_CODEC_ID_PICTOR,
  243. AV_CODEC_ID_ANSI,
  244. AV_CODEC_ID_A64_MULTI,
  245. AV_CODEC_ID_A64_MULTI5,
  246. AV_CODEC_ID_R10K,
  247. AV_CODEC_ID_MXPEG,
  248. AV_CODEC_ID_LAGARITH,
  249. AV_CODEC_ID_PRORES,
  250. AV_CODEC_ID_JV,
  251. AV_CODEC_ID_DFA,
  252. AV_CODEC_ID_WMV3IMAGE,
  253. AV_CODEC_ID_VC1IMAGE,
  254. AV_CODEC_ID_UTVIDEO,
  255. AV_CODEC_ID_BMV_VIDEO,
  256. AV_CODEC_ID_VBLE,
  257. AV_CODEC_ID_DXTORY,
  258. AV_CODEC_ID_V410,
  259. AV_CODEC_ID_XWD,
  260. AV_CODEC_ID_CDXL,
  261. AV_CODEC_ID_XBM,
  262. AV_CODEC_ID_ZEROCODEC,
  263. AV_CODEC_ID_MSS1,
  264. AV_CODEC_ID_MSA1,
  265. AV_CODEC_ID_TSCC2,
  266. AV_CODEC_ID_MTS2,
  267. AV_CODEC_ID_CLLC,
  268. AV_CODEC_ID_MSS2,
  269. AV_CODEC_ID_VP9,
  270. AV_CODEC_ID_AIC,
  271. AV_CODEC_ID_ESCAPE130,
  272. AV_CODEC_ID_G2M,
  273. AV_CODEC_ID_WEBP,
  274. AV_CODEC_ID_HNM4_VIDEO,
  275. AV_CODEC_ID_HEVC,
  276. AV_CODEC_ID_FIC,
  277. AV_CODEC_ID_ALIAS_PIX,
  278. AV_CODEC_ID_BRENDER_PIX,
  279. AV_CODEC_ID_PAF_VIDEO,
  280. AV_CODEC_ID_EXR,
  281. AV_CODEC_ID_VP7,
  282. AV_CODEC_ID_SANM,
  283. AV_CODEC_ID_SGIRLE,
  284. AV_CODEC_ID_MVC1,
  285. AV_CODEC_ID_MVC2,
  286. AV_CODEC_ID_HQX,
  287. /* various PCM "codecs" */
  288. AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs
  289. AV_CODEC_ID_PCM_S16LE = 0x10000,
  290. AV_CODEC_ID_PCM_S16BE,
  291. AV_CODEC_ID_PCM_U16LE,
  292. AV_CODEC_ID_PCM_U16BE,
  293. AV_CODEC_ID_PCM_S8,
  294. AV_CODEC_ID_PCM_U8,
  295. AV_CODEC_ID_PCM_MULAW,
  296. AV_CODEC_ID_PCM_ALAW,
  297. AV_CODEC_ID_PCM_S32LE,
  298. AV_CODEC_ID_PCM_S32BE,
  299. AV_CODEC_ID_PCM_U32LE,
  300. AV_CODEC_ID_PCM_U32BE,
  301. AV_CODEC_ID_PCM_S24LE,
  302. AV_CODEC_ID_PCM_S24BE,
  303. AV_CODEC_ID_PCM_U24LE,
  304. AV_CODEC_ID_PCM_U24BE,
  305. AV_CODEC_ID_PCM_S24DAUD,
  306. AV_CODEC_ID_PCM_ZORK,
  307. AV_CODEC_ID_PCM_S16LE_PLANAR,
  308. AV_CODEC_ID_PCM_DVD,
  309. AV_CODEC_ID_PCM_F32BE,
  310. AV_CODEC_ID_PCM_F32LE,
  311. AV_CODEC_ID_PCM_F64BE,
  312. AV_CODEC_ID_PCM_F64LE,
  313. AV_CODEC_ID_PCM_BLURAY,
  314. AV_CODEC_ID_PCM_LXF,
  315. AV_CODEC_ID_S302M,
  316. AV_CODEC_ID_PCM_S8_PLANAR,
  317. AV_CODEC_ID_PCM_S24LE_PLANAR,
  318. AV_CODEC_ID_PCM_S32LE_PLANAR,
  319. /* various ADPCM codecs */
  320. AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
  321. AV_CODEC_ID_ADPCM_IMA_WAV,
  322. AV_CODEC_ID_ADPCM_IMA_DK3,
  323. AV_CODEC_ID_ADPCM_IMA_DK4,
  324. AV_CODEC_ID_ADPCM_IMA_WS,
  325. AV_CODEC_ID_ADPCM_IMA_SMJPEG,
  326. AV_CODEC_ID_ADPCM_MS,
  327. AV_CODEC_ID_ADPCM_4XM,
  328. AV_CODEC_ID_ADPCM_XA,
  329. AV_CODEC_ID_ADPCM_ADX,
  330. AV_CODEC_ID_ADPCM_EA,
  331. AV_CODEC_ID_ADPCM_G726,
  332. AV_CODEC_ID_ADPCM_CT,
  333. AV_CODEC_ID_ADPCM_SWF,
  334. AV_CODEC_ID_ADPCM_YAMAHA,
  335. AV_CODEC_ID_ADPCM_SBPRO_4,
  336. AV_CODEC_ID_ADPCM_SBPRO_3,
  337. AV_CODEC_ID_ADPCM_SBPRO_2,
  338. AV_CODEC_ID_ADPCM_THP,
  339. AV_CODEC_ID_ADPCM_IMA_AMV,
  340. AV_CODEC_ID_ADPCM_EA_R1,
  341. AV_CODEC_ID_ADPCM_EA_R3,
  342. AV_CODEC_ID_ADPCM_EA_R2,
  343. AV_CODEC_ID_ADPCM_IMA_EA_SEAD,
  344. AV_CODEC_ID_ADPCM_IMA_EA_EACS,
  345. AV_CODEC_ID_ADPCM_EA_XAS,
  346. AV_CODEC_ID_ADPCM_EA_MAXIS_XA,
  347. AV_CODEC_ID_ADPCM_IMA_ISS,
  348. AV_CODEC_ID_ADPCM_G722,
  349. AV_CODEC_ID_ADPCM_IMA_APC,
  350. AV_CODEC_ID_ADPCM_VIMA,
  351. /* AMR */
  352. AV_CODEC_ID_AMR_NB = 0x12000,
  353. AV_CODEC_ID_AMR_WB,
  354. /* RealAudio codecs*/
  355. AV_CODEC_ID_RA_144 = 0x13000,
  356. AV_CODEC_ID_RA_288,
  357. /* various DPCM codecs */
  358. AV_CODEC_ID_ROQ_DPCM = 0x14000,
  359. AV_CODEC_ID_INTERPLAY_DPCM,
  360. AV_CODEC_ID_XAN_DPCM,
  361. AV_CODEC_ID_SOL_DPCM,
  362. /* audio codecs */
  363. AV_CODEC_ID_MP2 = 0x15000,
  364. AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
  365. AV_CODEC_ID_AAC,
  366. AV_CODEC_ID_AC3,
  367. AV_CODEC_ID_DTS,
  368. AV_CODEC_ID_VORBIS,
  369. AV_CODEC_ID_DVAUDIO,
  370. AV_CODEC_ID_WMAV1,
  371. AV_CODEC_ID_WMAV2,
  372. AV_CODEC_ID_MACE3,
  373. AV_CODEC_ID_MACE6,
  374. AV_CODEC_ID_VMDAUDIO,
  375. AV_CODEC_ID_FLAC,
  376. AV_CODEC_ID_MP3ADU,
  377. AV_CODEC_ID_MP3ON4,
  378. AV_CODEC_ID_SHORTEN,
  379. AV_CODEC_ID_ALAC,
  380. AV_CODEC_ID_WESTWOOD_SND1,
  381. AV_CODEC_ID_GSM, ///< as in Berlin toast format
  382. AV_CODEC_ID_QDM2,
  383. AV_CODEC_ID_COOK,
  384. AV_CODEC_ID_TRUESPEECH,
  385. AV_CODEC_ID_TTA,
  386. AV_CODEC_ID_SMACKAUDIO,
  387. AV_CODEC_ID_QCELP,
  388. AV_CODEC_ID_WAVPACK,
  389. AV_CODEC_ID_DSICINAUDIO,
  390. AV_CODEC_ID_IMC,
  391. AV_CODEC_ID_MUSEPACK7,
  392. AV_CODEC_ID_MLP,
  393. AV_CODEC_ID_GSM_MS, /* as found in WAV */
  394. AV_CODEC_ID_ATRAC3,
  395. #if FF_API_VOXWARE
  396. AV_CODEC_ID_VOXWARE,
  397. #endif
  398. AV_CODEC_ID_APE,
  399. AV_CODEC_ID_NELLYMOSER,
  400. AV_CODEC_ID_MUSEPACK8,
  401. AV_CODEC_ID_SPEEX,
  402. AV_CODEC_ID_WMAVOICE,
  403. AV_CODEC_ID_WMAPRO,
  404. AV_CODEC_ID_WMALOSSLESS,
  405. AV_CODEC_ID_ATRAC3P,
  406. AV_CODEC_ID_EAC3,
  407. AV_CODEC_ID_SIPR,
  408. AV_CODEC_ID_MP1,
  409. AV_CODEC_ID_TWINVQ,
  410. AV_CODEC_ID_TRUEHD,
  411. AV_CODEC_ID_MP4ALS,
  412. AV_CODEC_ID_ATRAC1,
  413. AV_CODEC_ID_BINKAUDIO_RDFT,
  414. AV_CODEC_ID_BINKAUDIO_DCT,
  415. AV_CODEC_ID_AAC_LATM,
  416. AV_CODEC_ID_QDMC,
  417. AV_CODEC_ID_CELT,
  418. AV_CODEC_ID_G723_1,
  419. AV_CODEC_ID_G729,
  420. AV_CODEC_ID_8SVX_EXP,
  421. AV_CODEC_ID_8SVX_FIB,
  422. AV_CODEC_ID_BMV_AUDIO,
  423. AV_CODEC_ID_RALF,
  424. AV_CODEC_ID_IAC,
  425. AV_CODEC_ID_ILBC,
  426. AV_CODEC_ID_OPUS,
  427. AV_CODEC_ID_COMFORT_NOISE,
  428. AV_CODEC_ID_TAK,
  429. AV_CODEC_ID_METASOUND,
  430. AV_CODEC_ID_PAF_AUDIO,
  431. AV_CODEC_ID_ON2AVC,
  432. AV_CODEC_ID_DSS_SP,
  433. /* subtitle codecs */
  434. AV_CODEC_ID_FIRST_SUBTITLE = 0x17000, ///< A dummy ID pointing at the start of subtitle codecs.
  435. AV_CODEC_ID_DVD_SUBTITLE = 0x17000,
  436. AV_CODEC_ID_DVB_SUBTITLE,
  437. AV_CODEC_ID_TEXT, ///< raw UTF-8 text
  438. AV_CODEC_ID_XSUB,
  439. AV_CODEC_ID_SSA,
  440. AV_CODEC_ID_MOV_TEXT,
  441. AV_CODEC_ID_HDMV_PGS_SUBTITLE,
  442. AV_CODEC_ID_DVB_TELETEXT,
  443. AV_CODEC_ID_SRT,
  444. /* other specific kind of codecs (generally used for attachments) */
  445. AV_CODEC_ID_FIRST_UNKNOWN = 0x18000, ///< A dummy ID pointing at the start of various fake codecs.
  446. AV_CODEC_ID_TTF = 0x18000,
  447. AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
  448. AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS
  449. * stream (only used by libavformat) */
  450. AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems
  451. * stream (only used by libavformat) */
  452. AV_CODEC_ID_FFMETADATA = 0x21000, ///< Dummy codec for streams containing only metadata information.
  453. };
  454. /**
  455. * This struct describes the properties of a single codec described by an
  456. * AVCodecID.
  457. * @see avcodec_descriptor_get()
  458. */
  459. typedef struct AVCodecDescriptor {
  460. enum AVCodecID id;
  461. enum AVMediaType type;
  462. /**
  463. * Name of the codec described by this descriptor. It is non-empty and
  464. * unique for each codec descriptor. It should contain alphanumeric
  465. * characters and '_' only.
  466. */
  467. const char *name;
  468. /**
  469. * A more descriptive name for this codec. May be NULL.
  470. */
  471. const char *long_name;
  472. /**
  473. * Codec properties, a combination of AV_CODEC_PROP_* flags.
  474. */
  475. int props;
  476. } AVCodecDescriptor;
  477. /**
  478. * Codec uses only intra compression.
  479. * Video codecs only.
  480. */
  481. #define AV_CODEC_PROP_INTRA_ONLY (1 << 0)
  482. /**
  483. * Codec supports lossy compression. Audio and video codecs only.
  484. * @note a codec may support both lossy and lossless
  485. * compression modes
  486. */
  487. #define AV_CODEC_PROP_LOSSY (1 << 1)
  488. /**
  489. * Codec supports lossless compression. Audio and video codecs only.
  490. */
  491. #define AV_CODEC_PROP_LOSSLESS (1 << 2)
  492. /**
  493. * Codec supports frame reordering. That is, the coded order (the order in which
  494. * the encoded packets are output by the encoders / stored / input to the
  495. * decoders) may be different from the presentation order of the corresponding
  496. * frames.
  497. *
  498. * For codecs that do not have this property set, PTS and DTS should always be
  499. * equal.
  500. */
  501. #define AV_CODEC_PROP_REORDER (1 << 3)
  502. /**
  503. * @ingroup lavc_decoding
  504. * Required number of additionally allocated bytes at the end of the input bitstream for decoding.
  505. * This is mainly needed because some optimized bitstream readers read
  506. * 32 or 64 bit at once and could read over the end.<br>
  507. * Note: If the first 23 bits of the additional bytes are not 0, then damaged
  508. * MPEG bitstreams could cause overread and segfault.
  509. */
  510. #define FF_INPUT_BUFFER_PADDING_SIZE 8
  511. /**
  512. * @ingroup lavc_encoding
  513. * minimum encoding buffer size
  514. * Used to avoid some checks during header writing.
  515. */
  516. #define FF_MIN_BUFFER_SIZE 16384
  517. /**
  518. * @ingroup lavc_encoding
  519. * motion estimation type.
  520. */
  521. enum Motion_Est_ID {
  522. ME_ZERO = 1, ///< no search, that is use 0,0 vector whenever one is needed
  523. ME_FULL,
  524. ME_LOG,
  525. ME_PHODS,
  526. ME_EPZS, ///< enhanced predictive zonal search
  527. ME_X1, ///< reserved for experiments
  528. ME_HEX, ///< hexagon based search
  529. ME_UMH, ///< uneven multi-hexagon search
  530. ME_TESA, ///< transformed exhaustive search algorithm
  531. };
  532. /**
  533. * @ingroup lavc_decoding
  534. */
  535. enum AVDiscard{
  536. /* We leave some space between them for extensions (drop some
  537. * keyframes for intra-only or drop just some bidir frames). */
  538. AVDISCARD_NONE =-16, ///< discard nothing
  539. AVDISCARD_DEFAULT = 0, ///< discard useless packets like 0 size packets in avi
  540. AVDISCARD_NONREF = 8, ///< discard all non reference
  541. AVDISCARD_BIDIR = 16, ///< discard all bidirectional frames
  542. AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes
  543. AVDISCARD_ALL = 48, ///< discard all
  544. };
  545. enum AVAudioServiceType {
  546. AV_AUDIO_SERVICE_TYPE_MAIN = 0,
  547. AV_AUDIO_SERVICE_TYPE_EFFECTS = 1,
  548. AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED = 2,
  549. AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED = 3,
  550. AV_AUDIO_SERVICE_TYPE_DIALOGUE = 4,
  551. AV_AUDIO_SERVICE_TYPE_COMMENTARY = 5,
  552. AV_AUDIO_SERVICE_TYPE_EMERGENCY = 6,
  553. AV_AUDIO_SERVICE_TYPE_VOICE_OVER = 7,
  554. AV_AUDIO_SERVICE_TYPE_KARAOKE = 8,
  555. AV_AUDIO_SERVICE_TYPE_NB , ///< Not part of ABI
  556. };
  557. /**
  558. * @ingroup lavc_encoding
  559. */
  560. typedef struct RcOverride{
  561. int start_frame;
  562. int end_frame;
  563. int qscale; // If this is 0 then quality_factor will be used instead.
  564. float quality_factor;
  565. } RcOverride;
  566. #if FF_API_MAX_BFRAMES
  567. /**
  568. * @deprecated there is no libavcodec-wide limit on the number of B-frames
  569. */
  570. #define FF_MAX_B_FRAMES 16
  571. #endif
  572. /* encoding support
  573. These flags can be passed in AVCodecContext.flags before initialization.
  574. Note: Not everything is supported yet.
  575. */
  576. /**
  577. * Allow decoders to produce frames with data planes that are not aligned
  578. * to CPU requirements (e.g. due to cropping).
  579. */
  580. #define CODEC_FLAG_UNALIGNED 0x0001
  581. #define CODEC_FLAG_QSCALE 0x0002 ///< Use fixed qscale.
  582. #define CODEC_FLAG_4MV 0x0004 ///< 4 MV per MB allowed / advanced prediction for H.263.
  583. #define CODEC_FLAG_OUTPUT_CORRUPT 0x0008 ///< Output even those frames that might be corrupted
  584. #define CODEC_FLAG_QPEL 0x0010 ///< Use qpel MC.
  585. #if FF_API_GMC
  586. /**
  587. * @deprecated use the "gmc" private option of the libxvid encoder
  588. */
  589. #define CODEC_FLAG_GMC 0x0020 ///< Use GMC.
  590. #endif
  591. #if FF_API_MV0
  592. /**
  593. * @deprecated use the flag "mv0" in the "mpv_flags" private option of the
  594. * mpegvideo encoders
  595. */
  596. #define CODEC_FLAG_MV0 0x0040
  597. #endif
  598. #if FF_API_INPUT_PRESERVED
  599. /**
  600. * @deprecated passing reference-counted frames to the encoders replaces this
  601. * flag
  602. */
  603. #define CODEC_FLAG_INPUT_PRESERVED 0x0100
  604. #endif
  605. #define CODEC_FLAG_PASS1 0x0200 ///< Use internal 2pass ratecontrol in first pass mode.
  606. #define CODEC_FLAG_PASS2 0x0400 ///< Use internal 2pass ratecontrol in second pass mode.
  607. #define CODEC_FLAG_GRAY 0x2000 ///< Only decode/encode grayscale.
  608. #if FF_API_EMU_EDGE
  609. /**
  610. * @deprecated edges are not used/required anymore. I.e. this flag is now always
  611. * set.
  612. */
  613. #define CODEC_FLAG_EMU_EDGE 0x4000
  614. #endif
  615. #define CODEC_FLAG_PSNR 0x8000 ///< error[?] variables will be set during encoding.
  616. #define CODEC_FLAG_TRUNCATED 0x00010000 /** Input bitstream might be truncated at a random
  617. location instead of only at frame boundaries. */
  618. #if FF_API_NORMALIZE_AQP
  619. /**
  620. * @deprecated use the flag "naq" in the "mpv_flags" private option of the
  621. * mpegvideo encoders
  622. */
  623. #define CODEC_FLAG_NORMALIZE_AQP 0x00020000
  624. #endif
  625. #define CODEC_FLAG_INTERLACED_DCT 0x00040000 ///< Use interlaced DCT.
  626. #define CODEC_FLAG_LOW_DELAY 0x00080000 ///< Force low delay.
  627. #define CODEC_FLAG_GLOBAL_HEADER 0x00400000 ///< Place global headers in extradata instead of every keyframe.
  628. #define CODEC_FLAG_BITEXACT 0x00800000 ///< Use only bitexact stuff (except (I)DCT).
  629. /* Fx : Flag for h263+ extra options */
  630. #define CODEC_FLAG_AC_PRED 0x01000000 ///< H.263 advanced intra coding / MPEG-4 AC prediction
  631. #define CODEC_FLAG_LOOP_FILTER 0x00000800 ///< loop filter
  632. #define CODEC_FLAG_INTERLACED_ME 0x20000000 ///< interlaced motion estimation
  633. #define CODEC_FLAG_CLOSED_GOP 0x80000000
  634. #define CODEC_FLAG2_FAST 0x00000001 ///< Allow non spec compliant speedup tricks.
  635. #define CODEC_FLAG2_NO_OUTPUT 0x00000004 ///< Skip bitstream encoding.
  636. #define CODEC_FLAG2_LOCAL_HEADER 0x00000008 ///< Place global headers at every keyframe instead of in extradata.
  637. #define CODEC_FLAG2_IGNORE_CROP 0x00010000 ///< Discard cropping information from SPS.
  638. #define CODEC_FLAG2_CHUNKS 0x00008000 ///< Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
  639. /* Unsupported options :
  640. * Syntax Arithmetic coding (SAC)
  641. * Reference Picture Selection
  642. * Independent Segment Decoding */
  643. /* /Fx */
  644. /* codec capabilities */
  645. #define CODEC_CAP_DRAW_HORIZ_BAND 0x0001 ///< Decoder can use draw_horiz_band callback.
  646. /**
  647. * Codec uses get_buffer() for allocating buffers and supports custom allocators.
  648. * If not set, it might not use get_buffer() at all or use operations that
  649. * assume the buffer was allocated by avcodec_default_get_buffer.
  650. */
  651. #define CODEC_CAP_DR1 0x0002
  652. #define CODEC_CAP_TRUNCATED 0x0008
  653. #if FF_API_XVMC
  654. /* Codec can export data for HW decoding (XvMC). */
  655. #define CODEC_CAP_HWACCEL 0x0010
  656. #endif /* FF_API_XVMC */
  657. /**
  658. * Encoder or decoder requires flushing with NULL input at the end in order to
  659. * give the complete and correct output.
  660. *
  661. * NOTE: If this flag is not set, the codec is guaranteed to never be fed with
  662. * with NULL data. The user can still send NULL data to the public encode
  663. * or decode function, but libavcodec will not pass it along to the codec
  664. * unless this flag is set.
  665. *
  666. * Decoders:
  667. * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL,
  668. * avpkt->size=0 at the end to get the delayed data until the decoder no longer
  669. * returns frames.
  670. *
  671. * Encoders:
  672. * The encoder needs to be fed with NULL data at the end of encoding until the
  673. * encoder no longer returns data.
  674. *
  675. * NOTE: For encoders implementing the AVCodec.encode2() function, setting this
  676. * flag also means that the encoder must set the pts and duration for
  677. * each output packet. If this flag is not set, the pts and duration will
  678. * be determined by libavcodec from the input frame.
  679. */
  680. #define CODEC_CAP_DELAY 0x0020
  681. /**
  682. * Codec can be fed a final frame with a smaller size.
  683. * This can be used to prevent truncation of the last audio samples.
  684. */
  685. #define CODEC_CAP_SMALL_LAST_FRAME 0x0040
  686. #if FF_API_CAP_VDPAU
  687. /**
  688. * Codec can export data for HW decoding (VDPAU).
  689. */
  690. #define CODEC_CAP_HWACCEL_VDPAU 0x0080
  691. #endif
  692. /**
  693. * Codec can output multiple frames per AVPacket
  694. * Normally demuxers return one frame at a time, demuxers which do not do
  695. * are connected to a parser to split what they return into proper frames.
  696. * This flag is reserved to the very rare category of codecs which have a
  697. * bitstream that cannot be split into frames without timeconsuming
  698. * operations like full decoding. Demuxers carring such bitstreams thus
  699. * may return multiple frames in a packet. This has many disadvantages like
  700. * prohibiting stream copy in many cases thus it should only be considered
  701. * as a last resort.
  702. */
  703. #define CODEC_CAP_SUBFRAMES 0x0100
  704. /**
  705. * Codec is experimental and is thus avoided in favor of non experimental
  706. * encoders
  707. */
  708. #define CODEC_CAP_EXPERIMENTAL 0x0200
  709. /**
  710. * Codec should fill in channel configuration and samplerate instead of container
  711. */
  712. #define CODEC_CAP_CHANNEL_CONF 0x0400
  713. #if FF_API_NEG_LINESIZES
  714. /**
  715. * @deprecated no codecs use this capability
  716. */
  717. #define CODEC_CAP_NEG_LINESIZES 0x0800
  718. #endif
  719. /**
  720. * Codec supports frame-level multithreading.
  721. */
  722. #define CODEC_CAP_FRAME_THREADS 0x1000
  723. /**
  724. * Codec supports slice-based (or partition-based) multithreading.
  725. */
  726. #define CODEC_CAP_SLICE_THREADS 0x2000
  727. /**
  728. * Codec supports changed parameters at any point.
  729. */
  730. #define CODEC_CAP_PARAM_CHANGE 0x4000
  731. /**
  732. * Codec supports avctx->thread_count == 0 (auto).
  733. */
  734. #define CODEC_CAP_AUTO_THREADS 0x8000
  735. /**
  736. * Audio encoder supports receiving a different number of samples in each call.
  737. */
  738. #define CODEC_CAP_VARIABLE_FRAME_SIZE 0x10000
  739. #if FF_API_MB_TYPE
  740. //The following defines may change, don't expect compatibility if you use them.
  741. #define MB_TYPE_INTRA4x4 0x0001
  742. #define MB_TYPE_INTRA16x16 0x0002 //FIXME H.264-specific
  743. #define MB_TYPE_INTRA_PCM 0x0004 //FIXME H.264-specific
  744. #define MB_TYPE_16x16 0x0008
  745. #define MB_TYPE_16x8 0x0010
  746. #define MB_TYPE_8x16 0x0020
  747. #define MB_TYPE_8x8 0x0040
  748. #define MB_TYPE_INTERLACED 0x0080
  749. #define MB_TYPE_DIRECT2 0x0100 //FIXME
  750. #define MB_TYPE_ACPRED 0x0200
  751. #define MB_TYPE_GMC 0x0400
  752. #define MB_TYPE_SKIP 0x0800
  753. #define MB_TYPE_P0L0 0x1000
  754. #define MB_TYPE_P1L0 0x2000
  755. #define MB_TYPE_P0L1 0x4000
  756. #define MB_TYPE_P1L1 0x8000
  757. #define MB_TYPE_L0 (MB_TYPE_P0L0 | MB_TYPE_P1L0)
  758. #define MB_TYPE_L1 (MB_TYPE_P0L1 | MB_TYPE_P1L1)
  759. #define MB_TYPE_L0L1 (MB_TYPE_L0 | MB_TYPE_L1)
  760. #define MB_TYPE_QUANT 0x00010000
  761. #define MB_TYPE_CBP 0x00020000
  762. //Note bits 24-31 are reserved for codec specific use (h264 ref0, mpeg1 0mv, ...)
  763. #endif
  764. /**
  765. * Pan Scan area.
  766. * This specifies the area which should be displayed.
  767. * Note there may be multiple such areas for one frame.
  768. */
  769. typedef struct AVPanScan{
  770. /**
  771. * id
  772. * - encoding: Set by user.
  773. * - decoding: Set by libavcodec.
  774. */
  775. int id;
  776. /**
  777. * width and height in 1/16 pel
  778. * - encoding: Set by user.
  779. * - decoding: Set by libavcodec.
  780. */
  781. int width;
  782. int height;
  783. /**
  784. * position of the top left corner in 1/16 pel for up to 3 fields/frames
  785. * - encoding: Set by user.
  786. * - decoding: Set by libavcodec.
  787. */
  788. int16_t position[3][2];
  789. }AVPanScan;
  790. #if FF_API_QSCALE_TYPE
  791. #define FF_QSCALE_TYPE_MPEG1 0
  792. #define FF_QSCALE_TYPE_MPEG2 1
  793. #define FF_QSCALE_TYPE_H264 2
  794. #define FF_QSCALE_TYPE_VP56 3
  795. #endif
  796. #if FF_API_GET_BUFFER
  797. #define FF_BUFFER_TYPE_INTERNAL 1
  798. #define FF_BUFFER_TYPE_USER 2 ///< direct rendering buffers (image is (de)allocated by user)
  799. #define FF_BUFFER_TYPE_SHARED 4 ///< Buffer from somewhere else; don't deallocate image (data/base), all other tables are not shared.
  800. #define FF_BUFFER_TYPE_COPY 8 ///< Just a (modified) copy of some other buffer, don't deallocate anything.
  801. #define FF_BUFFER_HINTS_VALID 0x01 // Buffer hints value is meaningful (if 0 ignore).
  802. #define FF_BUFFER_HINTS_READABLE 0x02 // Codec will read from buffer.
  803. #define FF_BUFFER_HINTS_PRESERVE 0x04 // User must not alter buffer content.
  804. #define FF_BUFFER_HINTS_REUSABLE 0x08 // Codec will reuse the buffer (update).
  805. #endif
  806. /**
  807. * The decoder will keep a reference to the frame and may reuse it later.
  808. */
  809. #define AV_GET_BUFFER_FLAG_REF (1 << 0)
  810. /**
  811. * @defgroup lavc_packet AVPacket
  812. *
  813. * Types and functions for working with AVPacket.
  814. * @{
  815. */
  816. enum AVPacketSideDataType {
  817. AV_PKT_DATA_PALETTE,
  818. AV_PKT_DATA_NEW_EXTRADATA,
  819. /**
  820. * An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
  821. * @code
  822. * u32le param_flags
  823. * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT)
  824. * s32le channel_count
  825. * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)
  826. * u64le channel_layout
  827. * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)
  828. * s32le sample_rate
  829. * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)
  830. * s32le width
  831. * s32le height
  832. * @endcode
  833. */
  834. AV_PKT_DATA_PARAM_CHANGE,
  835. /**
  836. * An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of
  837. * structures with info about macroblocks relevant to splitting the
  838. * packet into smaller packets on macroblock edges (e.g. as for RFC 2190).
  839. * That is, it does not necessarily contain info about all macroblocks,
  840. * as long as the distance between macroblocks in the info is smaller
  841. * than the target payload size.
  842. * Each MB info structure is 12 bytes, and is laid out as follows:
  843. * @code
  844. * u32le bit offset from the start of the packet
  845. * u8 current quantizer at the start of the macroblock
  846. * u8 GOB number
  847. * u16le macroblock address within the GOB
  848. * u8 horizontal MV predictor
  849. * u8 vertical MV predictor
  850. * u8 horizontal MV predictor for block number 3
  851. * u8 vertical MV predictor for block number 3
  852. * @endcode
  853. */
  854. AV_PKT_DATA_H263_MB_INFO,
  855. /**
  856. * This side data should be associated with an audio stream and contains
  857. * ReplayGain information in form of the AVReplayGain struct.
  858. */
  859. AV_PKT_DATA_REPLAYGAIN,
  860. /**
  861. * This side data contains a 3x3 transformation matrix describing an affine
  862. * transformation that needs to be applied to the decoded video frames for
  863. * correct presentation.
  864. *
  865. * See libavutil/display.h for a detailed description of the data.
  866. */
  867. AV_PKT_DATA_DISPLAYMATRIX,
  868. /**
  869. * This side data should be associated with a video stream and contains
  870. * Stereoscopic 3D information in form of the AVStereo3D struct.
  871. */
  872. AV_PKT_DATA_STEREO3D,
  873. /**
  874. * This side data should be associated with an audio stream and corresponds
  875. * to enum AVAudioServiceType.
  876. */
  877. AV_PKT_DATA_AUDIO_SERVICE_TYPE,
  878. };
  879. typedef struct AVPacketSideData {
  880. uint8_t *data;
  881. int size;
  882. enum AVPacketSideDataType type;
  883. } AVPacketSideData;
  884. /**
  885. * This structure stores compressed data. It is typically exported by demuxers
  886. * and then passed as input to decoders, or received as output from encoders and
  887. * then passed to muxers.
  888. *
  889. * For video, it should typically contain one compressed frame. For audio it may
  890. * contain several compressed frames.
  891. *
  892. * AVPacket is one of the few structs in Libav, whose size is a part of public
  893. * ABI. Thus it may be allocated on stack and no new fields can be added to it
  894. * without libavcodec and libavformat major bump.
  895. *
  896. * The semantics of data ownership depends on the buf or destruct (deprecated)
  897. * fields. If either is set, the packet data is dynamically allocated and is
  898. * valid indefinitely until av_free_packet() is called (which in turn calls
  899. * av_buffer_unref()/the destruct callback to free the data). If neither is set,
  900. * the packet data is typically backed by some static buffer somewhere and is
  901. * only valid for a limited time (e.g. until the next read call when demuxing).
  902. *
  903. * The side data is always allocated with av_malloc() and is freed in
  904. * av_free_packet().
  905. */
  906. typedef struct AVPacket {
  907. /**
  908. * A reference to the reference-counted buffer where the packet data is
  909. * stored.
  910. * May be NULL, then the packet data is not reference-counted.
  911. */
  912. AVBufferRef *buf;
  913. /**
  914. * Presentation timestamp in AVStream->time_base units; the time at which
  915. * the decompressed packet will be presented to the user.
  916. * Can be AV_NOPTS_VALUE if it is not stored in the file.
  917. * pts MUST be larger or equal to dts as presentation cannot happen before
  918. * decompression, unless one wants to view hex dumps. Some formats misuse
  919. * the terms dts and pts/cts to mean something different. Such timestamps
  920. * must be converted to true pts/dts before they are stored in AVPacket.
  921. */
  922. int64_t pts;
  923. /**
  924. * Decompression timestamp in AVStream->time_base units; the time at which
  925. * the packet is decompressed.
  926. * Can be AV_NOPTS_VALUE if it is not stored in the file.
  927. */
  928. int64_t dts;
  929. uint8_t *data;
  930. int size;
  931. int stream_index;
  932. /**
  933. * A combination of AV_PKT_FLAG values
  934. */
  935. int flags;
  936. /**
  937. * Additional packet data that can be provided by the container.
  938. * Packet can contain several types of side information.
  939. */
  940. AVPacketSideData *side_data;
  941. int side_data_elems;
  942. /**
  943. * Duration of this packet in AVStream->time_base units, 0 if unknown.
  944. * Equals next_pts - this_pts in presentation order.
  945. */
  946. int duration;
  947. #if FF_API_DESTRUCT_PACKET
  948. attribute_deprecated
  949. void (*destruct)(struct AVPacket *);
  950. attribute_deprecated
  951. void *priv;
  952. #endif
  953. int64_t pos; ///< byte position in stream, -1 if unknown
  954. /**
  955. * Time difference in AVStream->time_base units from the pts of this
  956. * packet to the point at which the output from the decoder has converged
  957. * independent from the availability of previous frames. That is, the
  958. * frames are virtually identical no matter if decoding started from
  959. * the very first frame or from this keyframe.
  960. * Is AV_NOPTS_VALUE if unknown.
  961. * This field is not the display duration of the current packet.
  962. * This field has no meaning if the packet does not have AV_PKT_FLAG_KEY
  963. * set.
  964. *
  965. * The purpose of this field is to allow seeking in streams that have no
  966. * keyframes in the conventional sense. It corresponds to the
  967. * recovery point SEI in H.264 and match_time_delta in NUT. It is also
  968. * essential for some types of subtitle streams to ensure that all
  969. * subtitles are correctly displayed after seeking.
  970. */
  971. int64_t convergence_duration;
  972. } AVPacket;
  973. #define AV_PKT_FLAG_KEY 0x0001 ///< The packet contains a keyframe
  974. #define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
  975. enum AVSideDataParamChangeFlags {
  976. AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = 0x0001,
  977. AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002,
  978. AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004,
  979. AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008,
  980. };
  981. /**
  982. * @}
  983. */
  984. struct AVCodecInternal;
  985. enum AVFieldOrder {
  986. AV_FIELD_UNKNOWN,
  987. AV_FIELD_PROGRESSIVE,
  988. AV_FIELD_TT, //< Top coded_first, top displayed first
  989. AV_FIELD_BB, //< Bottom coded first, bottom displayed first
  990. AV_FIELD_TB, //< Top coded first, bottom displayed first
  991. AV_FIELD_BT, //< Bottom coded first, top displayed first
  992. };
  993. /**
  994. * main external API structure.
  995. * New fields can be added to the end with minor version bumps.
  996. * Removal, reordering and changes to existing fields require a major
  997. * version bump.
  998. * sizeof(AVCodecContext) must not be used outside libav*.
  999. */
  1000. typedef struct AVCodecContext {
  1001. /**
  1002. * information on struct for av_log
  1003. * - set by avcodec_alloc_context3
  1004. */
  1005. const AVClass *av_class;
  1006. int log_level_offset;
  1007. enum AVMediaType codec_type; /* see AVMEDIA_TYPE_xxx */
  1008. const struct AVCodec *codec;
  1009. #if FF_API_CODEC_NAME
  1010. /**
  1011. * @deprecated this field is not used for anything in libavcodec
  1012. */
  1013. attribute_deprecated
  1014. char codec_name[32];
  1015. #endif
  1016. enum AVCodecID codec_id; /* see AV_CODEC_ID_xxx */
  1017. /**
  1018. * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
  1019. * This is used to work around some encoder bugs.
  1020. * A demuxer should set this to what is stored in the field used to identify the codec.
  1021. * If there are multiple such fields in a container then the demuxer should choose the one
  1022. * which maximizes the information about the used codec.
  1023. * If the codec tag field in a container is larger than 32 bits then the demuxer should
  1024. * remap the longer ID to 32 bits with a table or other structure. Alternatively a new
  1025. * extra_codec_tag + size could be added but for this a clear advantage must be demonstrated
  1026. * first.
  1027. * - encoding: Set by user, if not then the default based on codec_id will be used.
  1028. * - decoding: Set by user, will be converted to uppercase by libavcodec during init.
  1029. */
  1030. unsigned int codec_tag;
  1031. #if FF_API_STREAM_CODEC_TAG
  1032. /**
  1033. * @deprecated this field is unused
  1034. */
  1035. attribute_deprecated
  1036. unsigned int stream_codec_tag;
  1037. #endif
  1038. void *priv_data;
  1039. /**
  1040. * Private context used for internal data.
  1041. *
  1042. * Unlike priv_data, this is not codec-specific. It is used in general
  1043. * libavcodec functions.
  1044. */
  1045. struct AVCodecInternal *internal;
  1046. /**
  1047. * Private data of the user, can be used to carry app specific stuff.
  1048. * - encoding: Set by user.
  1049. * - decoding: Set by user.
  1050. */
  1051. void *opaque;
  1052. /**
  1053. * the average bitrate
  1054. * - encoding: Set by user; unused for constant quantizer encoding.
  1055. * - decoding: Set by libavcodec. 0 or some bitrate if this info is available in the stream.
  1056. */
  1057. int bit_rate;
  1058. /**
  1059. * number of bits the bitstream is allowed to diverge from the reference.
  1060. * the reference can be CBR (for CBR pass1) or VBR (for pass2)
  1061. * - encoding: Set by user; unused for constant quantizer encoding.
  1062. * - decoding: unused
  1063. */
  1064. int bit_rate_tolerance;
  1065. /**
  1066. * Global quality for codecs which cannot change it per frame.
  1067. * This should be proportional to MPEG-1/2/4 qscale.
  1068. * - encoding: Set by user.
  1069. * - decoding: unused
  1070. */
  1071. int global_quality;
  1072. /**
  1073. * - encoding: Set by user.
  1074. * - decoding: unused
  1075. */
  1076. int compression_level;
  1077. #define FF_COMPRESSION_DEFAULT -1
  1078. /**
  1079. * CODEC_FLAG_*.
  1080. * - encoding: Set by user.
  1081. * - decoding: Set by user.
  1082. */
  1083. int flags;
  1084. /**
  1085. * CODEC_FLAG2_*
  1086. * - encoding: Set by user.
  1087. * - decoding: Set by user.
  1088. */
  1089. int flags2;
  1090. /**
  1091. * some codecs need / can use extradata like Huffman tables.
  1092. * mjpeg: Huffman tables
  1093. * rv10: additional flags
  1094. * mpeg4: global headers (they can be in the bitstream or here)
  1095. * The allocated memory should be FF_INPUT_BUFFER_PADDING_SIZE bytes larger
  1096. * than extradata_size to avoid prolems if it is read with the bitstream reader.
  1097. * The bytewise contents of extradata must not depend on the architecture or CPU endianness.
  1098. * - encoding: Set/allocated/freed by libavcodec.
  1099. * - decoding: Set/allocated/freed by user.
  1100. */
  1101. uint8_t *extradata;
  1102. int extradata_size;
  1103. /**
  1104. * This is the fundamental unit of time (in seconds) in terms
  1105. * of which frame timestamps are represented. For fixed-fps content,
  1106. * timebase should be 1/framerate and timestamp increments should be
  1107. * identically 1.
  1108. * - encoding: MUST be set by user.
  1109. * - decoding: the use of this field for decoding is deprecated.
  1110. * Use framerate instead.
  1111. */
  1112. AVRational time_base;
  1113. /**
  1114. * For some codecs, the time base is closer to the field rate than the frame rate.
  1115. * Most notably, H.264 and MPEG-2 specify time_base as half of frame duration
  1116. * if no telecine is used ...
  1117. *
  1118. * Set to time_base ticks per frame. Default 1, e.g., H.264/MPEG-2 set it to 2.
  1119. */
  1120. int ticks_per_frame;
  1121. /**
  1122. * Codec delay.
  1123. *
  1124. * Video:
  1125. * Number of frames the decoded output will be delayed relative to the
  1126. * encoded input.
  1127. *
  1128. * Audio:
  1129. * For encoding, this field is unused (see initial_padding).
  1130. *
  1131. * For decoding, this is the number of samples the decoder needs to
  1132. * output before the decoder's output is valid. When seeking, you should
  1133. * start decoding this many samples prior to your desired seek point.
  1134. *
  1135. * - encoding: Set by libavcodec.
  1136. * - decoding: Set by libavcodec.
  1137. */
  1138. int delay;
  1139. /* video only */
  1140. /**
  1141. * picture width / height.
  1142. * - encoding: MUST be set by user.
  1143. * - decoding: May be set by the user before opening the decoder if known e.g.
  1144. * from the container. Some decoders will require the dimensions
  1145. * to be set by the caller. During decoding, the decoder may
  1146. * overwrite those values as required.
  1147. */
  1148. int width, height;
  1149. /**
  1150. * Bitstream width / height, may be different from width/height e.g. when
  1151. * the decoded frame is cropped before being output.
  1152. * - encoding: unused
  1153. * - decoding: May be set by the user before opening the decoder if known
  1154. * e.g. from the container. During decoding, the decoder may
  1155. * overwrite those values as required.
  1156. */
  1157. int coded_width, coded_height;
  1158. #if FF_API_ASPECT_EXTENDED
  1159. #define FF_ASPECT_EXTENDED 15
  1160. #endif
  1161. /**
  1162. * the number of pictures in a group of pictures, or 0 for intra_only
  1163. * - encoding: Set by user.
  1164. * - decoding: unused
  1165. */
  1166. int gop_size;
  1167. /**
  1168. * Pixel format, see AV_PIX_FMT_xxx.
  1169. * May be set by the demuxer if known from headers.
  1170. * May be overriden by the decoder if it knows better.
  1171. * - encoding: Set by user.
  1172. * - decoding: Set by user if known, overridden by libavcodec if known
  1173. */
  1174. enum AVPixelFormat pix_fmt;
  1175. /**
  1176. * Motion estimation algorithm used for video coding.
  1177. * 1 (zero), 2 (full), 3 (log), 4 (phods), 5 (epzs), 6 (x1), 7 (hex),
  1178. * 8 (umh), 10 (tesa) [7, 8, 10 are x264 specific]
  1179. * - encoding: MUST be set by user.
  1180. * - decoding: unused
  1181. */
  1182. int me_method;
  1183. /**
  1184. * If non NULL, 'draw_horiz_band' is called by the libavcodec
  1185. * decoder to draw a horizontal band. It improves cache usage. Not
  1186. * all codecs can do that. You must check the codec capabilities
  1187. * beforehand.
  1188. * When multithreading is used, it may be called from multiple threads
  1189. * at the same time; threads might draw different parts of the same AVFrame,
  1190. * or multiple AVFrames, and there is no guarantee that slices will be drawn
  1191. * in order.
  1192. * The function is also used by hardware acceleration APIs.
  1193. * It is called at least once during frame decoding to pass
  1194. * the data needed for hardware render.
  1195. * In that mode instead of pixel data, AVFrame points to
  1196. * a structure specific to the acceleration API. The application
  1197. * reads the structure and can change some fields to indicate progress
  1198. * or mark state.
  1199. * - encoding: unused
  1200. * - decoding: Set by user.
  1201. * @param height the height of the slice
  1202. * @param y the y position of the slice
  1203. * @param type 1->top field, 2->bottom field, 3->frame
  1204. * @param offset offset into the AVFrame.data from which the slice should be read
  1205. */
  1206. void (*draw_horiz_band)(struct AVCodecContext *s,
  1207. const AVFrame *src, int offset[AV_NUM_DATA_POINTERS],
  1208. int y, int type, int height);
  1209. /**
  1210. * callback to negotiate the pixelFormat
  1211. * @param fmt is the list of formats which are supported by the codec,
  1212. * it is terminated by -1 as 0 is a valid format, the formats are ordered by quality.
  1213. * The first is always the native one.
  1214. * @note The callback may be called again immediately if initialization for
  1215. * the selected (hardware-accelerated) pixel format failed.
  1216. * @warning Behavior is undefined if the callback returns a value not
  1217. * in the fmt list of formats.
  1218. * @return the chosen format
  1219. * - encoding: unused
  1220. * - decoding: Set by user, if not set the native format will be chosen.
  1221. */
  1222. enum AVPixelFormat (*get_format)(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
  1223. /**
  1224. * maximum number of B-frames between non-B-frames
  1225. * Note: The output will be delayed by max_b_frames+1 relative to the input.
  1226. * - encoding: Set by user.
  1227. * - decoding: unused
  1228. */
  1229. int max_b_frames;
  1230. /**
  1231. * qscale factor between IP and B-frames
  1232. * If > 0 then the last P-frame quantizer will be used (q= lastp_q*factor+offset).
  1233. * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset).
  1234. * - encoding: Set by user.
  1235. * - decoding: unused
  1236. */
  1237. float b_quant_factor;
  1238. /** obsolete FIXME remove */
  1239. int rc_strategy;
  1240. #define FF_RC_STRATEGY_XVID 1
  1241. int b_frame_strategy;
  1242. /**
  1243. * qscale offset between IP and B-frames
  1244. * - encoding: Set by user.
  1245. * - decoding: unused
  1246. */
  1247. float b_quant_offset;
  1248. /**
  1249. * Size of the frame reordering buffer in the decoder.
  1250. * For MPEG-2 it is 1 IPB or 0 low delay IP.
  1251. * - encoding: Set by libavcodec.
  1252. * - decoding: Set by libavcodec.
  1253. */
  1254. int has_b_frames;
  1255. /**
  1256. * 0-> h263 quant 1-> mpeg quant
  1257. * - encoding: Set by user.
  1258. * - decoding: unused
  1259. */
  1260. int mpeg_quant;
  1261. /**
  1262. * qscale factor between P and I-frames
  1263. * If > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset).
  1264. * If < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset).
  1265. * - encoding: Set by user.
  1266. * - decoding: unused
  1267. */
  1268. float i_quant_factor;
  1269. /**
  1270. * qscale offset between P and I-frames
  1271. * - encoding: Set by user.
  1272. * - decoding: unused
  1273. */
  1274. float i_quant_offset;
  1275. /**
  1276. * luminance masking (0-> disabled)
  1277. * - encoding: Set by user.
  1278. * - decoding: unused
  1279. */
  1280. float lumi_masking;
  1281. /**
  1282. * temporary complexity masking (0-> disabled)
  1283. * - encoding: Set by user.
  1284. * - decoding: unused
  1285. */
  1286. float temporal_cplx_masking;
  1287. /**
  1288. * spatial complexity masking (0-> disabled)
  1289. * - encoding: Set by user.
  1290. * - decoding: unused
  1291. */
  1292. float spatial_cplx_masking;
  1293. /**
  1294. * p block masking (0-> disabled)
  1295. * - encoding: Set by user.
  1296. * - decoding: unused
  1297. */
  1298. float p_masking;
  1299. /**
  1300. * darkness masking (0-> disabled)
  1301. * - encoding: Set by user.
  1302. * - decoding: unused
  1303. */
  1304. float dark_masking;
  1305. /**
  1306. * slice count
  1307. * - encoding: Set by libavcodec.
  1308. * - decoding: Set by user (or 0).
  1309. */
  1310. int slice_count;
  1311. /**
  1312. * prediction method (needed for huffyuv)
  1313. * - encoding: Set by user.
  1314. * - decoding: unused
  1315. */
  1316. int prediction_method;
  1317. #define FF_PRED_LEFT 0
  1318. #define FF_PRED_PLANE 1
  1319. #define FF_PRED_MEDIAN 2
  1320. /**
  1321. * slice offsets in the frame in bytes
  1322. * - encoding: Set/allocated by libavcodec.
  1323. * - decoding: Set/allocated by user (or NULL).
  1324. */
  1325. int *slice_offset;
  1326. /**
  1327. * sample aspect ratio (0 if unknown)
  1328. * That is the width of a pixel divided by the height of the pixel.
  1329. * Numerator and denominator must be relatively prime and smaller than 256 for some video standards.
  1330. * - encoding: Set by user.
  1331. * - decoding: Set by libavcodec.
  1332. */
  1333. AVRational sample_aspect_ratio;
  1334. /**
  1335. * motion estimation comparison function
  1336. * - encoding: Set by user.
  1337. * - decoding: unused
  1338. */
  1339. int me_cmp;
  1340. /**
  1341. * subpixel motion estimation comparison function
  1342. * - encoding: Set by user.
  1343. * - decoding: unused
  1344. */
  1345. int me_sub_cmp;
  1346. /**
  1347. * macroblock comparison function (not supported yet)
  1348. * - encoding: Set by user.
  1349. * - decoding: unused
  1350. */
  1351. int mb_cmp;
  1352. /**
  1353. * interlaced DCT comparison function
  1354. * - encoding: Set by user.
  1355. * - decoding: unused
  1356. */
  1357. int ildct_cmp;
  1358. #define FF_CMP_SAD 0
  1359. #define FF_CMP_SSE 1
  1360. #define FF_CMP_SATD 2
  1361. #define FF_CMP_DCT 3
  1362. #define FF_CMP_PSNR 4
  1363. #define FF_CMP_BIT 5
  1364. #define FF_CMP_RD 6
  1365. #define FF_CMP_ZERO 7
  1366. #define FF_CMP_VSAD 8
  1367. #define FF_CMP_VSSE 9
  1368. #define FF_CMP_NSSE 10
  1369. #define FF_CMP_DCTMAX 13
  1370. #define FF_CMP_DCT264 14
  1371. #define FF_CMP_CHROMA 256
  1372. /**
  1373. * ME diamond size & shape
  1374. * - encoding: Set by user.
  1375. * - decoding: unused
  1376. */
  1377. int dia_size;
  1378. /**
  1379. * amount of previous MV predictors (2a+1 x 2a+1 square)
  1380. * - encoding: Set by user.
  1381. * - decoding: unused
  1382. */
  1383. int last_predictor_count;
  1384. /**
  1385. * prepass for motion estimation
  1386. * - encoding: Set by user.
  1387. * - decoding: unused
  1388. */
  1389. int pre_me;
  1390. /**
  1391. * motion estimation prepass comparison function
  1392. * - encoding: Set by user.
  1393. * - decoding: unused
  1394. */
  1395. int me_pre_cmp;
  1396. /**
  1397. * ME prepass diamond size & shape
  1398. * - encoding: Set by user.
  1399. * - decoding: unused
  1400. */
  1401. int pre_dia_size;
  1402. /**
  1403. * subpel ME quality
  1404. * - encoding: Set by user.
  1405. * - decoding: unused
  1406. */
  1407. int me_subpel_quality;
  1408. #if FF_API_AFD
  1409. /**
  1410. * DTG active format information (additional aspect ratio
  1411. * information only used in DVB MPEG-2 transport streams)
  1412. * 0 if not set.
  1413. *
  1414. * - encoding: unused
  1415. * - decoding: Set by decoder.
  1416. * @deprecated Deprecated in favor of AVSideData
  1417. */
  1418. attribute_deprecated int dtg_active_format;
  1419. #define FF_DTG_AFD_SAME 8
  1420. #define FF_DTG_AFD_4_3 9
  1421. #define FF_DTG_AFD_16_9 10
  1422. #define FF_DTG_AFD_14_9 11
  1423. #define FF_DTG_AFD_4_3_SP_14_9 13
  1424. #define FF_DTG_AFD_16_9_SP_14_9 14
  1425. #define FF_DTG_AFD_SP_4_3 15
  1426. #endif /* FF_API_AFD */
  1427. /**
  1428. * maximum motion estimation search range in subpel units
  1429. * If 0 then no limit.
  1430. *
  1431. * - encoding: Set by user.
  1432. * - decoding: unused
  1433. */
  1434. int me_range;
  1435. /**
  1436. * intra quantizer bias
  1437. * - encoding: Set by user.
  1438. * - decoding: unused
  1439. */
  1440. int intra_quant_bias;
  1441. #define FF_DEFAULT_QUANT_BIAS 999999
  1442. /**
  1443. * inter quantizer bias
  1444. * - encoding: Set by user.
  1445. * - decoding: unused
  1446. */
  1447. int inter_quant_bias;
  1448. /**
  1449. * slice flags
  1450. * - encoding: unused
  1451. * - decoding: Set by user.
  1452. */
  1453. int slice_flags;
  1454. #define SLICE_FLAG_CODED_ORDER 0x0001 ///< draw_horiz_band() is called in coded order instead of display
  1455. #define SLICE_FLAG_ALLOW_FIELD 0x0002 ///< allow draw_horiz_band() with field slices (MPEG2 field pics)
  1456. #define SLICE_FLAG_ALLOW_PLANE 0x0004 ///< allow draw_horiz_band() with 1 component at a time (SVQ1)
  1457. #if FF_API_XVMC
  1458. /**
  1459. * XVideo Motion Acceleration
  1460. * - encoding: forbidden
  1461. * - decoding: set by decoder
  1462. * @deprecated XvMC support is slated for removal.
  1463. */
  1464. attribute_deprecated int xvmc_acceleration;
  1465. #endif /* FF_API_XVMC */
  1466. /**
  1467. * macroblock decision mode
  1468. * - encoding: Set by user.
  1469. * - decoding: unused
  1470. */
  1471. int mb_decision;
  1472. #define FF_MB_DECISION_SIMPLE 0 ///< uses mb_cmp
  1473. #define FF_MB_DECISION_BITS 1 ///< chooses the one which needs the fewest bits
  1474. #define FF_MB_DECISION_RD 2 ///< rate distortion
  1475. /**
  1476. * custom intra quantization matrix
  1477. * - encoding: Set by user, can be NULL.
  1478. * - decoding: Set by libavcodec.
  1479. */
  1480. uint16_t *intra_matrix;
  1481. /**
  1482. * custom inter quantization matrix
  1483. * - encoding: Set by user, can be NULL.
  1484. * - decoding: Set by libavcodec.
  1485. */
  1486. uint16_t *inter_matrix;
  1487. /**
  1488. * scene change detection threshold
  1489. * 0 is default, larger means fewer detected scene changes.
  1490. * - encoding: Set by user.
  1491. * - decoding: unused
  1492. */
  1493. int scenechange_threshold;
  1494. /**
  1495. * noise reduction strength
  1496. * - encoding: Set by user.
  1497. * - decoding: unused
  1498. */
  1499. int noise_reduction;
  1500. #if FF_API_MPV_OPT
  1501. /**
  1502. * @deprecated this field is unused
  1503. */
  1504. attribute_deprecated
  1505. int me_threshold;
  1506. /**
  1507. * @deprecated this field is unused
  1508. */
  1509. attribute_deprecated
  1510. int mb_threshold;
  1511. #endif
  1512. /**
  1513. * precision of the intra DC coefficient - 8
  1514. * - encoding: Set by user.
  1515. * - decoding: unused
  1516. */
  1517. int intra_dc_precision;
  1518. /**
  1519. * Number of macroblock rows at the top which are skipped.
  1520. * - encoding: unused
  1521. * - decoding: Set by user.
  1522. */
  1523. int skip_top;
  1524. /**
  1525. * Number of macroblock rows at the bottom which are skipped.
  1526. * - encoding: unused
  1527. * - decoding: Set by user.
  1528. */
  1529. int skip_bottom;
  1530. #if FF_API_MPV_OPT
  1531. /**
  1532. * @deprecated use encoder private options instead
  1533. */
  1534. attribute_deprecated
  1535. float border_masking;
  1536. #endif
  1537. /**
  1538. * minimum MB lagrange multipler
  1539. * - encoding: Set by user.
  1540. * - decoding: unused
  1541. */
  1542. int mb_lmin;
  1543. /**
  1544. * maximum MB lagrange multipler
  1545. * - encoding: Set by user.
  1546. * - decoding: unused
  1547. */
  1548. int mb_lmax;
  1549. /**
  1550. *
  1551. * - encoding: Set by user.
  1552. * - decoding: unused
  1553. */
  1554. int me_penalty_compensation;
  1555. /**
  1556. *
  1557. * - encoding: Set by user.
  1558. * - decoding: unused
  1559. */
  1560. int bidir_refine;
  1561. /**
  1562. *
  1563. * - encoding: Set by user.
  1564. * - decoding: unused
  1565. */
  1566. int brd_scale;
  1567. /**
  1568. * minimum GOP size
  1569. * - encoding: Set by user.
  1570. * - decoding: unused
  1571. */
  1572. int keyint_min;
  1573. /**
  1574. * number of reference frames
  1575. * - encoding: Set by user.
  1576. * - decoding: Set by lavc.
  1577. */
  1578. int refs;
  1579. /**
  1580. * chroma qp offset from luma
  1581. * - encoding: Set by user.
  1582. * - decoding: unused
  1583. */
  1584. int chromaoffset;
  1585. #if FF_API_UNUSED_MEMBERS
  1586. /**
  1587. * Multiplied by qscale for each frame and added to scene_change_score.
  1588. * - encoding: Set by user.
  1589. * - decoding: unused
  1590. */
  1591. attribute_deprecated int scenechange_factor;
  1592. #endif
  1593. /**
  1594. *
  1595. * Note: Value depends upon the compare function used for fullpel ME.
  1596. * - encoding: Set by user.
  1597. * - decoding: unused
  1598. */
  1599. int mv0_threshold;
  1600. /**
  1601. * Adjust sensitivity of b_frame_strategy 1.
  1602. * - encoding: Set by user.
  1603. * - decoding: unused
  1604. */
  1605. int b_sensitivity;
  1606. /**
  1607. * Chromaticity coordinates of the source primaries.
  1608. * - encoding: Set by user
  1609. * - decoding: Set by libavcodec
  1610. */
  1611. enum AVColorPrimaries color_primaries;
  1612. /**
  1613. * Color Transfer Characteristic.
  1614. * - encoding: Set by user
  1615. * - decoding: Set by libavcodec
  1616. */
  1617. enum AVColorTransferCharacteristic color_trc;
  1618. /**
  1619. * YUV colorspace type.
  1620. * - encoding: Set by user
  1621. * - decoding: Set by libavcodec
  1622. */
  1623. enum AVColorSpace colorspace;
  1624. /**
  1625. * MPEG vs JPEG YUV range.
  1626. * - encoding: Set by user
  1627. * - decoding: Set by libavcodec
  1628. */
  1629. enum AVColorRange color_range;
  1630. /**
  1631. * This defines the location of chroma samples.
  1632. * - encoding: Set by user
  1633. * - decoding: Set by libavcodec
  1634. */
  1635. enum AVChromaLocation chroma_sample_location;
  1636. /**
  1637. * Number of slices.
  1638. * Indicates number of picture subdivisions. Used for parallelized
  1639. * decoding.
  1640. * - encoding: Set by user
  1641. * - decoding: unused
  1642. */
  1643. int slices;
  1644. /** Field order
  1645. * - encoding: set by libavcodec
  1646. * - decoding: Set by libavcodec
  1647. */
  1648. enum AVFieldOrder field_order;
  1649. /* audio only */
  1650. int sample_rate; ///< samples per second
  1651. int channels; ///< number of audio channels
  1652. /**
  1653. * audio sample format
  1654. * - encoding: Set by user.
  1655. * - decoding: Set by libavcodec.
  1656. */
  1657. enum AVSampleFormat sample_fmt; ///< sample format
  1658. /* The following data should not be initialized. */
  1659. /**
  1660. * Number of samples per channel in an audio frame.
  1661. *
  1662. * - encoding: set by libavcodec in avcodec_open2(). Each submitted frame
  1663. * except the last must contain exactly frame_size samples per channel.
  1664. * May be 0 when the codec has CODEC_CAP_VARIABLE_FRAME_SIZE set, then the
  1665. * frame size is not restricted.
  1666. * - decoding: may be set by some decoders to indicate constant frame size
  1667. */
  1668. int frame_size;
  1669. /**
  1670. * Frame counter, set by libavcodec.
  1671. *
  1672. * - decoding: total number of frames returned from the decoder so far.
  1673. * - encoding: total number of frames passed to the encoder so far.
  1674. *
  1675. * @note the counter is not incremented if encoding/decoding resulted in
  1676. * an error.
  1677. */
  1678. int frame_number;
  1679. /**
  1680. * number of bytes per packet if constant and known or 0
  1681. * Used by some WAV based audio codecs.
  1682. */
  1683. int block_align;
  1684. /**
  1685. * Audio cutoff bandwidth (0 means "automatic")
  1686. * - encoding: Set by user.
  1687. * - decoding: unused
  1688. */
  1689. int cutoff;
  1690. #if FF_API_REQUEST_CHANNELS
  1691. /**
  1692. * Decoder should decode to this many channels if it can (0 for default)
  1693. * - encoding: unused
  1694. * - decoding: Set by user.
  1695. * @deprecated Deprecated in favor of request_channel_layout.
  1696. */
  1697. attribute_deprecated int request_channels;
  1698. #endif
  1699. /**
  1700. * Audio channel layout.
  1701. * - encoding: set by user.
  1702. * - decoding: set by libavcodec.
  1703. */
  1704. uint64_t channel_layout;
  1705. /**
  1706. * Request decoder to use this channel layout if it can (0 for default)
  1707. * - encoding: unused
  1708. * - decoding: Set by user.
  1709. */
  1710. uint64_t request_channel_layout;
  1711. /**
  1712. * Type of service that the audio stream conveys.
  1713. * - encoding: Set by user.
  1714. * - decoding: Set by libavcodec.
  1715. */
  1716. enum AVAudioServiceType audio_service_type;
  1717. /**
  1718. * Used to request a sample format from the decoder.
  1719. * - encoding: unused.
  1720. * - decoding: Set by user.
  1721. */
  1722. enum AVSampleFormat request_sample_fmt;
  1723. #if FF_API_GET_BUFFER
  1724. /**
  1725. * Called at the beginning of each frame to get a buffer for it.
  1726. *
  1727. * The function will set AVFrame.data[], AVFrame.linesize[].
  1728. * AVFrame.extended_data[] must also be set, but it should be the same as
  1729. * AVFrame.data[] except for planar audio with more channels than can fit
  1730. * in AVFrame.data[]. In that case, AVFrame.data[] shall still contain as
  1731. * many data pointers as it can hold.
  1732. *
  1733. * if CODEC_CAP_DR1 is not set then get_buffer() must call
  1734. * avcodec_default_get_buffer() instead of providing buffers allocated by
  1735. * some other means.
  1736. *
  1737. * AVFrame.data[] should be 32- or 16-byte-aligned unless the CPU doesn't
  1738. * need it. avcodec_default_get_buffer() aligns the output buffer properly,
  1739. * but if get_buffer() is overridden then alignment considerations should
  1740. * be taken into account.
  1741. *
  1742. * @see avcodec_default_get_buffer()
  1743. *
  1744. * Video:
  1745. *
  1746. * If pic.reference is set then the frame will be read later by libavcodec.
  1747. * avcodec_align_dimensions2() should be used to find the required width and
  1748. * height, as they normally need to be rounded up to the next multiple of 16.
  1749. *
  1750. * If frame multithreading is used and thread_safe_callbacks is set,
  1751. * it may be called from a different thread, but not from more than one at
  1752. * once. Does not need to be reentrant.
  1753. *
  1754. * @see release_buffer(), reget_buffer()
  1755. * @see avcodec_align_dimensions2()
  1756. *
  1757. * Audio:
  1758. *
  1759. * Decoders request a buffer of a particular size by setting
  1760. * AVFrame.nb_samples prior to calling get_buffer(). The decoder may,
  1761. * however, utilize only part of the buffer by setting AVFrame.nb_samples
  1762. * to a smaller value in the output frame.
  1763. *
  1764. * Decoders cannot use the buffer after returning from
  1765. * avcodec_decode_audio4(), so they will not call release_buffer(), as it
  1766. * is assumed to be released immediately upon return. In some rare cases,
  1767. * a decoder may need to call get_buffer() more than once in a single
  1768. * call to avcodec_decode_audio4(). In that case, when get_buffer() is
  1769. * called again after it has already been called once, the previously
  1770. * acquired buffer is assumed to be released at that time and may not be
  1771. * reused by the decoder.
  1772. *
  1773. * As a convenience, av_samples_get_buffer_size() and
  1774. * av_samples_fill_arrays() in libavutil may be used by custom get_buffer()
  1775. * functions to find the required data size and to fill data pointers and
  1776. * linesize. In AVFrame.linesize, only linesize[0] may be set for audio
  1777. * since all planes must be the same size.
  1778. *
  1779. * @see av_samples_get_buffer_size(), av_samples_fill_arrays()
  1780. *
  1781. * - encoding: unused
  1782. * - decoding: Set by libavcodec, user can override.
  1783. *
  1784. * @deprecated use get_buffer2()
  1785. */
  1786. attribute_deprecated
  1787. int (*get_buffer)(struct AVCodecContext *c, AVFrame *pic);
  1788. /**
  1789. * Called to release buffers which were allocated with get_buffer.
  1790. * A released buffer can be reused in get_buffer().
  1791. * pic.data[*] must be set to NULL.
  1792. * May be called from a different thread if frame multithreading is used,
  1793. * but not by more than one thread at once, so does not need to be reentrant.
  1794. * - encoding: unused
  1795. * - decoding: Set by libavcodec, user can override.
  1796. *
  1797. * @deprecated custom freeing callbacks should be set from get_buffer2()
  1798. */
  1799. attribute_deprecated
  1800. void (*release_buffer)(struct AVCodecContext *c, AVFrame *pic);
  1801. /**
  1802. * Called at the beginning of a frame to get cr buffer for it.
  1803. * Buffer type (size, hints) must be the same. libavcodec won't check it.
  1804. * libavcodec will pass previous buffer in pic, function should return
  1805. * same buffer or new buffer with old frame "painted" into it.
  1806. * If pic.data[0] == NULL must behave like get_buffer().
  1807. * if CODEC_CAP_DR1 is not set then reget_buffer() must call
  1808. * avcodec_default_reget_buffer() instead of providing buffers allocated by
  1809. * some other means.
  1810. * - encoding: unused
  1811. * - decoding: Set by libavcodec, user can override.
  1812. */
  1813. attribute_deprecated
  1814. int (*reget_buffer)(struct AVCodecContext *c, AVFrame *pic);
  1815. #endif
  1816. /**
  1817. * This callback is called at the beginning of each frame to get data
  1818. * buffer(s) for it. There may be one contiguous buffer for all the data or
  1819. * there may be a buffer per each data plane or anything in between. What
  1820. * this means is, you may set however many entries in buf[] you feel necessary.
  1821. * Each buffer must be reference-counted using the AVBuffer API (see description
  1822. * of buf[] below).
  1823. *
  1824. * The following fields will be set in the frame before this callback is
  1825. * called:
  1826. * - format
  1827. * - width, height (video only)
  1828. * - sample_rate, channel_layout, nb_samples (audio only)
  1829. * Their values may differ from the corresponding values in
  1830. * AVCodecContext. This callback must use the frame values, not the codec
  1831. * context values, to calculate the required buffer size.
  1832. *
  1833. * This callback must fill the following fields in the frame:
  1834. * - data[]
  1835. * - linesize[]
  1836. * - extended_data:
  1837. * * if the data is planar audio with more than 8 channels, then this
  1838. * callback must allocate and fill extended_data to contain all pointers
  1839. * to all data planes. data[] must hold as many pointers as it can.
  1840. * extended_data must be allocated with av_malloc() and will be freed in
  1841. * av_frame_unref().
  1842. * * otherwise exended_data must point to data
  1843. * - buf[] must contain one or more pointers to AVBufferRef structures. Each of
  1844. * the frame's data and extended_data pointers must be contained in these. That
  1845. * is, one AVBufferRef for each allocated chunk of memory, not necessarily one
  1846. * AVBufferRef per data[] entry. See: av_buffer_create(), av_buffer_alloc(),
  1847. * and av_buffer_ref().
  1848. * - extended_buf and nb_extended_buf must be allocated with av_malloc() by
  1849. * this callback and filled with the extra buffers if there are more
  1850. * buffers than buf[] can hold. extended_buf will be freed in
  1851. * av_frame_unref().
  1852. *
  1853. * If CODEC_CAP_DR1 is not set then get_buffer2() must call
  1854. * avcodec_default_get_buffer2() instead of providing buffers allocated by
  1855. * some other means.
  1856. *
  1857. * Each data plane must be aligned to the maximum required by the target
  1858. * CPU.
  1859. *
  1860. * @see avcodec_default_get_buffer2()
  1861. *
  1862. * Video:
  1863. *
  1864. * If AV_GET_BUFFER_FLAG_REF is set in flags then the frame may be reused
  1865. * (read and/or written to if it is writable) later by libavcodec.
  1866. *
  1867. * avcodec_align_dimensions2() should be used to find the required width and
  1868. * height, as they normally need to be rounded up to the next multiple of 16.
  1869. *
  1870. * If frame multithreading is used and thread_safe_callbacks is set,
  1871. * this callback may be called from a different thread, but not from more
  1872. * than one at once. Does not need to be reentrant.
  1873. *
  1874. * @see avcodec_align_dimensions2()
  1875. *
  1876. * Audio:
  1877. *
  1878. * Decoders request a buffer of a particular size by setting
  1879. * AVFrame.nb_samples prior to calling get_buffer2(). The decoder may,
  1880. * however, utilize only part of the buffer by setting AVFrame.nb_samples
  1881. * to a smaller value in the output frame.
  1882. *
  1883. * As a convenience, av_samples_get_buffer_size() and
  1884. * av_samples_fill_arrays() in libavutil may be used by custom get_buffer2()
  1885. * functions to find the required data size and to fill data pointers and
  1886. * linesize. In AVFrame.linesize, only linesize[0] may be set for audio
  1887. * since all planes must be the same size.
  1888. *
  1889. * @see av_samples_get_buffer_size(), av_samples_fill_arrays()
  1890. *
  1891. * - encoding: unused
  1892. * - decoding: Set by libavcodec, user can override.
  1893. */
  1894. int (*get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags);
  1895. /**
  1896. * If non-zero, the decoded audio and video frames returned from
  1897. * avcodec_decode_video2() and avcodec_decode_audio4() are reference-counted
  1898. * and are valid indefinitely. The caller must free them with
  1899. * av_frame_unref() when they are not needed anymore.
  1900. * Otherwise, the decoded frames must not be freed by the caller and are
  1901. * only valid until the next decode call.
  1902. *
  1903. * - encoding: unused
  1904. * - decoding: set by the caller before avcodec_open2().
  1905. */
  1906. int refcounted_frames;
  1907. /* - encoding parameters */
  1908. float qcompress; ///< amount of qscale change between easy & hard scenes (0.0-1.0)
  1909. float qblur; ///< amount of qscale smoothing over time (0.0-1.0)
  1910. /**
  1911. * minimum quantizer
  1912. * - encoding: Set by user.
  1913. * - decoding: unused
  1914. */
  1915. int qmin;
  1916. /**
  1917. * maximum quantizer
  1918. * - encoding: Set by user.
  1919. * - decoding: unused
  1920. */
  1921. int qmax;
  1922. /**
  1923. * maximum quantizer difference between frames
  1924. * - encoding: Set by user.
  1925. * - decoding: unused
  1926. */
  1927. int max_qdiff;
  1928. #if FF_API_MPV_OPT
  1929. /**
  1930. * @deprecated use encoder private options instead
  1931. */
  1932. attribute_deprecated
  1933. float rc_qsquish;
  1934. attribute_deprecated
  1935. float rc_qmod_amp;
  1936. attribute_deprecated
  1937. int rc_qmod_freq;
  1938. #endif
  1939. /**
  1940. * decoder bitstream buffer size
  1941. * - encoding: Set by user.
  1942. * - decoding: unused
  1943. */
  1944. int rc_buffer_size;
  1945. /**
  1946. * ratecontrol override, see RcOverride
  1947. * - encoding: Allocated/set/freed by user.
  1948. * - decoding: unused
  1949. */
  1950. int rc_override_count;
  1951. RcOverride *rc_override;
  1952. #if FF_API_MPV_OPT
  1953. /**
  1954. * @deprecated use encoder private options instead
  1955. */
  1956. attribute_deprecated
  1957. const char *rc_eq;
  1958. #endif
  1959. /**
  1960. * maximum bitrate
  1961. * - encoding: Set by user.
  1962. * - decoding: unused
  1963. */
  1964. int rc_max_rate;
  1965. /**
  1966. * minimum bitrate
  1967. * - encoding: Set by user.
  1968. * - decoding: unused
  1969. */
  1970. int rc_min_rate;
  1971. #if FF_API_MPV_OPT
  1972. /**
  1973. * @deprecated use encoder private options instead
  1974. */
  1975. attribute_deprecated
  1976. float rc_buffer_aggressivity;
  1977. attribute_deprecated
  1978. float rc_initial_cplx;
  1979. #endif
  1980. /**
  1981. * Ratecontrol attempt to use, at maximum, <value> of what can be used without an underflow.
  1982. * - encoding: Set by user.
  1983. * - decoding: unused.
  1984. */
  1985. float rc_max_available_vbv_use;
  1986. /**
  1987. * Ratecontrol attempt to use, at least, <value> times the amount needed to prevent a vbv overflow.
  1988. * - encoding: Set by user.
  1989. * - decoding: unused.
  1990. */
  1991. float rc_min_vbv_overflow_use;
  1992. /**
  1993. * Number of bits which should be loaded into the rc buffer before decoding starts.
  1994. * - encoding: Set by user.
  1995. * - decoding: unused
  1996. */
  1997. int rc_initial_buffer_occupancy;
  1998. #define FF_CODER_TYPE_VLC 0
  1999. #define FF_CODER_TYPE_AC 1
  2000. #define FF_CODER_TYPE_RAW 2
  2001. #define FF_CODER_TYPE_RLE 3
  2002. #if FF_API_UNUSED_MEMBERS
  2003. #define FF_CODER_TYPE_DEFLATE 4
  2004. #endif /* FF_API_UNUSED_MEMBERS */
  2005. /**
  2006. * coder type
  2007. * - encoding: Set by user.
  2008. * - decoding: unused
  2009. */
  2010. int coder_type;
  2011. /**
  2012. * context model
  2013. * - encoding: Set by user.
  2014. * - decoding: unused
  2015. */
  2016. int context_model;
  2017. #if FF_API_MPV_OPT
  2018. /**
  2019. * @deprecated use encoder private options instead
  2020. */
  2021. attribute_deprecated
  2022. int lmin;
  2023. /**
  2024. * @deprecated use encoder private options instead
  2025. */
  2026. attribute_deprecated
  2027. int lmax;
  2028. #endif
  2029. /**
  2030. * frame skip threshold
  2031. * - encoding: Set by user.
  2032. * - decoding: unused
  2033. */
  2034. int frame_skip_threshold;
  2035. /**
  2036. * frame skip factor
  2037. * - encoding: Set by user.
  2038. * - decoding: unused
  2039. */
  2040. int frame_skip_factor;
  2041. /**
  2042. * frame skip exponent
  2043. * - encoding: Set by user.
  2044. * - decoding: unused
  2045. */
  2046. int frame_skip_exp;
  2047. /**
  2048. * frame skip comparison function
  2049. * - encoding: Set by user.
  2050. * - decoding: unused
  2051. */
  2052. int frame_skip_cmp;
  2053. /**
  2054. * trellis RD quantization
  2055. * - encoding: Set by user.
  2056. * - decoding: unused
  2057. */
  2058. int trellis;
  2059. /**
  2060. * - encoding: Set by user.
  2061. * - decoding: unused
  2062. */
  2063. int min_prediction_order;
  2064. /**
  2065. * - encoding: Set by user.
  2066. * - decoding: unused
  2067. */
  2068. int max_prediction_order;
  2069. /**
  2070. * GOP timecode frame start number, in non drop frame format
  2071. * - encoding: Set by user.
  2072. * - decoding: unused
  2073. */
  2074. int64_t timecode_frame_start;
  2075. /* The RTP callback: This function is called */
  2076. /* every time the encoder has a packet to send. */
  2077. /* It depends on the encoder if the data starts */
  2078. /* with a Start Code (it should). H.263 does. */
  2079. /* mb_nb contains the number of macroblocks */
  2080. /* encoded in the RTP payload. */
  2081. void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb);
  2082. int rtp_payload_size; /* The size of the RTP payload: the coder will */
  2083. /* do its best to deliver a chunk with size */
  2084. /* below rtp_payload_size, the chunk will start */
  2085. /* with a start code on some codecs like H.263. */
  2086. /* This doesn't take account of any particular */
  2087. /* headers inside the transmitted RTP payload. */
  2088. /* statistics, used for 2-pass encoding */
  2089. int mv_bits;
  2090. int header_bits;
  2091. int i_tex_bits;
  2092. int p_tex_bits;
  2093. int i_count;
  2094. int p_count;
  2095. int skip_count;
  2096. int misc_bits;
  2097. /**
  2098. * number of bits used for the previously encoded frame
  2099. * - encoding: Set by libavcodec.
  2100. * - decoding: unused
  2101. */
  2102. int frame_bits;
  2103. /**
  2104. * pass1 encoding statistics output buffer
  2105. * - encoding: Set by libavcodec.
  2106. * - decoding: unused
  2107. */
  2108. char *stats_out;
  2109. /**
  2110. * pass2 encoding statistics input buffer
  2111. * Concatenated stuff from stats_out of pass1 should be placed here.
  2112. * - encoding: Allocated/set/freed by user.
  2113. * - decoding: unused
  2114. */
  2115. char *stats_in;
  2116. /**
  2117. * Work around bugs in encoders which sometimes cannot be detected automatically.
  2118. * - encoding: Set by user
  2119. * - decoding: Set by user
  2120. */
  2121. int workaround_bugs;
  2122. #define FF_BUG_AUTODETECT 1 ///< autodetection
  2123. #if FF_API_OLD_MSMPEG4
  2124. #define FF_BUG_OLD_MSMPEG4 2
  2125. #endif
  2126. #define FF_BUG_XVID_ILACE 4
  2127. #define FF_BUG_UMP4 8
  2128. #define FF_BUG_NO_PADDING 16
  2129. #define FF_BUG_AMV 32
  2130. #if FF_API_AC_VLC
  2131. #define FF_BUG_AC_VLC 0 ///< Will be removed, libavcodec can now handle these non-compliant files by default.
  2132. #endif
  2133. #define FF_BUG_QPEL_CHROMA 64
  2134. #define FF_BUG_STD_QPEL 128
  2135. #define FF_BUG_QPEL_CHROMA2 256
  2136. #define FF_BUG_DIRECT_BLOCKSIZE 512
  2137. #define FF_BUG_EDGE 1024
  2138. #define FF_BUG_HPEL_CHROMA 2048
  2139. #define FF_BUG_DC_CLIP 4096
  2140. #define FF_BUG_MS 8192 ///< Work around various bugs in Microsoft's broken decoders.
  2141. #define FF_BUG_TRUNCATED 16384
  2142. /**
  2143. * strictly follow the standard (MPEG4, ...).
  2144. * - encoding: Set by user.
  2145. * - decoding: Set by user.
  2146. * Setting this to STRICT or higher means the encoder and decoder will
  2147. * generally do stupid things, whereas setting it to unofficial or lower
  2148. * will mean the encoder might produce output that is not supported by all
  2149. * spec-compliant decoders. Decoders don't differentiate between normal,
  2150. * unofficial and experimental (that is, they always try to decode things
  2151. * when they can) unless they are explicitly asked to behave stupidly
  2152. * (=strictly conform to the specs)
  2153. */
  2154. int strict_std_compliance;
  2155. #define FF_COMPLIANCE_VERY_STRICT 2 ///< Strictly conform to an older more strict version of the spec or reference software.
  2156. #define FF_COMPLIANCE_STRICT 1 ///< Strictly conform to all the things in the spec no matter what consequences.
  2157. #define FF_COMPLIANCE_NORMAL 0
  2158. #define FF_COMPLIANCE_UNOFFICIAL -1 ///< Allow unofficial extensions
  2159. #define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things.
  2160. /**
  2161. * error concealment flags
  2162. * - encoding: unused
  2163. * - decoding: Set by user.
  2164. */
  2165. int error_concealment;
  2166. #define FF_EC_GUESS_MVS 1
  2167. #define FF_EC_DEBLOCK 2
  2168. /**
  2169. * debug
  2170. * - encoding: Set by user.
  2171. * - decoding: Set by user.
  2172. */
  2173. int debug;
  2174. #define FF_DEBUG_PICT_INFO 1
  2175. #define FF_DEBUG_RC 2
  2176. #define FF_DEBUG_BITSTREAM 4
  2177. #define FF_DEBUG_MB_TYPE 8
  2178. #define FF_DEBUG_QP 16
  2179. #if FF_API_DEBUG_MV
  2180. /**
  2181. * @deprecated this option does nothing
  2182. */
  2183. #define FF_DEBUG_MV 32
  2184. #endif
  2185. #define FF_DEBUG_DCT_COEFF 0x00000040
  2186. #define FF_DEBUG_SKIP 0x00000080
  2187. #define FF_DEBUG_STARTCODE 0x00000100
  2188. #if FF_API_UNUSED_MEMBERS
  2189. #define FF_DEBUG_PTS 0x00000200
  2190. #endif /* FF_API_UNUSED_MEMBERS */
  2191. #define FF_DEBUG_ER 0x00000400
  2192. #define FF_DEBUG_MMCO 0x00000800
  2193. #define FF_DEBUG_BUGS 0x00001000
  2194. #if FF_API_DEBUG_MV
  2195. #define FF_DEBUG_VIS_QP 0x00002000
  2196. #define FF_DEBUG_VIS_MB_TYPE 0x00004000
  2197. #endif
  2198. #define FF_DEBUG_BUFFERS 0x00008000
  2199. #define FF_DEBUG_THREADS 0x00010000
  2200. #if FF_API_DEBUG_MV
  2201. /**
  2202. * @deprecated this option does not have any effect
  2203. */
  2204. attribute_deprecated
  2205. int debug_mv;
  2206. #define FF_DEBUG_VIS_MV_P_FOR 0x00000001 //visualize forward predicted MVs of P frames
  2207. #define FF_DEBUG_VIS_MV_B_FOR 0x00000002 //visualize forward predicted MVs of B frames
  2208. #define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames
  2209. #endif
  2210. /**
  2211. * Error recognition; may misdetect some more or less valid parts as errors.
  2212. * - encoding: unused
  2213. * - decoding: Set by user.
  2214. */
  2215. int err_recognition;
  2216. /**
  2217. * Verify checksums embedded in the bitstream (could be of either encoded or
  2218. * decoded data, depending on the codec) and print an error message on mismatch.
  2219. * If AV_EF_EXPLODE is also set, a mismatching checksum will result in the
  2220. * decoder returning an error.
  2221. */
  2222. #define AV_EF_CRCCHECK (1<<0)
  2223. #define AV_EF_BITSTREAM (1<<1)
  2224. #define AV_EF_BUFFER (1<<2)
  2225. #define AV_EF_EXPLODE (1<<3)
  2226. /**
  2227. * opaque 64bit number (generally a PTS) that will be reordered and
  2228. * output in AVFrame.reordered_opaque
  2229. * - encoding: unused
  2230. * - decoding: Set by user.
  2231. */
  2232. int64_t reordered_opaque;
  2233. /**
  2234. * Hardware accelerator in use
  2235. * - encoding: unused.
  2236. * - decoding: Set by libavcodec
  2237. */
  2238. struct AVHWAccel *hwaccel;
  2239. /**
  2240. * Hardware accelerator context.
  2241. * For some hardware accelerators, a global context needs to be
  2242. * provided by the user. In that case, this holds display-dependent
  2243. * data Libav cannot instantiate itself. Please refer to the
  2244. * Libav HW accelerator documentation to know how to fill this
  2245. * is. e.g. for VA API, this is a struct vaapi_context.
  2246. * - encoding: unused
  2247. * - decoding: Set by user
  2248. */
  2249. void *hwaccel_context;
  2250. /**
  2251. * error
  2252. * - encoding: Set by libavcodec if flags&CODEC_FLAG_PSNR.
  2253. * - decoding: unused
  2254. */
  2255. uint64_t error[AV_NUM_DATA_POINTERS];
  2256. /**
  2257. * DCT algorithm, see FF_DCT_* below
  2258. * - encoding: Set by user.
  2259. * - decoding: unused
  2260. */
  2261. int dct_algo;
  2262. #define FF_DCT_AUTO 0
  2263. #define FF_DCT_FASTINT 1
  2264. #if FF_API_UNUSED_MEMBERS
  2265. #define FF_DCT_INT 2
  2266. #endif /* FF_API_UNUSED_MEMBERS */
  2267. #define FF_DCT_MMX 3
  2268. #define FF_DCT_ALTIVEC 5
  2269. #define FF_DCT_FAAN 6
  2270. /**
  2271. * IDCT algorithm, see FF_IDCT_* below.
  2272. * - encoding: Set by user.
  2273. * - decoding: Set by user.
  2274. */
  2275. int idct_algo;
  2276. #define FF_IDCT_AUTO 0
  2277. #define FF_IDCT_INT 1
  2278. #define FF_IDCT_SIMPLE 2
  2279. #define FF_IDCT_SIMPLEMMX 3
  2280. #define FF_IDCT_ARM 7
  2281. #define FF_IDCT_ALTIVEC 8
  2282. #if FF_API_ARCH_SH4
  2283. #define FF_IDCT_SH4 9
  2284. #endif
  2285. #define FF_IDCT_SIMPLEARM 10
  2286. #if FF_API_UNUSED_MEMBERS
  2287. #define FF_IDCT_IPP 13
  2288. #endif /* FF_API_UNUSED_MEMBERS */
  2289. #define FF_IDCT_XVID 14
  2290. #if FF_API_IDCT_XVIDMMX
  2291. #define FF_IDCT_XVIDMMX 14
  2292. #endif /* FF_API_IDCT_XVIDMMX */
  2293. #define FF_IDCT_SIMPLEARMV5TE 16
  2294. #define FF_IDCT_SIMPLEARMV6 17
  2295. #if FF_API_ARCH_SPARC
  2296. #define FF_IDCT_SIMPLEVIS 18
  2297. #endif
  2298. #define FF_IDCT_FAAN 20
  2299. #define FF_IDCT_SIMPLENEON 22
  2300. #if FF_API_ARCH_ALPHA
  2301. #define FF_IDCT_SIMPLEALPHA 23
  2302. #endif
  2303. /**
  2304. * bits per sample/pixel from the demuxer (needed for huffyuv).
  2305. * - encoding: Set by libavcodec.
  2306. * - decoding: Set by user.
  2307. */
  2308. int bits_per_coded_sample;
  2309. /**
  2310. * Bits per sample/pixel of internal libavcodec pixel/sample format.
  2311. * - encoding: set by user.
  2312. * - decoding: set by libavcodec.
  2313. */
  2314. int bits_per_raw_sample;
  2315. #if FF_API_LOWRES
  2316. /**
  2317. * low resolution decoding, 1-> 1/2 size, 2->1/4 size
  2318. * - encoding: unused
  2319. * - decoding: Set by user.
  2320. *
  2321. * @deprecated use decoder private options instead
  2322. */
  2323. attribute_deprecated int lowres;
  2324. #endif
  2325. /**
  2326. * the picture in the bitstream
  2327. * - encoding: Set by libavcodec.
  2328. * - decoding: unused
  2329. */
  2330. AVFrame *coded_frame;
  2331. /**
  2332. * thread count
  2333. * is used to decide how many independent tasks should be passed to execute()
  2334. * - encoding: Set by user.
  2335. * - decoding: Set by user.
  2336. */
  2337. int thread_count;
  2338. /**
  2339. * Which multithreading methods to use.
  2340. * Use of FF_THREAD_FRAME will increase decoding delay by one frame per thread,
  2341. * so clients which cannot provide future frames should not use it.
  2342. *
  2343. * - encoding: Set by user, otherwise the default is used.
  2344. * - decoding: Set by user, otherwise the default is used.
  2345. */
  2346. int thread_type;
  2347. #define FF_THREAD_FRAME 1 ///< Decode more than one frame at once
  2348. #define FF_THREAD_SLICE 2 ///< Decode more than one part of a single frame at once
  2349. /**
  2350. * Which multithreading methods are in use by the codec.
  2351. * - encoding: Set by libavcodec.
  2352. * - decoding: Set by libavcodec.
  2353. */
  2354. int active_thread_type;
  2355. /**
  2356. * Set by the client if its custom get_buffer() callback can be called
  2357. * synchronously from another thread, which allows faster multithreaded decoding.
  2358. * draw_horiz_band() will be called from other threads regardless of this setting.
  2359. * Ignored if the default get_buffer() is used.
  2360. * - encoding: Set by user.
  2361. * - decoding: Set by user.
  2362. */
  2363. int thread_safe_callbacks;
  2364. /**
  2365. * The codec may call this to execute several independent things.
  2366. * It will return only after finishing all tasks.
  2367. * The user may replace this with some multithreaded implementation,
  2368. * the default implementation will execute the parts serially.
  2369. * @param count the number of things to execute
  2370. * - encoding: Set by libavcodec, user can override.
  2371. * - decoding: Set by libavcodec, user can override.
  2372. */
  2373. int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size);
  2374. /**
  2375. * The codec may call this to execute several independent things.
  2376. * It will return only after finishing all tasks.
  2377. * The user may replace this with some multithreaded implementation,
  2378. * the default implementation will execute the parts serially.
  2379. * Also see avcodec_thread_init and e.g. the --enable-pthread configure option.
  2380. * @param c context passed also to func
  2381. * @param count the number of things to execute
  2382. * @param arg2 argument passed unchanged to func
  2383. * @param ret return values of executed functions, must have space for "count" values. May be NULL.
  2384. * @param func function that will be called count times, with jobnr from 0 to count-1.
  2385. * threadnr will be in the range 0 to c->thread_count-1 < MAX_THREADS and so that no
  2386. * two instances of func executing at the same time will have the same threadnr.
  2387. * @return always 0 currently, but code should handle a future improvement where when any call to func
  2388. * returns < 0 no further calls to func may be done and < 0 is returned.
  2389. * - encoding: Set by libavcodec, user can override.
  2390. * - decoding: Set by libavcodec, user can override.
  2391. */
  2392. int (*execute2)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count);
  2393. #if FF_API_THREAD_OPAQUE
  2394. /**
  2395. * @deprecated this field should not be used from outside of lavc
  2396. */
  2397. attribute_deprecated
  2398. void *thread_opaque;
  2399. #endif
  2400. /**
  2401. * noise vs. sse weight for the nsse comparsion function
  2402. * - encoding: Set by user.
  2403. * - decoding: unused
  2404. */
  2405. int nsse_weight;
  2406. /**
  2407. * profile
  2408. * - encoding: Set by user.
  2409. * - decoding: Set by libavcodec.
  2410. */
  2411. int profile;
  2412. #define FF_PROFILE_UNKNOWN -99
  2413. #define FF_PROFILE_RESERVED -100
  2414. #define FF_PROFILE_AAC_MAIN 0
  2415. #define FF_PROFILE_AAC_LOW 1
  2416. #define FF_PROFILE_AAC_SSR 2
  2417. #define FF_PROFILE_AAC_LTP 3
  2418. #define FF_PROFILE_AAC_HE 4
  2419. #define FF_PROFILE_AAC_HE_V2 28
  2420. #define FF_PROFILE_AAC_LD 22
  2421. #define FF_PROFILE_AAC_ELD 38
  2422. #define FF_PROFILE_MPEG2_AAC_LOW 128
  2423. #define FF_PROFILE_MPEG2_AAC_HE 131
  2424. #define FF_PROFILE_DTS 20
  2425. #define FF_PROFILE_DTS_ES 30
  2426. #define FF_PROFILE_DTS_96_24 40
  2427. #define FF_PROFILE_DTS_HD_HRA 50
  2428. #define FF_PROFILE_DTS_HD_MA 60
  2429. #define FF_PROFILE_MPEG2_422 0
  2430. #define FF_PROFILE_MPEG2_HIGH 1
  2431. #define FF_PROFILE_MPEG2_SS 2
  2432. #define FF_PROFILE_MPEG2_SNR_SCALABLE 3
  2433. #define FF_PROFILE_MPEG2_MAIN 4
  2434. #define FF_PROFILE_MPEG2_SIMPLE 5
  2435. #define FF_PROFILE_H264_CONSTRAINED (1<<9) // 8+1; constraint_set1_flag
  2436. #define FF_PROFILE_H264_INTRA (1<<11) // 8+3; constraint_set3_flag
  2437. #define FF_PROFILE_H264_BASELINE 66
  2438. #define FF_PROFILE_H264_CONSTRAINED_BASELINE (66|FF_PROFILE_H264_CONSTRAINED)
  2439. #define FF_PROFILE_H264_MAIN 77
  2440. #define FF_PROFILE_H264_EXTENDED 88
  2441. #define FF_PROFILE_H264_HIGH 100
  2442. #define FF_PROFILE_H264_HIGH_10 110
  2443. #define FF_PROFILE_H264_HIGH_10_INTRA (110|FF_PROFILE_H264_INTRA)
  2444. #define FF_PROFILE_H264_HIGH_422 122
  2445. #define FF_PROFILE_H264_HIGH_422_INTRA (122|FF_PROFILE_H264_INTRA)
  2446. #define FF_PROFILE_H264_HIGH_444 144
  2447. #define FF_PROFILE_H264_HIGH_444_PREDICTIVE 244
  2448. #define FF_PROFILE_H264_HIGH_444_INTRA (244|FF_PROFILE_H264_INTRA)
  2449. #define FF_PROFILE_H264_CAVLC_444 44
  2450. #define FF_PROFILE_VC1_SIMPLE 0
  2451. #define FF_PROFILE_VC1_MAIN 1
  2452. #define FF_PROFILE_VC1_COMPLEX 2
  2453. #define FF_PROFILE_VC1_ADVANCED 3
  2454. #define FF_PROFILE_MPEG4_SIMPLE 0
  2455. #define FF_PROFILE_MPEG4_SIMPLE_SCALABLE 1
  2456. #define FF_PROFILE_MPEG4_CORE 2
  2457. #define FF_PROFILE_MPEG4_MAIN 3
  2458. #define FF_PROFILE_MPEG4_N_BIT 4
  2459. #define FF_PROFILE_MPEG4_SCALABLE_TEXTURE 5
  2460. #define FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION 6
  2461. #define FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE 7
  2462. #define FF_PROFILE_MPEG4_HYBRID 8
  2463. #define FF_PROFILE_MPEG4_ADVANCED_REAL_TIME 9
  2464. #define FF_PROFILE_MPEG4_CORE_SCALABLE 10
  2465. #define FF_PROFILE_MPEG4_ADVANCED_CODING 11
  2466. #define FF_PROFILE_MPEG4_ADVANCED_CORE 12
  2467. #define FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE 13
  2468. #define FF_PROFILE_MPEG4_SIMPLE_STUDIO 14
  2469. #define FF_PROFILE_MPEG4_ADVANCED_SIMPLE 15
  2470. #define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0 0
  2471. #define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1 1
  2472. #define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION 2
  2473. #define FF_PROFILE_JPEG2000_DCINEMA_2K 3
  2474. #define FF_PROFILE_JPEG2000_DCINEMA_4K 4
  2475. #define FF_PROFILE_HEVC_MAIN 1
  2476. #define FF_PROFILE_HEVC_MAIN_10 2
  2477. #define FF_PROFILE_HEVC_MAIN_STILL_PICTURE 3
  2478. /**
  2479. * level
  2480. * - encoding: Set by user.
  2481. * - decoding: Set by libavcodec.
  2482. */
  2483. int level;
  2484. #define FF_LEVEL_UNKNOWN -99
  2485. /**
  2486. *
  2487. * - encoding: unused
  2488. * - decoding: Set by user.
  2489. */
  2490. enum AVDiscard skip_loop_filter;
  2491. /**
  2492. *
  2493. * - encoding: unused
  2494. * - decoding: Set by user.
  2495. */
  2496. enum AVDiscard skip_idct;
  2497. /**
  2498. *
  2499. * - encoding: unused
  2500. * - decoding: Set by user.
  2501. */
  2502. enum AVDiscard skip_frame;
  2503. /**
  2504. * Header containing style information for text subtitles.
  2505. * For SUBTITLE_ASS subtitle type, it should contain the whole ASS
  2506. * [Script Info] and [V4+ Styles] section, plus the [Events] line and
  2507. * the Format line following. It shouldn't include any Dialogue line.
  2508. * - encoding: Set/allocated/freed by user (before avcodec_open2())
  2509. * - decoding: Set/allocated/freed by libavcodec (by avcodec_open2())
  2510. */
  2511. uint8_t *subtitle_header;
  2512. int subtitle_header_size;
  2513. #if FF_API_ERROR_RATE
  2514. /**
  2515. * @deprecated use the 'error_rate' private AVOption of the mpegvideo
  2516. * encoders
  2517. */
  2518. attribute_deprecated
  2519. int error_rate;
  2520. #endif
  2521. #if FF_API_CODEC_PKT
  2522. /**
  2523. * @deprecated this field is not supposed to be accessed from outside lavc
  2524. */
  2525. attribute_deprecated
  2526. AVPacket *pkt;
  2527. #endif
  2528. /**
  2529. * VBV delay coded in the last frame (in periods of a 27 MHz clock).
  2530. * Used for compliant TS muxing.
  2531. * - encoding: Set by libavcodec.
  2532. * - decoding: unused.
  2533. */
  2534. uint64_t vbv_delay;
  2535. /**
  2536. * Encoding only. Allow encoders to output packets that do not contain any
  2537. * encoded data, only side data.
  2538. *
  2539. * Some encoders need to output such packets, e.g. to update some stream
  2540. * parameters at the end of encoding.
  2541. *
  2542. * All callers are strongly recommended to set this option to 1 and update
  2543. * their code to deal with such packets, since this behaviour may become
  2544. * always enabled in the future (then this option will be deprecated and
  2545. * later removed). To avoid ABI issues when this happens, the callers should
  2546. * use AVOptions to set this field.
  2547. */
  2548. int side_data_only_packets;
  2549. /**
  2550. * Audio only. The number of "priming" samples (padding) inserted by the
  2551. * encoder at the beginning of the audio. I.e. this number of leading
  2552. * decoded samples must be discarded by the caller to get the original audio
  2553. * without leading padding.
  2554. *
  2555. * - decoding: unused
  2556. * - encoding: Set by libavcodec. The timestamps on the output packets are
  2557. * adjusted by the encoder so that they always refer to the
  2558. * first sample of the data actually contained in the packet,
  2559. * including any added padding. E.g. if the timebase is
  2560. * 1/samplerate and the timestamp of the first input sample is
  2561. * 0, the timestamp of the first output packet will be
  2562. * -initial_padding.
  2563. */
  2564. int initial_padding;
  2565. /*
  2566. * - decoding: For codecs that store a framerate value in the compressed
  2567. * bitstream, the decoder may export it here. { 0, 1} when
  2568. * unknown.
  2569. * - encoding: unused
  2570. */
  2571. AVRational framerate;
  2572. /**
  2573. * Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
  2574. * - encoding: unused.
  2575. * - decoding: Set by libavcodec before calling get_format()
  2576. */
  2577. enum AVPixelFormat sw_pix_fmt;
  2578. } AVCodecContext;
  2579. /**
  2580. * AVProfile.
  2581. */
  2582. typedef struct AVProfile {
  2583. int profile;
  2584. const char *name; ///< short name for the profile
  2585. } AVProfile;
  2586. typedef struct AVCodecDefault AVCodecDefault;
  2587. struct AVSubtitle;
  2588. /**
  2589. * AVCodec.
  2590. */
  2591. typedef struct AVCodec {
  2592. /**
  2593. * Name of the codec implementation.
  2594. * The name is globally unique among encoders and among decoders (but an
  2595. * encoder and a decoder can share the same name).
  2596. * This is the primary way to find a codec from the user perspective.
  2597. */
  2598. const char *name;
  2599. /**
  2600. * Descriptive name for the codec, meant to be more human readable than name.
  2601. * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
  2602. */
  2603. const char *long_name;
  2604. enum AVMediaType type;
  2605. enum AVCodecID id;
  2606. /**
  2607. * Codec capabilities.
  2608. * see CODEC_CAP_*
  2609. */
  2610. int capabilities;
  2611. const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
  2612. const enum AVPixelFormat *pix_fmts; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
  2613. const int *supported_samplerates; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
  2614. const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
  2615. const uint64_t *channel_layouts; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
  2616. #if FF_API_LOWRES
  2617. attribute_deprecated uint8_t max_lowres; ///< maximum value for lowres supported by the decoder
  2618. #endif
  2619. const AVClass *priv_class; ///< AVClass for the private context
  2620. const AVProfile *profiles; ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
  2621. /*****************************************************************
  2622. * No fields below this line are part of the public API. They
  2623. * may not be used outside of libavcodec and can be changed and
  2624. * removed at will.
  2625. * New public fields should be added right above.
  2626. *****************************************************************
  2627. */
  2628. int priv_data_size;
  2629. struct AVCodec *next;
  2630. /**
  2631. * @name Frame-level threading support functions
  2632. * @{
  2633. */
  2634. /**
  2635. * If defined, called on thread contexts when they are created.
  2636. * If the codec allocates writable tables in init(), re-allocate them here.
  2637. * priv_data will be set to a copy of the original.
  2638. */
  2639. int (*init_thread_copy)(AVCodecContext *);
  2640. /**
  2641. * Copy necessary context variables from a previous thread context to the current one.
  2642. * If not defined, the next thread will start automatically; otherwise, the codec
  2643. * must call ff_thread_finish_setup().
  2644. *
  2645. * dst and src will (rarely) point to the same context, in which case memcpy should be skipped.
  2646. */
  2647. int (*update_thread_context)(AVCodecContext *dst, const AVCodecContext *src);
  2648. /** @} */
  2649. /**
  2650. * Private codec-specific defaults.
  2651. */
  2652. const AVCodecDefault *defaults;
  2653. /**
  2654. * Initialize codec static data, called from avcodec_register().
  2655. */
  2656. void (*init_static_data)(struct AVCodec *codec);
  2657. int (*init)(AVCodecContext *);
  2658. int (*encode_sub)(AVCodecContext *, uint8_t *buf, int buf_size,
  2659. const struct AVSubtitle *sub);
  2660. /**
  2661. * Encode data to an AVPacket.
  2662. *
  2663. * @param avctx codec context
  2664. * @param avpkt output AVPacket (may contain a user-provided buffer)
  2665. * @param[in] frame AVFrame containing the raw data to be encoded
  2666. * @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a
  2667. * non-empty packet was returned in avpkt.
  2668. * @return 0 on success, negative error code on failure
  2669. */
  2670. int (*encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame,
  2671. int *got_packet_ptr);
  2672. int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt);
  2673. int (*close)(AVCodecContext *);
  2674. /**
  2675. * Flush buffers.
  2676. * Will be called when seeking
  2677. */
  2678. void (*flush)(AVCodecContext *);
  2679. } AVCodec;
  2680. /**
  2681. * @defgroup lavc_hwaccel AVHWAccel
  2682. * @{
  2683. */
  2684. typedef struct AVHWAccel {
  2685. /**
  2686. * Name of the hardware accelerated codec.
  2687. * The name is globally unique among encoders and among decoders (but an
  2688. * encoder and a decoder can share the same name).
  2689. */
  2690. const char *name;
  2691. /**
  2692. * Type of codec implemented by the hardware accelerator.
  2693. *
  2694. * See AVMEDIA_TYPE_xxx
  2695. */
  2696. enum AVMediaType type;
  2697. /**
  2698. * Codec implemented by the hardware accelerator.
  2699. *
  2700. * See AV_CODEC_ID_xxx
  2701. */
  2702. enum AVCodecID id;
  2703. /**
  2704. * Supported pixel format.
  2705. *
  2706. * Only hardware accelerated formats are supported here.
  2707. */
  2708. enum AVPixelFormat pix_fmt;
  2709. /**
  2710. * Hardware accelerated codec capabilities.
  2711. * see FF_HWACCEL_CODEC_CAP_*
  2712. */
  2713. int capabilities;
  2714. /*****************************************************************
  2715. * No fields below this line are part of the public API. They
  2716. * may not be used outside of libavcodec and can be changed and
  2717. * removed at will.
  2718. * New public fields should be added right above.
  2719. *****************************************************************
  2720. */
  2721. struct AVHWAccel *next;
  2722. /**
  2723. * Allocate a custom buffer
  2724. */
  2725. int (*alloc_frame)(AVCodecContext *avctx, AVFrame *frame);
  2726. /**
  2727. * Called at the beginning of each frame or field picture.
  2728. *
  2729. * Meaningful frame information (codec specific) is guaranteed to
  2730. * be parsed at this point. This function is mandatory.
  2731. *
  2732. * Note that buf can be NULL along with buf_size set to 0.
  2733. * Otherwise, this means the whole frame is available at this point.
  2734. *
  2735. * @param avctx the codec context
  2736. * @param buf the frame data buffer base
  2737. * @param buf_size the size of the frame in bytes
  2738. * @return zero if successful, a negative value otherwise
  2739. */
  2740. int (*start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);
  2741. /**
  2742. * Callback for each slice.
  2743. *
  2744. * Meaningful slice information (codec specific) is guaranteed to
  2745. * be parsed at this point. This function is mandatory.
  2746. *
  2747. * @param avctx the codec context
  2748. * @param buf the slice data buffer base
  2749. * @param buf_size the size of the slice in bytes
  2750. * @return zero if successful, a negative value otherwise
  2751. */
  2752. int (*decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);
  2753. /**
  2754. * Called at the end of each frame or field picture.
  2755. *
  2756. * The whole picture is parsed at this point and can now be sent
  2757. * to the hardware accelerator. This function is mandatory.
  2758. *
  2759. * @param avctx the codec context
  2760. * @return zero if successful, a negative value otherwise
  2761. */
  2762. int (*end_frame)(AVCodecContext *avctx);
  2763. /**
  2764. * Size of per-frame hardware accelerator private data.
  2765. *
  2766. * Private data is allocated with av_mallocz() before
  2767. * AVCodecContext.get_buffer() and deallocated after
  2768. * AVCodecContext.release_buffer().
  2769. */
  2770. int frame_priv_data_size;
  2771. /**
  2772. * Initialize the hwaccel private data.
  2773. *
  2774. * This will be called from ff_get_format(), after hwaccel and
  2775. * hwaccel_context are set and the hwaccel private data in AVCodecInternal
  2776. * is allocated.
  2777. */
  2778. int (*init)(AVCodecContext *avctx);
  2779. /**
  2780. * Uninitialize the hwaccel private data.
  2781. *
  2782. * This will be called from get_format() or avcodec_close(), after hwaccel
  2783. * and hwaccel_context are already uninitialized.
  2784. */
  2785. int (*uninit)(AVCodecContext *avctx);
  2786. /**
  2787. * Size of the private data to allocate in
  2788. * AVCodecInternal.hwaccel_priv_data.
  2789. */
  2790. int priv_data_size;
  2791. } AVHWAccel;
  2792. /**
  2793. * Hardware acceleration should be used for decoding even if the codec level
  2794. * used is unknown or higher than the maximum supported level reported by the
  2795. * hardware driver.
  2796. */
  2797. #define AV_HWACCEL_FLAG_IGNORE_LEVEL (1 << 0)
  2798. /**
  2799. * Hardware acceleration can output YUV pixel formats with a different chroma
  2800. * sampling than 4:2:0 and/or other than 8 bits per component.
  2801. */
  2802. #define AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH (1 << 1)
  2803. /**
  2804. * @}
  2805. */
  2806. /**
  2807. * @defgroup lavc_picture AVPicture
  2808. *
  2809. * Functions for working with AVPicture
  2810. * @{
  2811. */
  2812. /**
  2813. * four components are given, that's all.
  2814. * the last component is alpha
  2815. */
  2816. typedef struct AVPicture {
  2817. uint8_t *data[AV_NUM_DATA_POINTERS];
  2818. int linesize[AV_NUM_DATA_POINTERS]; ///< number of bytes per line
  2819. } AVPicture;
  2820. /**
  2821. * @}
  2822. */
  2823. #define AVPALETTE_SIZE 1024
  2824. #define AVPALETTE_COUNT 256
  2825. enum AVSubtitleType {
  2826. SUBTITLE_NONE,
  2827. SUBTITLE_BITMAP, ///< A bitmap, pict will be set
  2828. /**
  2829. * Plain text, the text field must be set by the decoder and is
  2830. * authoritative. ass and pict fields may contain approximations.
  2831. */
  2832. SUBTITLE_TEXT,
  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. #define AV_SUBTITLE_FLAG_FORCED 0x00000001
  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. * data+linesize for the bitmap of this subtitle.
  2848. * can be set for text/ass as well once they where rendered
  2849. */
  2850. AVPicture pict;
  2851. enum AVSubtitleType type;
  2852. char *text; ///< 0 terminated plain UTF-8 text
  2853. /**
  2854. * 0 terminated ASS/SSA compatible event line.
  2855. * The pressentation of this is unaffected by the other values in this
  2856. * struct.
  2857. */
  2858. char *ass;
  2859. int flags;
  2860. } AVSubtitleRect;
  2861. typedef struct AVSubtitle {
  2862. uint16_t format; /* 0 = graphics */
  2863. uint32_t start_display_time; /* relative to packet pts, in ms */
  2864. uint32_t end_display_time; /* relative to packet pts, in ms */
  2865. unsigned num_rects;
  2866. AVSubtitleRect **rects;
  2867. int64_t pts; ///< Same as packet pts, in AV_TIME_BASE
  2868. } AVSubtitle;
  2869. /**
  2870. * If c is NULL, returns the first registered codec,
  2871. * if c is non-NULL, returns the next registered codec after c,
  2872. * or NULL if c is the last one.
  2873. */
  2874. AVCodec *av_codec_next(const AVCodec *c);
  2875. /**
  2876. * Return the LIBAVCODEC_VERSION_INT constant.
  2877. */
  2878. unsigned avcodec_version(void);
  2879. /**
  2880. * Return the libavcodec build-time configuration.
  2881. */
  2882. const char *avcodec_configuration(void);
  2883. /**
  2884. * Return the libavcodec license.
  2885. */
  2886. const char *avcodec_license(void);
  2887. /**
  2888. * Register the codec codec and initialize libavcodec.
  2889. *
  2890. * @warning either this function or avcodec_register_all() must be called
  2891. * before any other libavcodec functions.
  2892. *
  2893. * @see avcodec_register_all()
  2894. */
  2895. void avcodec_register(AVCodec *codec);
  2896. /**
  2897. * Register all the codecs, parsers and bitstream filters which were enabled at
  2898. * configuration time. If you do not call this function you can select exactly
  2899. * which formats you want to support, by using the individual registration
  2900. * functions.
  2901. *
  2902. * @see avcodec_register
  2903. * @see av_register_codec_parser
  2904. * @see av_register_bitstream_filter
  2905. */
  2906. void avcodec_register_all(void);
  2907. /**
  2908. * Allocate an AVCodecContext and set its fields to default values. The
  2909. * resulting struct should be freed with avcodec_free_context().
  2910. *
  2911. * @param codec if non-NULL, allocate private data and initialize defaults
  2912. * for the given codec. It is illegal to then call avcodec_open2()
  2913. * with a different codec.
  2914. * If NULL, then the codec-specific defaults won't be initialized,
  2915. * which may result in suboptimal default settings (this is
  2916. * important mainly for encoders, e.g. libx264).
  2917. *
  2918. * @return An AVCodecContext filled with default values or NULL on failure.
  2919. * @see avcodec_get_context_defaults
  2920. */
  2921. AVCodecContext *avcodec_alloc_context3(const AVCodec *codec);
  2922. /**
  2923. * Free the codec context and everything associated with it and write NULL to
  2924. * the provided pointer.
  2925. */
  2926. void avcodec_free_context(AVCodecContext **avctx);
  2927. /**
  2928. * Set the fields of the given AVCodecContext to default values corresponding
  2929. * to the given codec (defaults may be codec-dependent).
  2930. *
  2931. * Do not call this function if a non-NULL codec has been passed
  2932. * to avcodec_alloc_context3() that allocated this AVCodecContext.
  2933. * If codec is non-NULL, it is illegal to call avcodec_open2() with a
  2934. * different codec on this AVCodecContext.
  2935. */
  2936. int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec);
  2937. /**
  2938. * Get the AVClass for AVCodecContext. It can be used in combination with
  2939. * AV_OPT_SEARCH_FAKE_OBJ for examining options.
  2940. *
  2941. * @see av_opt_find().
  2942. */
  2943. const AVClass *avcodec_get_class(void);
  2944. /**
  2945. * Copy the settings of the source AVCodecContext into the destination
  2946. * AVCodecContext. The resulting destination codec context will be
  2947. * unopened, i.e. you are required to call avcodec_open2() before you
  2948. * can use this AVCodecContext to decode/encode video/audio data.
  2949. *
  2950. * @param dest target codec context, should be initialized with
  2951. * avcodec_alloc_context3(), but otherwise uninitialized
  2952. * @param src source codec context
  2953. * @return AVERROR() on error (e.g. memory allocation error), 0 on success
  2954. */
  2955. int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src);
  2956. #if FF_API_AVFRAME_LAVC
  2957. /**
  2958. * @deprecated use av_frame_alloc()
  2959. */
  2960. attribute_deprecated
  2961. AVFrame *avcodec_alloc_frame(void);
  2962. /**
  2963. * Set the fields of the given AVFrame to default values.
  2964. *
  2965. * @param frame The AVFrame of which the fields should be set to default values.
  2966. *
  2967. * @deprecated use av_frame_unref()
  2968. */
  2969. attribute_deprecated
  2970. void avcodec_get_frame_defaults(AVFrame *frame);
  2971. /**
  2972. * Free the frame and any dynamically allocated objects in it,
  2973. * e.g. extended_data.
  2974. *
  2975. * @param frame frame to be freed. The pointer will be set to NULL.
  2976. *
  2977. * @warning this function does NOT free the data buffers themselves
  2978. * (it does not know how, since they might have been allocated with
  2979. * a custom get_buffer()).
  2980. *
  2981. * @deprecated use av_frame_free()
  2982. */
  2983. attribute_deprecated
  2984. void avcodec_free_frame(AVFrame **frame);
  2985. #endif
  2986. /**
  2987. * Initialize the AVCodecContext to use the given AVCodec. Prior to using this
  2988. * function the context has to be allocated with avcodec_alloc_context3().
  2989. *
  2990. * The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(),
  2991. * avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for
  2992. * retrieving a codec.
  2993. *
  2994. * @warning This function is not thread safe!
  2995. *
  2996. * @note Always call this function before using decoding routines (such as
  2997. * @ref avcodec_decode_video2()).
  2998. *
  2999. * @code
  3000. * avcodec_register_all();
  3001. * av_dict_set(&opts, "b", "2.5M", 0);
  3002. * codec = avcodec_find_decoder(AV_CODEC_ID_H264);
  3003. * if (!codec)
  3004. * exit(1);
  3005. *
  3006. * context = avcodec_alloc_context3(codec);
  3007. *
  3008. * if (avcodec_open2(context, codec, opts) < 0)
  3009. * exit(1);
  3010. * @endcode
  3011. *
  3012. * @param avctx The context to initialize.
  3013. * @param codec The codec to open this context for. If a non-NULL codec has been
  3014. * previously passed to avcodec_alloc_context3() or
  3015. * avcodec_get_context_defaults3() for this context, then this
  3016. * parameter MUST be either NULL or equal to the previously passed
  3017. * codec.
  3018. * @param options A dictionary filled with AVCodecContext and codec-private options.
  3019. * On return this object will be filled with options that were not found.
  3020. *
  3021. * @return zero on success, a negative value on error
  3022. * @see avcodec_alloc_context3(), avcodec_find_decoder(), avcodec_find_encoder(),
  3023. * av_dict_set(), av_opt_find().
  3024. */
  3025. int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);
  3026. /**
  3027. * Close a given AVCodecContext and free all the data associated with it
  3028. * (but not the AVCodecContext itself).
  3029. *
  3030. * Calling this function on an AVCodecContext that hasn't been opened will free
  3031. * the codec-specific data allocated in avcodec_alloc_context3() /
  3032. * avcodec_get_context_defaults3() with a non-NULL codec. Subsequent calls will
  3033. * do nothing.
  3034. */
  3035. int avcodec_close(AVCodecContext *avctx);
  3036. /**
  3037. * Free all allocated data in the given subtitle struct.
  3038. *
  3039. * @param sub AVSubtitle to free.
  3040. */
  3041. void avsubtitle_free(AVSubtitle *sub);
  3042. /**
  3043. * @}
  3044. */
  3045. /**
  3046. * @addtogroup lavc_packet
  3047. * @{
  3048. */
  3049. #if FF_API_DESTRUCT_PACKET
  3050. /**
  3051. * Default packet destructor.
  3052. * @deprecated use the AVBuffer API instead
  3053. */
  3054. attribute_deprecated
  3055. void av_destruct_packet(AVPacket *pkt);
  3056. #endif
  3057. /**
  3058. * Initialize optional fields of a packet with default values.
  3059. *
  3060. * Note, this does not touch the data and size members, which have to be
  3061. * initialized separately.
  3062. *
  3063. * @param pkt packet
  3064. */
  3065. void av_init_packet(AVPacket *pkt);
  3066. /**
  3067. * Allocate the payload of a packet and initialize its fields with
  3068. * default values.
  3069. *
  3070. * @param pkt packet
  3071. * @param size wanted payload size
  3072. * @return 0 if OK, AVERROR_xxx otherwise
  3073. */
  3074. int av_new_packet(AVPacket *pkt, int size);
  3075. /**
  3076. * Reduce packet size, correctly zeroing padding
  3077. *
  3078. * @param pkt packet
  3079. * @param size new size
  3080. */
  3081. void av_shrink_packet(AVPacket *pkt, int size);
  3082. /**
  3083. * Increase packet size, correctly zeroing padding
  3084. *
  3085. * @param pkt packet
  3086. * @param grow_by number of bytes by which to increase the size of the packet
  3087. */
  3088. int av_grow_packet(AVPacket *pkt, int grow_by);
  3089. /**
  3090. * Initialize a reference-counted packet from av_malloc()ed data.
  3091. *
  3092. * @param pkt packet to be initialized. This function will set the data, size,
  3093. * buf and destruct fields, all others are left untouched.
  3094. * @param data Data allocated by av_malloc() to be used as packet data. If this
  3095. * function returns successfully, the data is owned by the underlying AVBuffer.
  3096. * The caller may not access the data through other means.
  3097. * @param size size of data in bytes, without the padding. I.e. the full buffer
  3098. * size is assumed to be size + FF_INPUT_BUFFER_PADDING_SIZE.
  3099. *
  3100. * @return 0 on success, a negative AVERROR on error
  3101. */
  3102. int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);
  3103. /**
  3104. * @warning This is a hack - the packet memory allocation stuff is broken. The
  3105. * packet is allocated if it was not really allocated.
  3106. */
  3107. int av_dup_packet(AVPacket *pkt);
  3108. /**
  3109. * Free a packet.
  3110. *
  3111. * @param pkt packet to free
  3112. */
  3113. void av_free_packet(AVPacket *pkt);
  3114. /**
  3115. * Allocate new information of a packet.
  3116. *
  3117. * @param pkt packet
  3118. * @param type side information type
  3119. * @param size side information size
  3120. * @return pointer to fresh allocated data or NULL otherwise
  3121. */
  3122. uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
  3123. int size);
  3124. /**
  3125. * Shrink the already allocated side data buffer
  3126. *
  3127. * @param pkt packet
  3128. * @param type side information type
  3129. * @param size new side information size
  3130. * @return 0 on success, < 0 on failure
  3131. */
  3132. int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
  3133. int size);
  3134. /**
  3135. * Get side information from packet.
  3136. *
  3137. * @param pkt packet
  3138. * @param type desired side information type
  3139. * @param size pointer for side information size to store (optional)
  3140. * @return pointer to data if present or NULL otherwise
  3141. */
  3142. uint8_t* av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
  3143. int *size);
  3144. /**
  3145. * Convenience function to free all the side data stored.
  3146. * All the other fields stay untouched.
  3147. *
  3148. * @param pkt packet
  3149. */
  3150. void av_packet_free_side_data(AVPacket *pkt);
  3151. /**
  3152. * Setup a new reference to the data described by a given packet
  3153. *
  3154. * If src is reference-counted, setup dst as a new reference to the
  3155. * buffer in src. Otherwise allocate a new buffer in dst and copy the
  3156. * data from src into it.
  3157. *
  3158. * All the other fields are copied from src.
  3159. *
  3160. * @see av_packet_unref
  3161. *
  3162. * @param dst Destination packet
  3163. * @param src Source packet
  3164. *
  3165. * @return 0 on success, a negative AVERROR on error.
  3166. */
  3167. int av_packet_ref(AVPacket *dst, AVPacket *src);
  3168. /**
  3169. * Wipe the packet.
  3170. *
  3171. * Unreference the buffer referenced by the packet and reset the
  3172. * remaining packet fields to their default values.
  3173. *
  3174. * @param pkt The packet to be unreferenced.
  3175. */
  3176. void av_packet_unref(AVPacket *pkt);
  3177. /**
  3178. * Move every field in src to dst and reset src.
  3179. *
  3180. * @see av_packet_unref
  3181. *
  3182. * @param src Source packet, will be reset
  3183. * @param dst Destination packet
  3184. */
  3185. void av_packet_move_ref(AVPacket *dst, AVPacket *src);
  3186. /**
  3187. * Copy only "properties" fields from src to dst.
  3188. *
  3189. * Properties for the purpose of this function are all the fields
  3190. * beside those related to the packet data (buf, data, size)
  3191. *
  3192. * @param dst Destination packet
  3193. * @param src Source packet
  3194. *
  3195. * @return 0 on success AVERROR on failure.
  3196. *
  3197. */
  3198. int av_packet_copy_props(AVPacket *dst, const AVPacket *src);
  3199. /**
  3200. * Convert valid timing fields (timestamps / durations) in a packet from one
  3201. * timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be
  3202. * ignored.
  3203. *
  3204. * @param pkt packet on which the conversion will be performed
  3205. * @param tb_src source timebase, in which the timing fields in pkt are
  3206. * expressed
  3207. * @param tb_dst destination timebase, to which the timing fields will be
  3208. * converted
  3209. */
  3210. void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst);
  3211. /**
  3212. * @}
  3213. */
  3214. /**
  3215. * @addtogroup lavc_decoding
  3216. * @{
  3217. */
  3218. /**
  3219. * Find a registered decoder with a matching codec ID.
  3220. *
  3221. * @param id AVCodecID of the requested decoder
  3222. * @return A decoder if one was found, NULL otherwise.
  3223. */
  3224. AVCodec *avcodec_find_decoder(enum AVCodecID id);
  3225. /**
  3226. * Find a registered decoder with the specified name.
  3227. *
  3228. * @param name name of the requested decoder
  3229. * @return A decoder if one was found, NULL otherwise.
  3230. */
  3231. AVCodec *avcodec_find_decoder_by_name(const char *name);
  3232. #if FF_API_GET_BUFFER
  3233. attribute_deprecated int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic);
  3234. attribute_deprecated void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic);
  3235. attribute_deprecated int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic);
  3236. #endif
  3237. /**
  3238. * The default callback for AVCodecContext.get_buffer2(). It is made public so
  3239. * it can be called by custom get_buffer2() implementations for decoders without
  3240. * CODEC_CAP_DR1 set.
  3241. */
  3242. int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags);
  3243. #if FF_API_EMU_EDGE
  3244. /**
  3245. * Return the amount of padding in pixels which the get_buffer callback must
  3246. * provide around the edge of the image for codecs which do not have the
  3247. * CODEC_FLAG_EMU_EDGE flag.
  3248. *
  3249. * @return Required padding in pixels.
  3250. *
  3251. * @deprecated CODEC_FLAG_EMU_EDGE is deprecated, so this function is no longer
  3252. * needed
  3253. */
  3254. attribute_deprecated
  3255. unsigned avcodec_get_edge_width(void);
  3256. #endif
  3257. /**
  3258. * Modify width and height values so that they will result in a memory
  3259. * buffer that is acceptable for the codec if you do not use any horizontal
  3260. * padding.
  3261. *
  3262. * May only be used if a codec with CODEC_CAP_DR1 has been opened.
  3263. */
  3264. void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height);
  3265. /**
  3266. * Modify width and height values so that they will result in a memory
  3267. * buffer that is acceptable for the codec if you also ensure that all
  3268. * line sizes are a multiple of the respective linesize_align[i].
  3269. *
  3270. * May only be used if a codec with CODEC_CAP_DR1 has been opened.
  3271. */
  3272. void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
  3273. int linesize_align[AV_NUM_DATA_POINTERS]);
  3274. /**
  3275. * Decode the audio frame of size avpkt->size from avpkt->data into frame.
  3276. *
  3277. * Some decoders may support multiple frames in a single AVPacket. Such
  3278. * decoders would then just decode the first frame and the return value would be
  3279. * less than the packet size. In this case, avcodec_decode_audio4 has to be
  3280. * called again with an AVPacket containing the remaining data in order to
  3281. * decode the second frame, etc... Even if no frames are returned, the packet
  3282. * needs to be fed to the decoder with remaining data until it is completely
  3283. * consumed or an error occurs.
  3284. *
  3285. * Some decoders (those marked with CODEC_CAP_DELAY) have a delay between input
  3286. * and output. This means that for some packets they will not immediately
  3287. * produce decoded output and need to be flushed at the end of decoding to get
  3288. * all the decoded data. Flushing is done by calling this function with packets
  3289. * with avpkt->data set to NULL and avpkt->size set to 0 until it stops
  3290. * returning samples. It is safe to flush even those decoders that are not
  3291. * marked with CODEC_CAP_DELAY, then no samples will be returned.
  3292. *
  3293. * @warning The input buffer, avpkt->data must be FF_INPUT_BUFFER_PADDING_SIZE
  3294. * larger than the actual read bytes because some optimized bitstream
  3295. * readers read 32 or 64 bits at once and could read over the end.
  3296. *
  3297. * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
  3298. * before packets may be fed to the decoder.
  3299. *
  3300. * @param avctx the codec context
  3301. * @param[out] frame The AVFrame in which to store decoded audio samples.
  3302. * The decoder will allocate a buffer for the decoded frame by
  3303. * calling the AVCodecContext.get_buffer2() callback.
  3304. * When AVCodecContext.refcounted_frames is set to 1, the frame is
  3305. * reference counted and the returned reference belongs to the
  3306. * caller. The caller must release the frame using av_frame_unref()
  3307. * when the frame is no longer needed. The caller may safely write
  3308. * to the frame if av_frame_is_writable() returns 1.
  3309. * When AVCodecContext.refcounted_frames is set to 0, the returned
  3310. * reference belongs to the decoder and is valid only until the
  3311. * next call to this function or until closing or flushing the
  3312. * decoder. The caller may not write to it.
  3313. * @param[out] got_frame_ptr Zero if no frame could be decoded, otherwise it is
  3314. * non-zero. Note that this field being set to zero
  3315. * does not mean that an error has occurred. For
  3316. * decoders with CODEC_CAP_DELAY set, no given decode
  3317. * call is guaranteed to produce a frame.
  3318. * @param[in] avpkt The input AVPacket containing the input buffer.
  3319. * At least avpkt->data and avpkt->size should be set. Some
  3320. * decoders might also require additional fields to be set.
  3321. * @return A negative error code is returned if an error occurred during
  3322. * decoding, otherwise the number of bytes consumed from the input
  3323. * AVPacket is returned.
  3324. */
  3325. int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame,
  3326. int *got_frame_ptr, AVPacket *avpkt);
  3327. /**
  3328. * Decode the video frame of size avpkt->size from avpkt->data into picture.
  3329. * Some decoders may support multiple frames in a single AVPacket, such
  3330. * decoders would then just decode the first frame.
  3331. *
  3332. * @warning The input buffer must be FF_INPUT_BUFFER_PADDING_SIZE larger than
  3333. * the actual read bytes because some optimized bitstream readers read 32 or 64
  3334. * bits at once and could read over the end.
  3335. *
  3336. * @warning The end of the input buffer buf should be set to 0 to ensure that
  3337. * no overreading happens for damaged MPEG streams.
  3338. *
  3339. * @note Codecs which have the CODEC_CAP_DELAY capability set have a delay
  3340. * between input and output, these need to be fed with avpkt->data=NULL,
  3341. * avpkt->size=0 at the end to return the remaining frames.
  3342. *
  3343. * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
  3344. * before packets may be fed to the decoder.
  3345. *
  3346. * @param avctx the codec context
  3347. * @param[out] picture The AVFrame in which the decoded video frame will be stored.
  3348. * Use av_frame_alloc() to get an AVFrame. The codec will
  3349. * allocate memory for the actual bitmap by calling the
  3350. * AVCodecContext.get_buffer2() callback.
  3351. * When AVCodecContext.refcounted_frames is set to 1, the frame is
  3352. * reference counted and the returned reference belongs to the
  3353. * caller. The caller must release the frame using av_frame_unref()
  3354. * when the frame is no longer needed. The caller may safely write
  3355. * to the frame if av_frame_is_writable() returns 1.
  3356. * When AVCodecContext.refcounted_frames is set to 0, the returned
  3357. * reference belongs to the decoder and is valid only until the
  3358. * next call to this function or until closing or flushing the
  3359. * decoder. The caller may not write to it.
  3360. *
  3361. * @param[in] avpkt The input AVpacket containing the input buffer.
  3362. * You can create such packet with av_init_packet() and by then setting
  3363. * data and size, some decoders might in addition need other fields like
  3364. * flags&AV_PKT_FLAG_KEY. All decoders are designed to use the least
  3365. * fields possible.
  3366. * @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero.
  3367. * @return On error a negative value is returned, otherwise the number of bytes
  3368. * used or zero if no frame could be decompressed.
  3369. */
  3370. int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
  3371. int *got_picture_ptr,
  3372. AVPacket *avpkt);
  3373. /**
  3374. * Decode a subtitle message.
  3375. * Return a negative value on error, otherwise return the number of bytes used.
  3376. * If no subtitle could be decompressed, got_sub_ptr is zero.
  3377. * Otherwise, the subtitle is stored in *sub.
  3378. * Note that CODEC_CAP_DR1 is not available for subtitle codecs. This is for
  3379. * simplicity, because the performance difference is expect to be negligible
  3380. * and reusing a get_buffer written for video codecs would probably perform badly
  3381. * due to a potentially very different allocation pattern.
  3382. *
  3383. * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
  3384. * before packets may be fed to the decoder.
  3385. *
  3386. * @param avctx the codec context
  3387. * @param[out] sub The AVSubtitle in which the decoded subtitle will be stored, must be
  3388. freed with avsubtitle_free if *got_sub_ptr is set.
  3389. * @param[in,out] got_sub_ptr Zero if no subtitle could be decompressed, otherwise, it is nonzero.
  3390. * @param[in] avpkt The input AVPacket containing the input buffer.
  3391. */
  3392. int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
  3393. int *got_sub_ptr,
  3394. AVPacket *avpkt);
  3395. /**
  3396. * @defgroup lavc_parsing Frame parsing
  3397. * @{
  3398. */
  3399. enum AVPictureStructure {
  3400. AV_PICTURE_STRUCTURE_UNKNOWN, //< unknown
  3401. AV_PICTURE_STRUCTURE_TOP_FIELD, //< coded as top field
  3402. AV_PICTURE_STRUCTURE_BOTTOM_FIELD, //< coded as bottom field
  3403. AV_PICTURE_STRUCTURE_FRAME, //< coded as frame
  3404. };
  3405. typedef struct AVCodecParserContext {
  3406. void *priv_data;
  3407. struct AVCodecParser *parser;
  3408. int64_t frame_offset; /* offset of the current frame */
  3409. int64_t cur_offset; /* current offset
  3410. (incremented by each av_parser_parse()) */
  3411. int64_t next_frame_offset; /* offset of the next frame */
  3412. /* video info */
  3413. int pict_type; /* XXX: Put it back in AVCodecContext. */
  3414. /**
  3415. * This field is used for proper frame duration computation in lavf.
  3416. * It signals, how much longer the frame duration of the current frame
  3417. * is compared to normal frame duration.
  3418. *
  3419. * frame_duration = (1 + repeat_pict) * time_base
  3420. *
  3421. * It is used by codecs like H.264 to display telecined material.
  3422. */
  3423. int repeat_pict; /* XXX: Put it back in AVCodecContext. */
  3424. int64_t pts; /* pts of the current frame */
  3425. int64_t dts; /* dts of the current frame */
  3426. /* private data */
  3427. int64_t last_pts;
  3428. int64_t last_dts;
  3429. int fetch_timestamp;
  3430. #define AV_PARSER_PTS_NB 4
  3431. int cur_frame_start_index;
  3432. int64_t cur_frame_offset[AV_PARSER_PTS_NB];
  3433. int64_t cur_frame_pts[AV_PARSER_PTS_NB];
  3434. int64_t cur_frame_dts[AV_PARSER_PTS_NB];
  3435. int flags;
  3436. #define PARSER_FLAG_COMPLETE_FRAMES 0x0001
  3437. #define PARSER_FLAG_ONCE 0x0002
  3438. /// Set if the parser has a valid file offset
  3439. #define PARSER_FLAG_FETCHED_OFFSET 0x0004
  3440. int64_t offset; ///< byte offset from starting packet start
  3441. int64_t cur_frame_end[AV_PARSER_PTS_NB];
  3442. /**
  3443. * Set by parser to 1 for key frames and 0 for non-key frames.
  3444. * It is initialized to -1, so if the parser doesn't set this flag,
  3445. * old-style fallback using AV_PICTURE_TYPE_I picture type as key frames
  3446. * will be used.
  3447. */
  3448. int key_frame;
  3449. /**
  3450. * Time difference in stream time base units from the pts of this
  3451. * packet to the point at which the output from the decoder has converged
  3452. * independent from the availability of previous frames. That is, the
  3453. * frames are virtually identical no matter if decoding started from
  3454. * the very first frame or from this keyframe.
  3455. * Is AV_NOPTS_VALUE if unknown.
  3456. * This field is not the display duration of the current frame.
  3457. * This field has no meaning if the packet does not have AV_PKT_FLAG_KEY
  3458. * set.
  3459. *
  3460. * The purpose of this field is to allow seeking in streams that have no
  3461. * keyframes in the conventional sense. It corresponds to the
  3462. * recovery point SEI in H.264 and match_time_delta in NUT. It is also
  3463. * essential for some types of subtitle streams to ensure that all
  3464. * subtitles are correctly displayed after seeking.
  3465. */
  3466. int64_t convergence_duration;
  3467. // Timestamp generation support:
  3468. /**
  3469. * Synchronization point for start of timestamp generation.
  3470. *
  3471. * Set to >0 for sync point, 0 for no sync point and <0 for undefined
  3472. * (default).
  3473. *
  3474. * For example, this corresponds to presence of H.264 buffering period
  3475. * SEI message.
  3476. */
  3477. int dts_sync_point;
  3478. /**
  3479. * Offset of the current timestamp against last timestamp sync point in
  3480. * units of AVCodecContext.time_base.
  3481. *
  3482. * Set to INT_MIN when dts_sync_point unused. Otherwise, it must
  3483. * contain a valid timestamp offset.
  3484. *
  3485. * Note that the timestamp of sync point has usually a nonzero
  3486. * dts_ref_dts_delta, which refers to the previous sync point. Offset of
  3487. * the next frame after timestamp sync point will be usually 1.
  3488. *
  3489. * For example, this corresponds to H.264 cpb_removal_delay.
  3490. */
  3491. int dts_ref_dts_delta;
  3492. /**
  3493. * Presentation delay of current frame in units of AVCodecContext.time_base.
  3494. *
  3495. * Set to INT_MIN when dts_sync_point unused. Otherwise, it must
  3496. * contain valid non-negative timestamp delta (presentation time of a frame
  3497. * must not lie in the past).
  3498. *
  3499. * This delay represents the difference between decoding and presentation
  3500. * time of the frame.
  3501. *
  3502. * For example, this corresponds to H.264 dpb_output_delay.
  3503. */
  3504. int pts_dts_delta;
  3505. /**
  3506. * Position of the packet in file.
  3507. *
  3508. * Analogous to cur_frame_pts/dts
  3509. */
  3510. int64_t cur_frame_pos[AV_PARSER_PTS_NB];
  3511. /**
  3512. * Byte position of currently parsed frame in stream.
  3513. */
  3514. int64_t pos;
  3515. /**
  3516. * Previous frame byte position.
  3517. */
  3518. int64_t last_pos;
  3519. /**
  3520. * Duration of the current frame.
  3521. * For audio, this is in units of 1 / AVCodecContext.sample_rate.
  3522. * For all other types, this is in units of AVCodecContext.time_base.
  3523. */
  3524. int duration;
  3525. enum AVFieldOrder field_order;
  3526. /**
  3527. * Indicate whether a picture is coded as a frame, top field or bottom field.
  3528. *
  3529. * For example, H.264 field_pic_flag equal to 0 corresponds to
  3530. * AV_PICTURE_STRUCTURE_FRAME. An H.264 picture with field_pic_flag
  3531. * equal to 1 and bottom_field_flag equal to 0 corresponds to
  3532. * AV_PICTURE_STRUCTURE_TOP_FIELD.
  3533. */
  3534. enum AVPictureStructure picture_structure;
  3535. /**
  3536. * Picture number incremented in presentation or output order.
  3537. * This field may be reinitialized at the first picture of a new sequence.
  3538. *
  3539. * For example, this corresponds to H.264 PicOrderCnt.
  3540. */
  3541. int output_picture_number;
  3542. /**
  3543. * Dimensions of the decoded video intended for presentation.
  3544. */
  3545. int width;
  3546. int height;
  3547. /**
  3548. * Dimensions of the coded video.
  3549. */
  3550. int coded_width;
  3551. int coded_height;
  3552. /**
  3553. * The format of the coded data, corresponds to enum AVPixelFormat for video
  3554. * and for enum AVSampleFormat for audio.
  3555. *
  3556. * Note that a decoder can have considerable freedom in how exactly it
  3557. * decodes the data, so the format reported here might be different from the
  3558. * one returned by a decoder.
  3559. */
  3560. int format;
  3561. } AVCodecParserContext;
  3562. typedef struct AVCodecParser {
  3563. int codec_ids[5]; /* several codec IDs are permitted */
  3564. int priv_data_size;
  3565. int (*parser_init)(AVCodecParserContext *s);
  3566. /* This callback never returns an error, a negative value means that
  3567. * the frame start was in a previous packet. */
  3568. int (*parser_parse)(AVCodecParserContext *s,
  3569. AVCodecContext *avctx,
  3570. const uint8_t **poutbuf, int *poutbuf_size,
  3571. const uint8_t *buf, int buf_size);
  3572. void (*parser_close)(AVCodecParserContext *s);
  3573. int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size);
  3574. struct AVCodecParser *next;
  3575. } AVCodecParser;
  3576. AVCodecParser *av_parser_next(const AVCodecParser *c);
  3577. void av_register_codec_parser(AVCodecParser *parser);
  3578. AVCodecParserContext *av_parser_init(int codec_id);
  3579. /**
  3580. * Parse a packet.
  3581. *
  3582. * @param s parser context.
  3583. * @param avctx codec context.
  3584. * @param poutbuf set to pointer to parsed buffer or NULL if not yet finished.
  3585. * @param poutbuf_size set to size of parsed buffer or zero if not yet finished.
  3586. * @param buf input buffer.
  3587. * @param buf_size input length, to signal EOF, this should be 0 (so that the last frame can be output).
  3588. * @param pts input presentation timestamp.
  3589. * @param dts input decoding timestamp.
  3590. * @param pos input byte position in stream.
  3591. * @return the number of bytes of the input bitstream used.
  3592. *
  3593. * Example:
  3594. * @code
  3595. * while(in_len){
  3596. * len = av_parser_parse2(myparser, AVCodecContext, &data, &size,
  3597. * in_data, in_len,
  3598. * pts, dts, pos);
  3599. * in_data += len;
  3600. * in_len -= len;
  3601. *
  3602. * if(size)
  3603. * decode_frame(data, size);
  3604. * }
  3605. * @endcode
  3606. */
  3607. int av_parser_parse2(AVCodecParserContext *s,
  3608. AVCodecContext *avctx,
  3609. uint8_t **poutbuf, int *poutbuf_size,
  3610. const uint8_t *buf, int buf_size,
  3611. int64_t pts, int64_t dts,
  3612. int64_t pos);
  3613. /**
  3614. * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
  3615. * @deprecated use AVBitstreamFilter
  3616. */
  3617. int av_parser_change(AVCodecParserContext *s,
  3618. AVCodecContext *avctx,
  3619. uint8_t **poutbuf, int *poutbuf_size,
  3620. const uint8_t *buf, int buf_size, int keyframe);
  3621. void av_parser_close(AVCodecParserContext *s);
  3622. /**
  3623. * @}
  3624. * @}
  3625. */
  3626. /**
  3627. * @addtogroup lavc_encoding
  3628. * @{
  3629. */
  3630. /**
  3631. * Find a registered encoder with a matching codec ID.
  3632. *
  3633. * @param id AVCodecID of the requested encoder
  3634. * @return An encoder if one was found, NULL otherwise.
  3635. */
  3636. AVCodec *avcodec_find_encoder(enum AVCodecID id);
  3637. /**
  3638. * Find a registered encoder with the specified name.
  3639. *
  3640. * @param name name of the requested encoder
  3641. * @return An encoder if one was found, NULL otherwise.
  3642. */
  3643. AVCodec *avcodec_find_encoder_by_name(const char *name);
  3644. /**
  3645. * Encode a frame of audio.
  3646. *
  3647. * Takes input samples from frame and writes the next output packet, if
  3648. * available, to avpkt. The output packet does not necessarily contain data for
  3649. * the most recent frame, as encoders can delay, split, and combine input frames
  3650. * internally as needed.
  3651. *
  3652. * @param avctx codec context
  3653. * @param avpkt output AVPacket.
  3654. * The user can supply an output buffer by setting
  3655. * avpkt->data and avpkt->size prior to calling the
  3656. * function, but if the size of the user-provided data is not
  3657. * large enough, encoding will fail. All other AVPacket fields
  3658. * will be reset by the encoder using av_init_packet(). If
  3659. * avpkt->data is NULL, the encoder will allocate it.
  3660. * The encoder will set avpkt->size to the size of the
  3661. * output packet.
  3662. *
  3663. * If this function fails or produces no output, avpkt will be
  3664. * freed using av_free_packet() (i.e. avpkt->destruct will be
  3665. * called to free the user supplied buffer).
  3666. * @param[in] frame AVFrame containing the raw audio data to be encoded.
  3667. * May be NULL when flushing an encoder that has the
  3668. * CODEC_CAP_DELAY capability set.
  3669. * If CODEC_CAP_VARIABLE_FRAME_SIZE is set, then each frame
  3670. * can have any number of samples.
  3671. * If it is not set, frame->nb_samples must be equal to
  3672. * avctx->frame_size for all frames except the last.
  3673. * The final frame may be smaller than avctx->frame_size.
  3674. * @param[out] got_packet_ptr This field is set to 1 by libavcodec if the
  3675. * output packet is non-empty, and to 0 if it is
  3676. * empty. If the function returns an error, the
  3677. * packet can be assumed to be invalid, and the
  3678. * value of got_packet_ptr is undefined and should
  3679. * not be used.
  3680. * @return 0 on success, negative error code on failure
  3681. */
  3682. int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt,
  3683. const AVFrame *frame, int *got_packet_ptr);
  3684. /**
  3685. * Encode a frame of video.
  3686. *
  3687. * Takes input raw video data from frame and writes the next output packet, if
  3688. * available, to avpkt. The output packet does not necessarily contain data for
  3689. * the most recent frame, as encoders can delay and reorder input frames
  3690. * internally as needed.
  3691. *
  3692. * @param avctx codec context
  3693. * @param avpkt output AVPacket.
  3694. * The user can supply an output buffer by setting
  3695. * avpkt->data and avpkt->size prior to calling the
  3696. * function, but if the size of the user-provided data is not
  3697. * large enough, encoding will fail. All other AVPacket fields
  3698. * will be reset by the encoder using av_init_packet(). If
  3699. * avpkt->data is NULL, the encoder will allocate it.
  3700. * The encoder will set avpkt->size to the size of the
  3701. * output packet. The returned data (if any) belongs to the
  3702. * caller, he is responsible for freeing it.
  3703. *
  3704. * If this function fails or produces no output, avpkt will be
  3705. * freed using av_free_packet() (i.e. avpkt->destruct will be
  3706. * called to free the user supplied buffer).
  3707. * @param[in] frame AVFrame containing the raw video data to be encoded.
  3708. * May be NULL when flushing an encoder that has the
  3709. * CODEC_CAP_DELAY capability set.
  3710. * @param[out] got_packet_ptr This field is set to 1 by libavcodec if the
  3711. * output packet is non-empty, and to 0 if it is
  3712. * empty. If the function returns an error, the
  3713. * packet can be assumed to be invalid, and the
  3714. * value of got_packet_ptr is undefined and should
  3715. * not be used.
  3716. * @return 0 on success, negative error code on failure
  3717. */
  3718. int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt,
  3719. const AVFrame *frame, int *got_packet_ptr);
  3720. int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
  3721. const AVSubtitle *sub);
  3722. /**
  3723. * @}
  3724. */
  3725. /**
  3726. * @addtogroup lavc_picture
  3727. * @{
  3728. */
  3729. /**
  3730. * Allocate memory for a picture. Call avpicture_free() to free it.
  3731. *
  3732. * @see avpicture_fill()
  3733. *
  3734. * @param picture the picture to be filled in
  3735. * @param pix_fmt the format of the picture
  3736. * @param width the width of the picture
  3737. * @param height the height of the picture
  3738. * @return zero if successful, a negative value if not
  3739. */
  3740. int avpicture_alloc(AVPicture *picture, enum AVPixelFormat pix_fmt, int width, int height);
  3741. /**
  3742. * Free a picture previously allocated by avpicture_alloc().
  3743. * The data buffer used by the AVPicture is freed, but the AVPicture structure
  3744. * itself is not.
  3745. *
  3746. * @param picture the AVPicture to be freed
  3747. */
  3748. void avpicture_free(AVPicture *picture);
  3749. /**
  3750. * Fill in the AVPicture fields, always assume a linesize alignment of 1.
  3751. *
  3752. * @see av_image_fill_arrays().
  3753. */
  3754. int avpicture_fill(AVPicture *picture, uint8_t *ptr,
  3755. enum AVPixelFormat pix_fmt, int width, int height);
  3756. /**
  3757. * Copy pixel data from an AVPicture into a buffer, always assume a
  3758. * linesize alignment of 1.
  3759. *
  3760. * @see av_image_copy_to_buffer().
  3761. */
  3762. int avpicture_layout(const AVPicture* src, enum AVPixelFormat pix_fmt,
  3763. int width, int height,
  3764. unsigned char *dest, int dest_size);
  3765. /**
  3766. * Calculate the size in bytes that a picture of the given width and height
  3767. * would occupy if stored in the given picture format.
  3768. * Always assume a linesize alignment of 1.
  3769. *
  3770. * @see av_image_get_buffer_size().
  3771. */
  3772. int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);
  3773. #if FF_API_DEINTERLACE
  3774. /**
  3775. * deinterlace - if not supported return -1
  3776. *
  3777. * @deprecated - use yadif (in libavfilter) instead
  3778. */
  3779. attribute_deprecated
  3780. int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
  3781. enum AVPixelFormat pix_fmt, int width, int height);
  3782. #endif
  3783. /**
  3784. * Copy image src to dst. Wraps av_picture_data_copy() above.
  3785. */
  3786. void av_picture_copy(AVPicture *dst, const AVPicture *src,
  3787. enum AVPixelFormat pix_fmt, int width, int height);
  3788. /**
  3789. * Crop image top and left side.
  3790. */
  3791. int av_picture_crop(AVPicture *dst, const AVPicture *src,
  3792. enum AVPixelFormat pix_fmt, int top_band, int left_band);
  3793. /**
  3794. * Pad image.
  3795. */
  3796. int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, enum AVPixelFormat pix_fmt,
  3797. int padtop, int padbottom, int padleft, int padright, int *color);
  3798. /**
  3799. * @}
  3800. */
  3801. /**
  3802. * @defgroup lavc_misc Utility functions
  3803. * @ingroup libavc
  3804. *
  3805. * Miscellaneous utility functions related to both encoding and decoding
  3806. * (or neither).
  3807. * @{
  3808. */
  3809. /**
  3810. * @defgroup lavc_misc_pixfmt Pixel formats
  3811. *
  3812. * Functions for working with pixel formats.
  3813. * @{
  3814. */
  3815. /**
  3816. * @deprecated Use av_pix_fmt_get_chroma_sub_sample
  3817. */
  3818. void attribute_deprecated avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift);
  3819. /**
  3820. * Return a value representing the fourCC code associated to the
  3821. * pixel format pix_fmt, or 0 if no associated fourCC code can be
  3822. * found.
  3823. */
  3824. unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt);
  3825. #define FF_LOSS_RESOLUTION 0x0001 /**< loss due to resolution change */
  3826. #define FF_LOSS_DEPTH 0x0002 /**< loss due to color depth change */
  3827. #define FF_LOSS_COLORSPACE 0x0004 /**< loss due to color space conversion */
  3828. #define FF_LOSS_ALPHA 0x0008 /**< loss of alpha bits */
  3829. #define FF_LOSS_COLORQUANT 0x0010 /**< loss due to color quantization */
  3830. #define FF_LOSS_CHROMA 0x0020 /**< loss of chroma (e.g. RGB to gray conversion) */
  3831. /**
  3832. * Compute what kind of losses will occur when converting from one specific
  3833. * pixel format to another.
  3834. * When converting from one pixel format to another, information loss may occur.
  3835. * For example, when converting from RGB24 to GRAY, the color information will
  3836. * be lost. Similarly, other losses occur when converting from some formats to
  3837. * other formats. These losses can involve loss of chroma, but also loss of
  3838. * resolution, loss of color depth, loss due to the color space conversion, loss
  3839. * of the alpha bits or loss due to color quantization.
  3840. * avcodec_get_fix_fmt_loss() informs you about the various types of losses
  3841. * which will occur when converting from one pixel format to another.
  3842. *
  3843. * @param[in] dst_pix_fmt destination pixel format
  3844. * @param[in] src_pix_fmt source pixel format
  3845. * @param[in] has_alpha Whether the source pixel format alpha channel is used.
  3846. * @return Combination of flags informing you what kind of losses will occur.
  3847. */
  3848. int avcodec_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt, enum AVPixelFormat src_pix_fmt,
  3849. int has_alpha);
  3850. /**
  3851. * Find the best pixel format to convert to given a certain source pixel
  3852. * format. When converting from one pixel format to another, information loss
  3853. * may occur. For example, when converting from RGB24 to GRAY, the color
  3854. * information will be lost. Similarly, other losses occur when converting from
  3855. * some formats to other formats. avcodec_find_best_pix_fmt2() searches which of
  3856. * the given pixel formats should be used to suffer the least amount of loss.
  3857. * The pixel formats from which it chooses one, are determined by the
  3858. * pix_fmt_list parameter.
  3859. *
  3860. *
  3861. * @param[in] pix_fmt_list AV_PIX_FMT_NONE terminated array of pixel formats to choose from
  3862. * @param[in] src_pix_fmt source pixel format
  3863. * @param[in] has_alpha Whether the source pixel format alpha channel is used.
  3864. * @param[out] loss_ptr Combination of flags informing you what kind of losses will occur.
  3865. * @return The best pixel format to convert to or -1 if none was found.
  3866. */
  3867. enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat *pix_fmt_list,
  3868. enum AVPixelFormat src_pix_fmt,
  3869. int has_alpha, int *loss_ptr);
  3870. enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
  3871. /**
  3872. * @}
  3873. */
  3874. #if FF_API_SET_DIMENSIONS
  3875. /**
  3876. * @deprecated this function is not supposed to be used from outside of lavc
  3877. */
  3878. attribute_deprecated
  3879. void avcodec_set_dimensions(AVCodecContext *s, int width, int height);
  3880. #endif
  3881. /**
  3882. * Put a string representing the codec tag codec_tag in buf.
  3883. *
  3884. * @param buf buffer to place codec tag in
  3885. * @param buf_size size in bytes of buf
  3886. * @param codec_tag codec tag to assign
  3887. * @return the length of the string that would have been generated if
  3888. * enough space had been available, excluding the trailing null
  3889. */
  3890. size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag);
  3891. void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode);
  3892. /**
  3893. * Return a name for the specified profile, if available.
  3894. *
  3895. * @param codec the codec that is searched for the given profile
  3896. * @param profile the profile value for which a name is requested
  3897. * @return A name for the profile if found, NULL otherwise.
  3898. */
  3899. const char *av_get_profile_name(const AVCodec *codec, int profile);
  3900. int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size);
  3901. int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int, int),void *arg, int *ret, int count);
  3902. //FIXME func typedef
  3903. /**
  3904. * Fill audio frame data and linesize.
  3905. * AVFrame extended_data channel pointers are allocated if necessary for
  3906. * planar audio.
  3907. *
  3908. * @param frame the AVFrame
  3909. * frame->nb_samples must be set prior to calling the
  3910. * function. This function fills in frame->data,
  3911. * frame->extended_data, frame->linesize[0].
  3912. * @param nb_channels channel count
  3913. * @param sample_fmt sample format
  3914. * @param buf buffer to use for frame data
  3915. * @param buf_size size of buffer
  3916. * @param align plane size sample alignment (0 = default)
  3917. * @return 0 on success, negative error code on failure
  3918. */
  3919. int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
  3920. enum AVSampleFormat sample_fmt, const uint8_t *buf,
  3921. int buf_size, int align);
  3922. /**
  3923. * Reset the internal decoder state / flush internal buffers. Should be called
  3924. * e.g. when seeking or when switching to a different stream.
  3925. *
  3926. * @note when refcounted frames are not used (i.e. avctx->refcounted_frames is 0),
  3927. * this invalidates the frames previously returned from the decoder. When
  3928. * refcounted frames are used, the decoder just releases any references it might
  3929. * keep internally, but the caller's reference remains valid.
  3930. */
  3931. void avcodec_flush_buffers(AVCodecContext *avctx);
  3932. /**
  3933. * Return codec bits per sample.
  3934. *
  3935. * @param[in] codec_id the codec
  3936. * @return Number of bits per sample or zero if unknown for the given codec.
  3937. */
  3938. int av_get_bits_per_sample(enum AVCodecID codec_id);
  3939. /**
  3940. * Return codec bits per sample.
  3941. * Only return non-zero if the bits per sample is exactly correct, not an
  3942. * approximation.
  3943. *
  3944. * @param[in] codec_id the codec
  3945. * @return Number of bits per sample or zero if unknown for the given codec.
  3946. */
  3947. int av_get_exact_bits_per_sample(enum AVCodecID codec_id);
  3948. /**
  3949. * Return audio frame duration.
  3950. *
  3951. * @param avctx codec context
  3952. * @param frame_bytes size of the frame, or 0 if unknown
  3953. * @return frame duration, in samples, if known. 0 if not able to
  3954. * determine.
  3955. */
  3956. int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes);
  3957. typedef struct AVBitStreamFilterContext {
  3958. void *priv_data;
  3959. struct AVBitStreamFilter *filter;
  3960. AVCodecParserContext *parser;
  3961. struct AVBitStreamFilterContext *next;
  3962. } AVBitStreamFilterContext;
  3963. typedef struct AVBitStreamFilter {
  3964. const char *name;
  3965. int priv_data_size;
  3966. int (*filter)(AVBitStreamFilterContext *bsfc,
  3967. AVCodecContext *avctx, const char *args,
  3968. uint8_t **poutbuf, int *poutbuf_size,
  3969. const uint8_t *buf, int buf_size, int keyframe);
  3970. void (*close)(AVBitStreamFilterContext *bsfc);
  3971. struct AVBitStreamFilter *next;
  3972. } AVBitStreamFilter;
  3973. void av_register_bitstream_filter(AVBitStreamFilter *bsf);
  3974. AVBitStreamFilterContext *av_bitstream_filter_init(const char *name);
  3975. int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc,
  3976. AVCodecContext *avctx, const char *args,
  3977. uint8_t **poutbuf, int *poutbuf_size,
  3978. const uint8_t *buf, int buf_size, int keyframe);
  3979. void av_bitstream_filter_close(AVBitStreamFilterContext *bsf);
  3980. AVBitStreamFilter *av_bitstream_filter_next(const AVBitStreamFilter *f);
  3981. /* memory */
  3982. /**
  3983. * Allocate a buffer with padding, reusing the given one if large enough.
  3984. *
  3985. * Same behaviour av_fast_malloc but the buffer has additional
  3986. * FF_INPUT_PADDING_SIZE at the end which will always memset to 0.
  3987. *
  3988. */
  3989. void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size);
  3990. /**
  3991. * Encode extradata length to a buffer. Used by xiph codecs.
  3992. *
  3993. * @param s buffer to write to; must be at least (v/255+1) bytes long
  3994. * @param v size of extradata in bytes
  3995. * @return number of bytes written to the buffer.
  3996. */
  3997. unsigned int av_xiphlacing(unsigned char *s, unsigned int v);
  3998. #if FF_API_MISSING_SAMPLE
  3999. /**
  4000. * Log a generic warning message about a missing feature. This function is
  4001. * intended to be used internally by Libav (libavcodec, libavformat, etc.)
  4002. * only, and would normally not be used by applications.
  4003. * @param[in] avc a pointer to an arbitrary struct of which the first field is
  4004. * a pointer to an AVClass struct
  4005. * @param[in] feature string containing the name of the missing feature
  4006. * @param[in] want_sample indicates if samples are wanted which exhibit this feature.
  4007. * If want_sample is non-zero, additional verbage will be added to the log
  4008. * message which tells the user how to report samples to the development
  4009. * mailing list.
  4010. * @deprecated Use avpriv_report_missing_feature() instead.
  4011. */
  4012. attribute_deprecated
  4013. void av_log_missing_feature(void *avc, const char *feature, int want_sample);
  4014. /**
  4015. * Log a generic warning message asking for a sample. This function is
  4016. * intended to be used internally by Libav (libavcodec, libavformat, etc.)
  4017. * only, and would normally not be used by applications.
  4018. * @param[in] avc a pointer to an arbitrary struct of which the first field is
  4019. * a pointer to an AVClass struct
  4020. * @param[in] msg string containing an optional message, or NULL if no message
  4021. * @deprecated Use avpriv_request_sample() instead.
  4022. */
  4023. attribute_deprecated
  4024. void av_log_ask_for_sample(void *avc, const char *msg, ...) av_printf_format(2, 3);
  4025. #endif /* FF_API_MISSING_SAMPLE */
  4026. /**
  4027. * Register the hardware accelerator hwaccel.
  4028. */
  4029. void av_register_hwaccel(AVHWAccel *hwaccel);
  4030. /**
  4031. * If hwaccel is NULL, returns the first registered hardware accelerator,
  4032. * if hwaccel is non-NULL, returns the next registered hardware accelerator
  4033. * after hwaccel, or NULL if hwaccel is the last one.
  4034. */
  4035. AVHWAccel *av_hwaccel_next(const AVHWAccel *hwaccel);
  4036. /**
  4037. * Lock operation used by lockmgr
  4038. */
  4039. enum AVLockOp {
  4040. AV_LOCK_CREATE, ///< Create a mutex
  4041. AV_LOCK_OBTAIN, ///< Lock the mutex
  4042. AV_LOCK_RELEASE, ///< Unlock the mutex
  4043. AV_LOCK_DESTROY, ///< Free mutex resources
  4044. };
  4045. /**
  4046. * Register a user provided lock manager supporting the operations
  4047. * specified by AVLockOp. The "mutex" argument to the function points
  4048. * to a (void *) where the lockmgr should store/get a pointer to a user
  4049. * allocated mutex. It is NULL upon AV_LOCK_CREATE and equal to the
  4050. * value left by the last call for all other ops. If the lock manager is
  4051. * unable to perform the op then it should leave the mutex in the same
  4052. * state as when it was called and return a non-zero value. However,
  4053. * when called with AV_LOCK_DESTROY the mutex will always be assumed to
  4054. * have been successfully destroyed. If av_lockmgr_register succeeds
  4055. * it will return a non-negative value, if it fails it will return a
  4056. * negative value and destroy all mutex and unregister all callbacks.
  4057. * av_lockmgr_register is not thread-safe, it must be called from a
  4058. * single thread before any calls which make use of locking are used.
  4059. *
  4060. * @param cb User defined callback. av_lockmgr_register invokes calls
  4061. * to this callback and the previously registered callback.
  4062. * The callback will be used to create more than one mutex
  4063. * each of which must be backed by its own underlying locking
  4064. * mechanism (i.e. do not use a single static object to
  4065. * implement your lock manager). If cb is set to NULL the
  4066. * lockmgr will be unregistered.
  4067. */
  4068. int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op));
  4069. /**
  4070. * Get the type of the given codec.
  4071. */
  4072. enum AVMediaType avcodec_get_type(enum AVCodecID codec_id);
  4073. /**
  4074. * @return a positive value if s is open (i.e. avcodec_open2() was called on it
  4075. * with no corresponding avcodec_close()), 0 otherwise.
  4076. */
  4077. int avcodec_is_open(AVCodecContext *s);
  4078. /**
  4079. * @return a non-zero number if codec is an encoder, zero otherwise
  4080. */
  4081. int av_codec_is_encoder(const AVCodec *codec);
  4082. /**
  4083. * @return a non-zero number if codec is a decoder, zero otherwise
  4084. */
  4085. int av_codec_is_decoder(const AVCodec *codec);
  4086. /**
  4087. * @return descriptor for given codec ID or NULL if no descriptor exists.
  4088. */
  4089. const AVCodecDescriptor *avcodec_descriptor_get(enum AVCodecID id);
  4090. /**
  4091. * Iterate over all codec descriptors known to libavcodec.
  4092. *
  4093. * @param prev previous descriptor. NULL to get the first descriptor.
  4094. *
  4095. * @return next descriptor or NULL after the last descriptor
  4096. */
  4097. const AVCodecDescriptor *avcodec_descriptor_next(const AVCodecDescriptor *prev);
  4098. /**
  4099. * @return codec descriptor with the given name or NULL if no such descriptor
  4100. * exists.
  4101. */
  4102. const AVCodecDescriptor *avcodec_descriptor_get_by_name(const char *name);
  4103. /**
  4104. * @}
  4105. */
  4106. #endif /* AVCODEC_AVCODEC_H */