update of headers. needs tests with newer libs, in particular linux distros.

git-svn-id: svn://svn.code.sf.net/p/ultrastardx/svn/trunk@1811 b956fd51-792f-4845-bead-9b4dfca2ff2c

1 files changed, 917 insertions, 110 deletions

diff --git a/src/lib/ffmpeg/avcodec.pas b/src/lib/ffmpeg/avcodec.pas
index 6039835c..402d6ed5 100644
--- a/src/lib/ffmpeg/avcodec.pas
+++ b/src/lib/ffmpeg/avcodec.pas
@@ -29,6 +29,11 @@
  * Min. version: 51.16.0, revision 6577, Sat Oct 7 15:30:46 2006 UTC 
  * Max. version: 52.11.0, revision 16912, Sun Feb 1 02:00:19 2009 UTC 
  *)
+{
+ * update to
+ * Max. version: 52.30.2, Fri Jun 12 21:05:00 2009 UTC 
+ * MiSchi
+}
 
 unit avcodec;
 
@@ -60,8 +65,8 @@ uses
 const
   (* Max. supported version by this header *)
   LIBAVCODEC_MAX_VERSION_MAJOR   = 52;
-  LIBAVCODEC_MAX_VERSION_MINOR   = 11;
-  LIBAVCODEC_MAX_VERSION_RELEASE = 0;
+  LIBAVCODEC_MAX_VERSION_MINOR   = 30;
+  LIBAVCODEC_MAX_VERSION_RELEASE = 2;
   LIBAVCODEC_MAX_VERSION = (LIBAVCODEC_MAX_VERSION_MAJOR * VERSION_MAJOR) +
                            (LIBAVCODEC_MAX_VERSION_MINOR * VERSION_MINOR) +
                            (LIBAVCODEC_MAX_VERSION_RELEASE * VERSION_RELEASE);
@@ -85,9 +90,9 @@ const
 {$IFEND}
 
 const
-  AV_NOPTS_VALUE: cint64   = $8000000000000000;
+  AV_NOPTS_VALUE: cint64  = $8000000000000000;
   AV_TIME_BASE            = 1000000;
-  AV_TIME_BASE_Q          : TAVRational = (num: 1; den: AV_TIME_BASE);
+  AV_TIME_BASE_Q: TAVRational = (num: 1; den: AV_TIME_BASE);
 
 (**
  * Identifies the syntax and semantics of the bitstream.
@@ -233,6 +238,25 @@ type
     CODEC_ID_MOTIONPIXELS,
     CODEC_ID_TGV,
     CODEC_ID_TGQ,
+{$IF LIBAVCODEC_VERSION >= 52012000}  // 52.12.0
+    CODEC_ID_TQI,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52022002}  // 52.22.2
+    CODEC_ID_AURA,
+    CODEC_ID_AURA2,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52027000}  // 52.27.0
+    CODEC_ID_V210X,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52028000}  // 52.28.0
+    CODEC_ID_TMV,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52029000}  // 52.29.0
+    CODEC_ID_V210,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52030002}  // 52.30.2
+    CODEC_ID_DPX,
+{$IFEND}
 
     //* various PCM "codecs" */
     CODEC_ID_PCM_S16LE= $10000,
@@ -354,6 +378,15 @@ type
     CODEC_ID_EAC3,
     CODEC_ID_SIPR,
     CODEC_ID_MP1,
+{$IF LIBAVCODEC_VERSION >= 52020000} // 52.20.0
+    CODEC_ID_TWINVQ,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52022000} // 52.22.0
+    CODEC_ID_TRUEHD,
+{$IFEND}
+{$IF LIBAVCODEC_VERSION >= 52026000} // 52.26.0
+    CODEC_ID_MP4ALS,
+{$IFEND}
 
     //* subtitle codecs */
     CODEC_ID_DVD_SUBTITLE= $17000,
@@ -369,7 +402,7 @@ type
     CODEC_ID_PROBE= $19000, ///< codec_id is not known (like CODEC_ID_NONE) but lavf should attempt to identify it
 
     CODEC_ID_MPEG2TS= $20000, {*< _FAKE_ codec to indicate a raw MPEG-2 TS
-                              * stream (only used by libavformat) *}
+                               * stream (only used by libavformat) *}
     __CODEC_ID_4BYTE = $FFFFF  // ensure 4-byte enum
   );
 
@@ -407,7 +440,7 @@ type
   _TSampleFormatArray = array [0 .. MaxInt div SizeOf(TSampleFormat)-1] of TSampleFormat;
   PSampleFormatArray = ^_TSampleFormatArray;
 
-const  
+const
   {* Audio channel masks *}
   CH_FRONT_LEFT             = $00000001;
   CH_FRONT_RIGHT            = $00000002;
@@ -434,13 +467,28 @@ const
   CH_LAYOUT_MONO            = (CH_FRONT_CENTER);
   CH_LAYOUT_STEREO          = (CH_FRONT_LEFT or CH_FRONT_RIGHT);
   CH_LAYOUT_SURROUND        = (CH_LAYOUT_STEREO or CH_FRONT_CENTER);
+{$IF LIBAVCODEC_VERSION >= 52027000} // 52.27.0
+  CH_LAYOUT_2_1               (CH_LAYOUT_STEREO or CH_BACK_CENTER);
+  CH_LAYOUT_4POINT0           (CH_LAYOUT_SURROUND or CH_BACK_CENTER);
+  CH_LAYOUT_2_2               (CH_LAYOUT_STEREO or CH_SIDE_LEFT or CH_SIDE_RIGHT);
+{$IFEND}
   CH_LAYOUT_QUAD            = (CH_LAYOUT_STEREO or CH_BACK_LEFT or CH_BACK_RIGHT);
   CH_LAYOUT_5POINT0         = (CH_LAYOUT_SURROUND or CH_SIDE_LEFT or CH_SIDE_RIGHT);
   CH_LAYOUT_5POINT1         = (CH_LAYOUT_5POINT0 or CH_LOW_FREQUENCY);
+{$IF LIBAVCODEC_VERSION >= 52025000} // 52.25.0
+  CH_LAYOUT_5POINT0_BACK    = (CH_LAYOUT_SURROUND or CH_BACK_LEFT or 
+                               CH_BACK_RIGHT);
+  CH_LAYOUT_5POINT1_BACK    = (CH_LAYOUT_5POINT0_BACK or CH_LOW_FREQUENCY);
+{$IFEND}
   CH_LAYOUT_7POINT1         = (CH_LAYOUT_5POINT1 or CH_BACK_LEFT or CH_BACK_RIGHT);
+{$IF LIBAVCODEC_VERSION < 52025000} // 52.25.0
   CH_LAYOUT_7POINT1_WIDE    = (CH_LAYOUT_SURROUND or CH_LOW_FREQUENCY or
-                                           CH_BACK_LEFT or CH_BACK_RIGHT or
-                                           CH_FRONT_LEFT_OF_CENTER or CH_FRONT_RIGHT_OF_CENTER);
+                               CH_BACK_LEFT or CH_BACK_RIGHT or
+{$ELSE}
+  CH_LAYOUT_7POINT1_WIDE    = (CH_LAYOUT_5POINT1_BACK or 
+{$IFEND}
+                               CH_FRONT_LEFT_OF_CENTER or
+                               CH_FRONT_RIGHT_OF_CENTER);
   CH_LAYOUT_STEREO_DOWNMIX  = (CH_STEREO_LEFT or CH_STEREO_RIGHT);
 
 
@@ -482,20 +530,76 @@ type
 
   TAVDiscard = (
     {* We leave some space between them for extensions (drop some
-     * keyframes for intra-only or drop just some bidir frames). *}
-    AVDISCARD_NONE   =-16, ///< discard nothing
-    AVDISCARD_DEFAULT=  0, ///< discard useless packets like 0 size packets in avi
-    AVDISCARD_NONREF =  8, ///< discard all non reference
-    AVDISCARD_BIDIR  = 16, ///< discard all bidirectional frames
-    AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes
-    AVDISCARD_ALL    = 48  ///< discard all
+     * keyframes for intra-only or drop just some bidir frames).
+     *}
+    AVDISCARD_NONE    = -16, ///< discard nothing
+    AVDISCARD_DEFAULT =   0, ///< discard useless packets like 0 size packets in avi
+    AVDISCARD_NONREF  =   8, ///< discard all non reference
+    AVDISCARD_BIDIR   =  16, ///< discard all bidirectional frames
+    AVDISCARD_NONKEY  =  32, ///< discard all frames except keyframes
+    AVDISCARD_ALL     =  48  ///< discard all
+  );
+
+{$IF LIBAVCODEC_VERSION < 52028000} // < 52.28.0
+  TAVColorPrimaries = (
+    AVCOL_PRI_BT709       = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
+    AVCOL_PRI_UNSPECIFIED = 2,
+    AVCOL_PRI_BT470M      = 4,
+    AVCOL_PRI_BT470BG     = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
+    AVCOL_PRI_SMPTE170M   = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
+    AVCOL_PRI_SMPTE240M   = 7, ///< functionally identical to above
+    AVCOL_PRI_FILM        = 8,
+    AVCOL_PRI_NB               ///< Not part of ABI
+  );
+
+  TAVColorTransferCharacteristic = (
+    AVCOL_TRC_BT709       = 1, ///< also ITU-R BT1361
+    AVCOL_TRC_UNSPECIFIED = 2,
+    AVCOL_TRC_GAMMA22     = 4, ///< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
+    AVCOL_TRC_GAMMA28     = 5, ///< also ITU-R BT470BG
+    AVCOL_TRC_NB               ///< Not part of ABI
+  );
+
+  TAVColorSpace = (
+    AVCOL_SPC_RGB         = 0,
+    AVCOL_SPC_BT709       = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
+    AVCOL_SPC_UNSPECIFIED = 2,
+    AVCOL_SPC_FCC         = 4,
+    AVCOL_SPC_BT470BG     = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
+    AVCOL_SPC_SMPTE170M   = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
+    AVCOL_SPC_SMPTE240M   = 7,
+    AVCOL_SPC_NB               ///< Not part of ABI
   );
 
+  TAVColorRange = (
+    AVCOL_RANGE_UNSPECIFIED = 0,
+    AVCOL_RANGE_MPEG        = 1, ///< the normal 219*2^(n-8) "MPEG" YUV ranges
+    AVCOL_RANGE_JPEG        = 2, ///< the normal     2^n-1   "JPEG" YUV ranges
+    AVCOL_RANGE_NB               ///< Not part of ABI
+  );
+
+(**
+ *  X   X      3 4 X      X are luma samples,
+ *             1 2        1-6 are possible chroma positions
+ *  X   X      5 6 X      0 is undefined/unknown position
+ *)
+  TAVChromaLocation = (
+    AVCHROMA_LOC_UNSPECIFIED = 0,
+    AVCHROMA_LOC_LEFT        = 1, ///< mpeg2/4, h264 default
+    AVCHROMA_LOC_CENTER      = 2, ///< mpeg1, jpeg, h263
+    AVCHROMA_LOC_TOPLEFT     = 3, ///< DV
+    AVCHROMA_LOC_TOP         = 4,
+    AVCHROMA_LOC_BOTTOMLEFT  = 5,
+    AVCHROMA_LOC_BOTTOM      = 6,
+    AVCHROMA_LOC_NB               ///< Not part of ABI
+  );
+{$IFEND}
+
   PRcOverride = ^TRcOverride;
   TRcOverride = record {16}
-    start_frame: cint;
-    end_frame: cint;
-    qscale: cint; // if this is 0 then quality_factor will be used instead
+    start_frame:    cint;
+    end_frame:      cint;
+    qscale:         cint; // if this is 0 then quality_factor will be used instead
     quality_factor: cfloat;
   end;
 
@@ -655,8 +759,8 @@ type
   end;
 
 const
-  FF_QSCALE_TYPE_MPEG1	= 0;
-  FF_QSCALE_TYPE_MPEG2	= 1;
+  FF_QSCALE_TYPE_MPEG1  = 0;
+  FF_QSCALE_TYPE_MPEG2  = 1;
   FF_QSCALE_TYPE_H264   = 2;
 
   FF_BUFFER_TYPE_INTERNAL = 1;
@@ -724,7 +828,7 @@ type
      * - decoding: Set by libavcodec.
      *)
     pts: cint64;
-    (**\
+    (**
      * picture number in bitstream order
      * - encoding: set by
      * - decoding: Set by libavcodec.
@@ -753,6 +857,7 @@ type
      * is this picture used as reference
      * The values for this are the same as the MpegEncContext.picture_structure
      * variable, that is 1->top field, 2->bottom field, 3->frame/both fields.
+     * Set to 4 for delayed, non-reference frames.
      * - encoding: unused
      * - decoding: Set by libavcodec. (before get_buffer() call)).
      *)
@@ -886,6 +991,18 @@ type
      *)
     reordered_opaque: cint64;
     {$IFEND}
+    
+    {$IF LIBAVCODEC_VERSION = 52021000} // 52.21.0
+    (**
+     * hardware accelerator private data (FFmpeg allocated)
+     * - encoding: unused
+     * - decoding: Set by libavcodec
+     *)
+    hwaccel_data_private: pointer;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52022000} // 52.22.0
+    hwaccel_picture_private: pointer;
+    {$IFEND}
 
     {$IF LIBAVCODEC_VERSION >= 51070000} // 51.70.0
     (**
@@ -928,6 +1045,73 @@ type
      *)
     rc_min_vbv_overflow_use: cfloat;
     {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52018000} // < 52.18.0
+    (**
+     * Hardware accelerator in use
+     * - encoding: unused.
+     * - decoding: Set by libavcodec
+     *)
+    hwaccel: PAVHWAccel;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52020000} // < 52.20.0
+    (**
+     * For some codecs, the time base is closer to the field rate than the frame rate.
+     * Most notably, H.264 and MPEG-2 specify time_base as half of frame duration
+     * if no telecine is used ...
+     *
+     * Set to time_base ticks per frame. Default 1, e.g., H.264/MPEG-2 set it to 2.
+     *)
+    ticks_per_frame: cint;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52021000} // < 52.21.0
+    (**
+     * Hardware accelerator context.
+     * For some hardware accelerators, a global context needs to be
+     * provided by the user. In that case, this holds display-dependent
+     * data FFmpeg cannot instantiate itself. Please refer to the
+     * FFmpeg HW accelerator documentation to know how to fill this
+     * is. e.g. for VA API, this is a struct vaapi_context.
+     * - encoding: unused
+     * - decoding: Set by user
+     *)
+    hwaccel_context: pointer;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION < 52028000} // < 52.28.0
+    (**
+     * Chromaticity coordinates of the source primaries.
+     * - encoding: Set by user
+     * - decoding: Set by libavcodec
+     *)
+    color_primaries: TAVColorPrimaries;
+
+    (**
+     * Color Transfer Characteristic.
+     * - encoding: Set by user
+     * - decoding: Set by libavcodec
+     *)
+    color_trc: TAVColorTransferCharacteristic;
+
+    (**
+     * YUV colorspace type.
+     * - encoding: Set by user
+     * - decoding: Set by libavcodec
+     *)
+    colorspace: TAVColorSpace;
+
+    (**
+     * MPEG vs JPEG YUV range.
+     * - encoding: Set by user
+     * - decoding: Set by libavcodec
+     *)
+    color_range: TAVColorRange;
+
+    (**
+     * This defines the location of chroma samples.
+     * - encoding: Set by user
+     * - decoding: Set by libavcodec
+     *)
+     chroma_sample_location: TAVChromaLocation;
+    {$IFEND}
   end;
 
 const
@@ -1007,12 +1191,21 @@ const
   (* lower 16 bits - CPU features *)
   FF_MM_MMX         = $0001; ///< standard MMX
   FF_MM_3DNOW       = $0004; ///< AMD 3DNOW
+  {$IF LIBAVCODEC_MAX_VERSION_MAJOR < 53}
   FF_MM_MMXEXT      = $0002; ///< SSE integer functions or AMD MMX ext
+  {$IFEND}
+  {$IF LIBAVCODEC_VERSION >= 52024000} // >= 52.24.0
+  FF_MM_MMX2        = $0002; ///< SSE integer functions or AMD MMX ext
+  {$IFEND}
   FF_MM_SSE         = $0008; ///< SSE functions
   FF_MM_SSE2        = $0010; ///< PIV SSE2 functions
   FF_MM_3DNOWEXT    = $0020; ///< AMD 3DNowExt
   FF_MM_SSE3        = $0040; ///< Prescott SSE3 functions
   FF_MM_SSSE3       = $0080; ///< Conroe SSSE3 functions
+  {$IF LIBAVCODEC_VERSION >= 52022003} // >= 52.22.3
+  FF_MM_SSE4        = $0100; ///< Penryn SSE4.1 functions
+  FF_MM_SSE42       = $0200; ///< Nehalem SSE4.2 functions
+  {$IFEND}
   FF_MM_IWMMXT      = $0100; ///< XScale IWMMXT
   FF_MM_ALTIVEC     = $0001; ///< standard AltiVec
 
@@ -1114,6 +1307,7 @@ const
   AVPALETTE_SIZE = 1024;
   AVPALETTE_COUNT = 256;
 
+{$IF LIBAVCODEC_MAX_VERSION_MAJOR < 53}
 type
 (**
  * AVPaletteControl
@@ -1135,6 +1329,69 @@ type
      * data is probably 6 bits in size and needs to be scaled *)
     palette: array [0..AVPALETTE_COUNT - 1] of cuint;
   end; {deprecated;}
+{$IFEND}
+
+{$IF LIBAVCODEC_VERSION >= 52023000} // >= 52.23.0
+type
+  PAVPacket = ^TAVPacket;
+  TAVPacket = record
+(*
+ * Presentation timestamp in AVStream->time_base units; the time at which
+ * the decompressed packet will be presented to the user.
+ * Can be AV_NOPTS_VALUE if it is not stored in the file.
+ * pts MUST be larger or equal to dts as presentation cannot happen before
+ * decompression, unless one wants to view hex dumps. Some formats misuse
+ * the terms dts and pts/cts to mean something different. Such timestamps
+ * must be converted to true pts/dts before they are stored in AVPacket.
+ *)
+    pts:          cint64;
+(*
+ * Decompression timestamp in AVStream->time_base units; the time at which
+ * the packet is decompressed.
+ * Can be AV_NOPTS_VALUE if it is not stored in the file.
+ *)
+    dts:          cint64;
+    data:         PByteArray;
+    size:         cint;
+    stream_index: cint;
+    flags:        cint;
+(*
+ * Duration of this packet in AVStream->time_base units, 0 if unknown.
+ * Equals next_pts - this_pts in presentation order.
+ *)
+    duration:     cint;
+    destruct:     procedure (para1: PAVPacket); cdecl;
+    priv:         pointer;
+    pos:          cint64;       // byte position in stream, -1 if unknown
+
+(*
+ * Time difference in AVStream->time_base units from the pts of this
+ * packet to the point at which the output from the decoder has converged
+ * independent from the availability of previous frames. That is, the
+ * frames are virtually identical no matter if decoding started from
+ * the very first frame or from this keyframe.
+ * Is AV_NOPTS_VALUE if unknown.
+ * This field is not the display duration of the current packet.
+ *
+ * The purpose of this field is to allow seeking in streams that have no
+ * keyframes in the conventional sense. It corresponds to the
+ * recovery point SEI in H.264 and match_time_delta in NUT. It is also
+ * essential for some types of subtitle streams to ensure that all
+ * subtitles are correctly displayed after seeking.
+ *)
+    convergence_duration: cint64;
+  end;
+
+const
+  {$IF LIBAVCODEC_VERSION < 52030002} // >= 52.30.2
+  PKT_FLAG_KEY = $0001;
+  {$ELSE}
+  AV_PKT_FLAG_KEY = $0001;
+    {$IF LIBAVCODEC_VERSION_MAJOR < 53}
+  PKT_FLAG_KEY = AV_PKT_FLAG_KEY;
+    {$IFEND}
+  {$IFEND}
+{$IFEND}
 
 type
   PAVClass = ^TAVClass; {const}
@@ -1273,6 +1530,13 @@ type
      * decoder to draw a horizontal band. It improves cache usage. Not
      * all codecs can do that. You must check the codec capabilities
      * beforehand.
+     * The function is also used by hardware acceleration APIs.
+     * It is called at least once during frame decoding to pass
+     * the data needed for hardware render.
+     * In that mode instead of pixel data, AVFrame points to
+     * a structure specific to the acceleration API. The application
+     * reads the structure and can change some fields to indicate progress
+     * or mark state.
      * - encoding: unused
      * - decoding: Set by user.
      * @param height the height of the slice
@@ -1301,7 +1565,9 @@ type
      *)
     frame_size: cint;
     frame_number: cint;   ///< audio or video frame number
+{$IF LIBAVCODEC_MAX_VERSION_MAJOR < 53}
     real_pict_num: cint;  ///< returns the real picture number of previous encoded frame
+{$IFEND}
 
     (**
      * Number of frames the decoded output will be delayed relative to
@@ -1490,6 +1756,9 @@ type
      * If pic.reference is set then the frame will be read later by libavcodec.
      * avcodec_align_dimensions() should be used to find the required width and
      * height, as they normally need to be rounded up to the next multiple of 16.
+     * if CODEC_CAP_DR1 is not set then get_buffer() must call
+     * avcodec_default_get_buffer() instead of providing buffers allocated by
+     * some other means.
      * - encoding: unused
      * - decoding: Set by libavcodec., user can override.
      *)
@@ -1505,7 +1774,8 @@ type
     release_buffer: procedure (c: PAVCodecContext; pic: PAVFrame); cdecl;
 
     (**
-     * If 1 the stream has a 1 frame delay during decoding.
+     * Size of the frame reordering buffer in the decoder.
+     * For MPEG-2 it is 1 IPB or 0 low delay IP.
      * - encoding: Set by libavcodec.
      * - decoding: Set by libavcodec.
      *)
@@ -2012,6 +2282,9 @@ type
      * libavcodec will pass previous buffer in pic, function should return
      * same buffer or new buffer with old frame "painted" into it.
      * If pic.data[0] == NULL must behave like get_buffer().
+     * if CODEC_CAP_DR1 is not set then reget_buffer() must call
+     * avcodec_default_reget_buffer() instead of providing buffers allocated by
+     * some other means.
      * - encoding: unused
      * - decoding: Set by libavcodec., user can override
      *)
@@ -2465,6 +2738,15 @@ type
      *)
     reordered_opaque: cint64;
     {$IFEND}
+    
+    {$IF LIBAVCODEC_VERSION >= 52028000} // 52.28.0
+    (**
+     * This defines the location of chroma samples.
+     * - encoding: Set by user
+     * - decoding: Set by libavcodec
+     *)
+     chroma_sample_location: TAVChromaLocation;
+    {$IFEND}
   end;
 
 (**
@@ -2479,7 +2761,11 @@ type
     encode: function (avctx: PAVCodecContext; buf: PByteArray; buf_size: cint; data: pointer): cint; cdecl;
     close: function (avctx: PAVCodecContext): cint; cdecl;
     decode: function (avctx: PAVCodecContext; outdata: pointer; var outdata_size: cint;
+    {$IF LIBAVCODEC_VERSION < 52025000} // 52.25.0
                       buf: {const} PByteArray; buf_size: cint): cint; cdecl;
+    {$ELSE}
+                      avpkt: PAVPacket): cint; cdecl;
+    {$IFEND}
     (**
      * Codec capabilities.
      * see CODEC_CAP_*
@@ -2495,8 +2781,8 @@ type
     pix_fmts: {const} PAVPixelFormat;       ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
     {$IF LIBAVCODEC_VERSION >= 51055000} // 51.55.0
     (**
-     * Descriptive name for the codec, meant to be more human readable than \p name.
-     * You \e should use the NULL_IF_CONFIG_SMALL() macro to define it.
+     * Descriptive name for the codec, meant to be more human readable than name.
+     * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
      *)
     long_name: {const} PAnsiChar;
     {$IFEND}
@@ -2511,6 +2797,107 @@ type
     {$IFEND}
   end;
 
+{$IF LIBAVCODEC_VERSION >= 52018000} // 52.18.0
+type
+(**
+ * AVHWAccel.
+ *)
+  PAVHWAccel = ^TAVHWAccel;
+  TAVHWAccel = record
+    (**
+     * Name of the hardware accelerated codec.
+     * The name is globally unique among encoders and among decoders (but an
+     * encoder and a decoder can share the same name).
+     *)
+    name: PAnsiChar;
+
+    (**
+     * Type of codec implemented by the hardware accelerator.
+     *
+     * See CODEC_TYPE_xxx
+     *)
+    type_: TCodecType;
+
+    (**
+     * Codec implemented by the hardware accelerator.
+     *
+     * See CODEC_ID_xxx
+     *)
+    id: TCodecID;
+
+    (**
+     * Supported pixel format.
+     *
+     * Only hardware accelerated formats are supported here.
+     *)
+    pix_fmt: {const} PAVPixelFormat; 
+
+    (**
+     * Hardware accelerated codec capabilities.
+     * see FF_HWACCEL_CODEC_CAP_*
+     *)
+    capabilities: cint;
+
+    next: PAVCodec;
+
+    (**
+     * Called at the beginning of each frame or field picture.
+     *
+     * Meaningful frame information (codec specific) is guaranteed to
+     * be parsed at this point. This function is mandatory.
+     *
+     * Note that buf can be NULL along with buf_size set to 0.
+     * Otherwise, this means the whole frame is available at this point.
+     *
+     * @param avctx the codec context
+     * @param buf the frame data buffer base
+     * @param buf_size the size of the frame in bytes
+     * @return zero if successful, a negative value otherwise
+     *)
+    start_frame: function (avctx:    PAVCodecContext; 
+                           buf:      PByteArray; 
+                           buf_size: cint): cint; cdecl;
+
+    (**
+     * Callback for each slice.
+     *
+     * Meaningful slice information (codec specific) is guaranteed to
+     * be parsed at this point. This function is mandatory.
+     *
+     * @param avctx the codec context
+     * @param buf the slice data buffer base
+     * @param buf_size the size of the slice in bytes
+     * @return zero if successful, a negative value otherwise
+     *)
+    decode_slice: function (avctx:    PAVCodecContext;
+                            buf:      PByteArray; 
+                            buf_size: cint): cint; cdecl;
+
+    (**
+     * Called at the end of each frame or field picture.
+     *
+     * The whole picture is parsed at this point and can now be sent
+     * to the hardware accelerator. This function is mandatory.
+     *
+     * @param avctx the codec context
+     * @return zero if successful, a negative value otherwise
+     *)
+    end_frame: function (avctx: PAVCodecContext): cint; cdecl;
+        
+{$IF LIBAVCODEC_VERSION >= 52021000} // >= 52.21.0
+    (**
+     * Size of HW accelerator private data.
+     *
+     * Private data is allocated with av_mallocz() before
+     * AVCodecContext.get_buffer() and deallocated after
+     * AVCodecContext.release_buffer().
+     *)
+    priv_data_size: cint;
+{$IFEND}
+        
+  end;
+{$IFEND}
+
 (**
  * four components are given, that's all.
  * the last component is alpha
@@ -2594,6 +2981,66 @@ type
     {$IFEND}
   end;
 
+{$IF LIBAVCODEC_VERSION >= 52025000} // 52.25.0
+{ packet functions  }
+
+(**
+ * @deprecated use NULL instead
+ *)
+procedure av_destruct_packet_nofree(pkt: PAVPacket);
+  cdecl; external av__codec;
+
+(*
+ * Default packet destructor.
+ *)
+procedure av_destruct_packet(pkt: PAVPacket);
+  cdecl; external av__codec;
+
+(*
+ * Initialize optional fields of a packet with default values.
+ *
+ * @param pkt packet
+ *)
+procedure av_init_packet(pkt: PAVPacket);
+  cdecl; external av__codec;
+
+(*
+ * Allocate the payload of a packet and initialize its fields with
+ * default values.
+ *
+ * @param pkt packet
+ * @param size wanted payload size
+ * @return 0 if OK, AVERROR_xxx otherwise
+ *)
+function av_new_packet(pkt: PAVPacket; size: cint): cint;
+  cdecl; external av__codec;
+
+(*
+ * Reduce packet size, correctly zeroing padding
+ *
+ * @param pkt packet
+ * @param size new size
+ *)
+procedure av_shrink_packet(pkt: PAVPacket; size: cint);
+  cdecl; external av__codec;
+
+(*
+ * @warning This is a hack - the packet memory allocation stuff is broken. The
+ * packet is allocated if it was not really allocated.
+ *)
+function av_dup_packet(pkt: PAVPacket): cint;
+  cdecl; external av__codec;
+
+(*
+ * Free a packet.
+ *
+ * @param pkt packet to free
+ *)
+procedure av_free_packet(pkt: PAVPacket);
+{$IF LIBAVCODEC_VERSION >=52028000} // 52.28.0
+  cdecl; external av__codec;
+{$IFEND}
+{$IFEND}
 
 (* resample.c *)
 
@@ -2611,7 +3058,15 @@ function audio_resample (s: PReSampleContext; output: PSmallint; input: PSmallin
 procedure audio_resample_close (s: PReSampleContext);
   cdecl; external av__codec;
 
-
+(**
+ * Initializes an audio resampler.
+ * Note, if either rate is not an integer then simply scale both rates up so they are.
+ * @param filter_length length of each FIR filter in the filterbank relative to the cutoff freq
+ * @param log2_phase_count log2 of the number of entries in the polyphase filterbank
+ * @param linear If 1 then the used FIR filter will be linearly interpolated
+                 between the 2 closest, if 0 the closest will be used
+ * @param cutoff cutoff frequency, 1.0 corresponds to half the output sampling rate
+ *)
 function av_resample_init (out_rate: cint; in_rate: cint; filter_length: cint;
                            log2_phase_count: cint; linear: cint; cutoff: cdouble): PAVResampleContext;
   cdecl; external av__codec;
@@ -2627,7 +3082,6 @@ procedure av_resample_compensate (c: PAVResampleContext; sample_delta: cint;
 procedure av_resample_close (c: PAVResampleContext);
   cdecl; external av__codec;
 
-
 {$IF LIBAVCODEC_VERSION < 52000000} // 52.0.0
 (* YUV420 format is assumed ! *)
 
@@ -2660,7 +3114,6 @@ procedure img_resample (s: PImgReSampleContext; output: PAVPicture; input: {cons
  *)
 procedure img_resample_close (s: PImgReSampleContext);
   cdecl; external av__codec; deprecated;
-
 {$IFEND}
 
 (**
@@ -2692,6 +3145,7 @@ procedure avpicture_free (picture: PAVPicture);
  * If a planar format is specified, several pointers will be set pointing to
  * the different picture planes and the line sizes of the different planes
  * will be stored in the lines_sizes array.
+ * Call with ptr == NULL to get the required size for the ptr buffer.
  *
  * @param picture AVPicture whose fields are to be filled in
  * @param ptr Buffer which will contain or contains the actual image data
@@ -2712,11 +3166,14 @@ function avpicture_layout (src: {const} PAVPicture; pix_fmt: TAVPixelFormat;
 (**
  * Calculate the size in bytes that a picture of the given width and height
  * would occupy if stored in the given picture format.
+ * Note that this returns the size of a compact representation as generated
+ * by avpicture_layout, which can be smaller than the size required for e.g.
+ * avpicture_fill.
  *
  * @param pix_fmt the given picture format
  * @param width the width of the image
  * @param height the height of the image
- * @return Image data size in bytes
+ * @return Image data size in bytes or -1 on error (e.g. too large dimensions).
  *)
 function avpicture_get_size (pix_fmt: TAVPixelFormat; width: cint; height: cint): cint;
   cdecl; external av__codec;
@@ -2730,6 +3187,17 @@ function avcodec_get_pix_fmt_name(pix_fmt: TAVPixelFormat): PAnsiChar;
 procedure avcodec_set_dimensions(s: PAVCodecContext; width: cint; height: cint);
   cdecl; external av__codec;
 
+(**
+ * Returns the pixel format corresponding to the name name.
+ *
+ * If there is no pixel format with name name, then looks for a
+ * pixel format with the name corresponding to the native endian
+ * format of name.
+ * For example in a little-endian system, first looks for "gray16",
+ * then for "gray16le".
+ *
+ * Finally if no pixel format has been found, returns PIX_FMT_NONE.
+ *)
 function avcodec_get_pix_fmt(name: {const} PAnsiChar): TAVPixelFormat;
   cdecl; external av__codec;
 
@@ -2773,7 +3241,7 @@ function avcodec_get_pix_fmt_loss (dst_pix_fmt: TAVPixelFormat; src_pix_fmt: TAV
  * some formats to other formats. avcodec_find_best_pix_fmt() searches which of
  * the given pixel formats should be used to suffer the least amount of loss.
  * The pixel formats from which it chooses one, are determined by the
- * \p pix_fmt_mask parameter.
+ * pix_fmt_mask parameter.
  *
  * @code
  * src_pix_fmt = PIX_FMT_YUV420P;
@@ -2791,10 +3259,14 @@ function avcodec_get_pix_fmt_loss (dst_pix_fmt: TAVPixelFormat; src_pix_fmt: TAV
 function avcodec_find_best_pix_fmt(pix_fmt_mask: cint64; src_pix_fmt: TAVPixelFormat;
                             has_alpha: cint; loss_ptr: PCint): cint;
   cdecl; external av__codec;
-{$ELSE}
+{$ELSEIF LIBAVCODEC_VERSION < 52022001}
 function avcodec_find_best_pix_fmt(pix_fmt_mask: cint; src_pix_fmt: TAVPixelFormat;
                             has_alpha: cint; loss_ptr: PCint): cint;
   cdecl; external av__codec;
+{$ELSE}
+function avcodec_find_best_pix_fmt(pix_fmt_mask: cint; src_pix_fmt: TAVPixelFormat;
+                            has_alpha: cint; loss_ptr: PCint): TAVPixelFormat;
+  cdecl; external av__codec;
 {$IFEND}
 
 {$IF LIBAVCODEC_VERSION >= 51041000} // 51.41.0
@@ -2808,8 +3280,13 @@ function avcodec_find_best_pix_fmt(pix_fmt_mask: cint; src_pix_fmt: TAVPixelForm
  * a negative value to print the corresponding header.
  * Meaningful values for obtaining a pixel format info vary from 0 to PIX_FMT_NB -1.
  *)
+{$IF LIBAVCODEC_VERSION < 52022001} // 52.22.1
 procedure avcodec_pix_fmt_string (buf: PAnsiChar; buf_size: cint; pix_fmt: cint);
   cdecl; external av__codec;
+{$ELSE}
+procedure avcodec_pix_fmt_string (buf: PAnsiChar; buf_size: cint; pix_fmt: TAVPixelFormat);
+  cdecl; external av__codec;
+{$IFEND}
 {$IFEND}
 
 const
@@ -2822,7 +3299,8 @@ const
  *)
 function img_get_alpha_info (src: {const} PAVPicture;
                              pix_fmt: TAVPixelFormat;
-                             width: cint; height: cint): cint;
+                             width:   cint;
+                             height:  cint): cint;
   cdecl; external av__codec;
 
 {$IF LIBAVCODEC_VERSION < 52000000} // 52.0.0
@@ -2838,8 +3316,11 @@ function img_convert (dst: PAVPicture; dst_pix_fmt: TAVPixelFormat;
 
 (* deinterlace a picture *)
 (* deinterlace - if not supported return -1 *)
-function avpicture_deinterlace (dst: PAVPicture; src: {const} PAVPicture;
-                        pix_fmt: TAVPixelFormat; width: cint; height: cint): cint;
+function avpicture_deinterlace (dst: PAVPicture;
+                        src: {const} PAVPicture;
+                        pix_fmt: TAVPixelFormat;
+                        width:   cint;
+                        height:  cint): cint;
   cdecl; external av__codec;
 
 {* external high level API *}
@@ -2852,6 +3333,11 @@ var
 {$IFEND}
 
 {$IF LIBAVCODEC_VERSION >= 51049000} // 51.49.0
+(**
+ * If c is NULL, returns the first registered codec,
+ * if c is non-NULL, returns the next registered codec after c,
+ * or NULL if c is the last one.
+ *)
 function av_codec_next(c: PAVCodec): PAVCodec;
   cdecl; external av__codec;
 {$IFEND}
@@ -2871,20 +3357,27 @@ function avcodec_build(): cuint;
 (**
  * Initializes libavcodec.
  *
- * @warning This function \e must be called before any other libavcodec
+ * @warning This function must be called before any other libavcodec
  * function.
  *)
 procedure avcodec_init();
   cdecl; external av__codec;
 
 (**
- * Register the codec \p codec and initialize libavcodec.
+ * Register the codec codec and initialize libavcodec.
  *
  * @see avcodec_init()
  *)
+{$IF LIBAVCODEC_VERSION >= 52014000} // 52.14.0
+procedure avcodec_register(codec: PAVCodec);
+  cdecl; external av__codec;
+// Deprecated in favor of avcodec_register.
+procedure register_avcodec(codec: PAVCodec);
+  cdecl; external av__codec; deprecated;
+{$ELSEIF LIBAVCODEC_VERSION_MAJOR < 53}
 procedure register_avcodec(codec: PAVCodec);
   cdecl; external av__codec;
-
+{$IFEND}
 (**
  * Finds a registered encoder with a matching codec ID.
  *
@@ -3050,125 +3543,189 @@ function avcodec_open(avctx: PAVCodecContext; codec: PAVCodec): cint;
 
 {$IF LIBAVCODEC_VERSION < 52000000} // < 52.0.0
 (**
- * @deprecated Use avcodec_decode_audio2() instead.
+ * @deprecated Use avcodec_decode_audio2 instead.
  *)
 function avcodec_decode_audio(avctx: PAVCodecContext; samples: PSmallint;
                            var frame_size_ptr: cint;
                            buf: {const} PByteArray; buf_size: cint): cint;
-  cdecl; external av__codec;
+  cdecl; external av__codec; {deprecated;}
 {$IFEND}
 
+{$IF LIBAVCODEC_MAX_VERSION_MAJOR < 53}
 {$IF LIBAVCODEC_VERSION >= 51030000} // 51.30.0
 (**
- * Decodes an audio frame from \p buf into \p samples.
- * The avcodec_decode_audio2() function decodes an audio frame from the input
- * buffer \p buf of size \p buf_size. To decode it, it makes use of the
- * audio codec which was coupled with \p avctx using avcodec_open(). The
- * resulting decoded frame is stored in output buffer \p samples.  If no frame
- * could be decompressed, \p frame_size_ptr is zero. Otherwise, it is the
- * decompressed frame size in \e bytes.
+ * Decodes an audio frame from buf into samples.
+ * Wrapper function which calls avcodec_decode_audio3.
  *
- * @warning You \e must set \p frame_size_ptr to the allocated size of the
- * output buffer before calling avcodec_decode_audio2().
+ * @deprecated Use avcodec_decode_audio3 instead.
+ * @param avctx the codec context
+ * @param[out] samples the output buffer
+ * @param[in,out] frame_size_ptr the output buffer size in bytes
+ * @param[in] buf the input buffer
+ * @param[in] buf_size the input buffer size in bytes
+ * @return On error a negative value is returned, otherwise the number of bytes
+ * used or zero if no frame could be decompressed.
+ *)
+function avcodec_decode_audio2(avctx: PAVCodecContext; samples: PSmallint;
+               var frame_size_ptr: cint;
+               buf: {const} PByteArray; buf_size: cint): cint;
+  cdecl; external av__codec; {deprecated;}
+{$IFEND}
+{$IFEND}
+
+{$IF LIBAVCODEC_VERSION >= 52025000} // 52.25.0
+(**
+ * Decodes the audio frame of size avpkt->size from avpkt->data into samples.
+ * Some decoders may support multiple frames in a single AVPacket, such
+ * decoders would then just decode the first frame.
+ * If no frame
+ * could be decompressed, frame_size_ptr is zero. Otherwise, it is the
+ * decompressed frame size in bytes.
+ *
+ * @warning You must set frame_size_ptr to the allocated size of the
+ * output buffer before calling avcodec_decode_audio3().
  *
- * @warning The input buffer must be \c FF_INPUT_BUFFER_PADDING_SIZE larger than
+ * @warning The input buffer must be FF_INPUT_BUFFER_PADDING_SIZE larger than
  * the actual read bytes because some optimized bitstream readers read 32 or 64
  * bits at once and could read over the end.
  *
- * @warning The end of the input buffer \p buf should be set to 0 to ensure that
+ * @warning The end of the input buffer avpkt->data should be set to 0 to ensure that
  * no overreading happens for damaged MPEG streams.
  *
- * @note You might have to align the input buffer \p buf and output buffer \p
+ * @note You might have to align the input buffer avpkt->data and output buffer
  * samples. The alignment requirements depend on the CPU: On some CPUs it isn't
  * necessary at all, on others it won't work at all if not aligned and on others
- * it will work but it will have an impact on performance. In practice, the
- * bitstream should have 4 byte alignment at minimum and all sample data should
- * be 16 byte aligned unless the CPU doesn't need it (AltiVec and SSE do). If
- * the linesize is not a multiple of 16 then there's no sense in aligning the
- * start of the buffer to 16.
+ * * it will work but it will have an impact on performance.
+ *
+ * In practice, avpkt->data should have 4 byte alignment at minimum and
+ * samples should be 16 byte aligned unless the CPU doesn't need it
+ * (AltiVec and SSE do).
  *
  * @note Some codecs have a delay between input and output, these need to be
- * feeded with buf=NULL, buf_size=0 at the end to return the remaining frames.
+ * feeded with avpkt->data=NULL, avpkt->size=0 at the end to return the remaining frames.
  *
  * @param avctx the codec context
  * @param[out] samples the output buffer
  * @param[in,out] frame_size_ptr the output buffer size in bytes
- * @param[in] buf the input buffer
- * @param[in] buf_size the input buffer size in bytes
+ * @param[in] avpkt The input AVPacket containing the input buffer.
+ *            You can create such packet with av_init_packet() and by then setting
+ *            data and size, some decoders might in addition need other fields.
+ *            All decoders are designed to use the least fields possible though.
  * @return On error a negative value is returned, otherwise the number of bytes
  * used or zero if no frame could be decompressed.
  *)
-function avcodec_decode_audio2(avctx: PAVCodecContext; samples: PSmallint;
+function avcodec_decode_audio3(avctx: PAVCodecContext; samples: PSmallint;
                var frame_size_ptr: cint;
-               buf: {const} PByteArray; buf_size: cint): cint;
+               avpkt: PAVPacket): cint;
   cdecl; external av__codec;
 {$IFEND}
 
+{$IF LIBAVCODEC_MAX_VERSION_MAJOR < 53}
 (**
- * Decodes a video frame from \p buf into \p picture.
- * The avcodec_decode_video() function decodes a video frame from the input
- * buffer \p buf of size \p buf_size. To decode it, it makes use of the
- * video codec which was coupled with \p avctx using avcodec_open(). The
- * resulting decoded frame is stored in \p picture.
+ * Decodes a video frame from buf into picture.
+ * Wrapper function which calls avcodec_decode_video2.
  *
- * @warning The input buffer must be \c FF_INPUT_BUFFER_PADDING_SIZE larger than
+ * @deprecated Use avcodec_decode_video2 instead.
+ * @param avctx the codec context
+ * @param[out] picture The AVFrame in which the decoded video frame will be stored.
+ * @param[in] buf the input buffer
+ * @param[in] buf_size the size of the input buffer in bytes
+ * @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero.
+ * @return On error a negative value is returned, otherwise the number of bytes
+ * used or zero if no frame could be decompressed.
+ *)
+function avcodec_decode_video(avctx: PAVCodecContext; picture: PAVFrame;
+                       var got_picture_ptr: cint;
+                       buf: {const} PByteArray; buf_size: cint): cint;
+  cdecl; external av__codec; {deprecated;}
+{$IFEND}
+
+{$IF LIBAVCODEC_VERSION >= 52025000} // 52.25.0
+(**
+ * Decodes the video frame of size avpkt->size from avpkt->data into picture.
+ * Some decoders may support multiple frames in a single AVPacket, such
+ * decoders would then just decode the first frame.
+ *
+ * @warning The input buffer must be FF_INPUT_BUFFER_PADDING_SIZE larger than
  * the actual read bytes because some optimized bitstream readers read 32 or 64
  * bits at once and could read over the end.
  *
- * @warning The end of the input buffer \p buf should be set to 0 to ensure that
+ * @warning The end of the input buffer buf should be set to 0 to ensure that
  * no overreading happens for damaged MPEG streams.
  *
- * @note You might have to align the input buffer \p buf and output buffer \p
- * samples. The alignment requirements depend on the CPU: on some CPUs it isn't
+ * @note You might have to align the input buffer avpkt->data.
+ * The alignment requirements depend on the CPU: on some CPUs it isn't
  * necessary at all, on others it won't work at all if not aligned and on others
- * it will work but it will have an impact on performance. In practice, the
- * bitstream should have 4 byte alignment at minimum and all sample data should
- * be 16 byte aligned unless the CPU doesn't need it (AltiVec and SSE do). If
- * the linesize is not a multiple of 16 then there's no sense in aligning the
- * start of the buffer to 16.
+ * it will work but it will have an impact on performance.
+ *
+ * In practice, avpkt->data should have 4 byte alignment at minimum.
  *
  * @param avctx the codec context
  * @param[out] picture The AVFrame in which the decoded video frame will be stored.
- * @param[in] buf the input buffer
- * @param[in] buf_size the size of the input buffer in bytes
+ * @param[in] avpkt The input AVpacket containing the input buffer.
+ *            You can create such packet with av_init_packet() and by then setting
+ *            data and size, some decoders might in addition need other fields like
+ *            flags&PKT_FLAG_KEY. All decoders are designed to use the least
+ *            fields possible.
  * @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero.
  * @return On error a negative value is returned, otherwise the number of bytes
  * used or zero if no frame could be decompressed.
  *)
-function avcodec_decode_video(avctx: PAVCodecContext; picture: PAVFrame;
+function avcodec_decode_video2(avctx: PAVCodecContext; picture: PAVFrame;
                        var got_picture_ptr: cint;
-                       buf: {const} PByteArray; buf_size: cint): cint;
+                       avpkt: PAVPacket): cint;
   cdecl; external av__codec;
+{$IFEND}
 
+{$IF LIBAVCODEC_MAX_VERSION_MAJOR < 53}
 (* Decode a subtitle message. Return -1 if error, otherwise return the
  * number of bytes used. If no subtitle could be decompressed,
- * got_sub_ptr is zero. Otherwise, the subtitle is stored in *sub. *)
+ * got_sub_ptr is zero. Otherwise, the subtitle is stored in*sub.
+ *)
 function avcodec_decode_subtitle(avctx: PAVCodecContext; sub: PAVSubtitle;
                           var got_sub_ptr: cint;
                           buf: {const} PByteArray; buf_size: cint): cint;
   cdecl; external av__codec;
+{$IFEND}
+  
+{$IF LIBAVCODEC_VERSION >= 52025000} // 52.25.0
+(* Decodes a subtitle message.
+ * Returns a negative value on error, otherwise returns the number of bytes used.
+ * If no subtitle could be decompressed, got_sub_ptr is zero.
+ * Otherwise, the subtitle is stored in sub.
+ *
+ * @param avctx the codec context
+ * @param[out] sub The AVSubtitle in which the decoded subtitle will be stored.
+ * @param[in,out] got_sub_ptr Zero if no subtitle could be decompressed, otherwise, it is nonzero.
+ * @param[in] avpkt The input AVPacket containing the input buffer.
+ *)
+function avcodec_decode_subtitle2(avctx: PAVCodecContext; sub: PAVSubtitle;
+                          var got_sub_ptr: cint;
+                          avpkt: PAVPacket): cint;
+  cdecl; external av__codec;
+{$IFEND}
+  
 function avcodec_parse_frame(avctx: PAVCodecContext; pdata: PPointer;
                       data_size_ptr: PCint;
                       buf: PByteArray; buf_size: cint): cint;
   cdecl; external av__codec;
 
 (**
- * Encodes an audio frame from \p samples into \p buf.
- * The avcodec_encode_audio() function encodes an audio frame from the input
- * buffer \p samples. To encode it, it makes use of the audio codec which was
- * coupled with \p avctx using avcodec_open(). The resulting encoded frame is
- * stored in output buffer \p buf.
+ * Encodes an audio frame from samples into buf.
  *
- * @note The output buffer should be at least \c FF_MIN_BUFFER_SIZE bytes large.
+ * @note The output buffer should be at least FF_MIN_BUFFER_SIZE bytes large.
+ * However, for PCM audio the user will know how much space is needed
+ * because it depends on the value passed in buf_size as described
+ * below. In that case a lower value can be used.
  *
  * @param avctx the codec context
  * @param[out] buf the output buffer
  * @param[in] buf_size the output buffer size
  * @param[in] samples the input buffer containing the samples
  * The number of samples read from this buffer is frame_size*channels,
- * both of which are defined in \p avctx.
- * For PCM audio the number of samples read from \p samples is equal to
- * \p buf_size * input_sample_size / output_sample_size.
+ * both of which are defined in avctx.
+ * For PCM audio the number of samples read from samples is equal to
+ * buf_size * input_sample_size / output_sample_size.
  * @return On error a negative value is returned, on success zero or the number
  * of bytes used to encode the data read from the input buffer.
  *)
@@ -3177,12 +3734,9 @@ function avcodec_encode_audio(avctx: PAVCodecContext; buf: PByte;
   cdecl; external av__codec;
 
 (**
- * Encodes a video frame from \p pict into \p buf.
- * The avcodec_encode_video() function encodes a video frame from the input
- * \p pict. To encode it, it makes use of the video codec which was coupled with
- * \p avctx using avcodec_open(). The resulting encoded bytes representing the
- * frame are stored in the output buffer \p buf. The input picture should be
- * stored using a specific format, namely \c avctx.pix_fmt.
+ * Encodes a video frame from pict into buf.
+ * The input picture should be
+ * stored using a specific format, namely avctx.pix_fmt.
  *
  * @param avctx the codec context
  * @param[out] buf the output buffer for the bitstream of encoded frame
@@ -3208,6 +3762,7 @@ function avcodec_close(avctx: PAVCodecContext): cint;
  * functions.
  *
  * @see register_avcodec
+ * @see avcodec_register
  * @see av_register_codec_parser
  * @see av_register_bitstream_filter
  *)
@@ -3226,7 +3781,7 @@ procedure avcodec_default_free_buffers(s: PAVCodecContext);
 (* misc useful functions *)
 
 (**
- * Returns a single letter to describe the given picture type \p pict_type.
+ * Returns a single letter to describe the given picture type pict_type.
  *
  * @param[in] pict_type the picture type
  * @return A single character representing the picture type.
@@ -3271,6 +3826,15 @@ type
     next_frame_offset: cint64; (* offset of the next frame *)
     (* video info *)
     pict_type: cint; (* XXX: put it back in AVCodecContext *)
+    (**
+     * This field is used for proper frame duration computation in lavf.
+     * It signals, how much longer the frame duration of the current frame
+     * is compared to normal frame duration.
+     *
+     * frame_duration = (1 + repeat_pict) * time_base
+     *
+     * It is used by codecs like H.264 to display telecined material.
+     *)
     repeat_pict: cint; (* XXX: put it back in AVCodecContext *)
     pts: cint64;     (* pts of the current frame *)
     dts: cint64;     (* dts of the current frame *)
@@ -3293,6 +3857,94 @@ type
     {$IF LIBAVCODEC_VERSION >= 51057001} // 51.57.1
     cur_frame_end: array [0..AV_PARSER_PTS_NB - 1] of cint64;
     {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52016000} // 52.16.0
+    (*!
+     * Set by parser to 1 for key frames and 0 for non-key frames.
+     * It is initialized to -1, so if the parser doesn't set this flag,
+     * old-style fallback using FF_I_TYPE picture type as key frames
+     * will be used.
+     *)
+    key_frame: cint;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52018000} // 52.18.0
+    (**
+     * Time difference in stream time base units from the pts of this
+     * packet to the point at which the output from the decoder has converged
+     * independent from the availability of previous frames. That is, the
+     * frames are virtually identical no matter if decoding started from
+     * the very first frame or from this keyframe.
+     * Is AV_NOPTS_VALUE if unknown.
+     * This field is not the display duration of the current frame.
+     *
+     * The purpose of this field is to allow seeking in streams that have no
+     * keyframes in the conventional sense. It corresponds to the
+     * recovery point SEI in H.264 and match_time_delta in NUT. It is also
+     * essential for some types of subtitle streams to ensure that all
+     * subtitles are correctly displayed after seeking.
+     *)
+    convergence_duration: cint64;
+    {$IFEND}
+    {$IF LIBAVCODEC_VERSION >= 52019000} // 52.19.0
+    // Timestamp generation support:
+    (**
+     * Synchronization point for start of timestamp generation.
+     *
+     * Set to >0 for sync point, 0 for no sync point and <0 for undefined
+     * (default).
+     *
+     * For example, this corresponds to presence of H.264 buffering period
+     * SEI message.
+     *)
+    dts_sync_point: cint;
+
+    (**
+     * Offset of the current timestamp against last timestamp sync point in
+     * units of AVCodecContext.time_base.
+     *
+     * Set to INT_MIN when dts_sync_point unused. Otherwise, it must
+     * contain a valid timestamp offset.
+     *
+     * Note that the timestamp of sync point has usually a nonzero
+     * dts_ref_dts_delta, which refers to the previous sync point. Offset of
+     * the next frame after timestamp sync point will be usually 1.
+     *
+     * For example, this corresponds to H.264 cpb_removal_delay.
+     *)
+    dts_ref_dts_delta: cint;
+
+    (**
+     * Presentation delay of current frame in units of AVCodecContext.time_base.
+     *
+     * Set to INT_MIN when dts_sync_point unused. Otherwise, it must
+     * contain valid non-negative timestamp delta (presentation time of a frame
+     * must not lie in the past).
+     *
+     * This delay represents the difference between decoding and presentation
+     * time of the frame.
+     *
+     * For example, this corresponds to H.264 dpb_output_delay.
+     *)
+    pts_dts_delta: cint;
+    {$IFEND}
+
+    {$IF LIBAVCODEC_VERSION >= 52021000} // 52.21.0
+    (**
+     * Position of the packet in file.
+     *
+     * Analogous to cur_frame_pts/dts
+     *)
+    cur_frame_pos: array [0..AV_PARSER_PTS_NB - 1] of cint64;
+
+    (**
+     * Byte position of currently parsed frame in stream.
+     *)
+    pos: cint64;
+
+    (**
+     * Previous frame byte position.
+     *)
+    last_pos: cint64;
+    {$IFEND}
   end;
 
   TAVCodecParser = record
@@ -3327,12 +3979,60 @@ procedure av_register_codec_parser(parser: PAVCodecParser);
 function av_parser_init(codec_id: cint): PAVCodecParserContext;
   cdecl; external av__codec;
 
+{$IF LIBAVCODEC_MAX_VERSION_MAJOR < 53}
 function av_parser_parse(s: PAVCodecParserContext;
                   avctx: PAVCodecContext;
-                  poutbuf: PPointer; poutbuf_size: PCint;
-                  buf: {const} PByteArray; buf_size: cint;
-                  pts: cint64; dts: cint64): cint;
-  cdecl; external av__codec;
+                  poutbuf: PPointer;
+                  poutbuf_size: PCint;
+                  buf: {const} PByteArray;
+                  buf_size: cint;
+                  pts: cint64;
+                  dts: cint64): cint;
+  cdecl; external av__codec; deprecated;
+{$IFEND}
+
+{$IF LIBAVCODEC_VERSION >= 52021000} // 52.21.0
+(**
+ * Parse a packet.
+ *
+ * @param s             parser context.
+ * @param avctx         codec context.
+ * @param poutbuf       set to pointer to parsed buffer or NULL if not yet finished.
+ * @param poutbuf_size  set to size of parsed buffer or zero if not yet finished.
+ * @param buf           input buffer.
+ * @param buf_size      input length, to signal EOF, this should be 0 (so that the last frame can be output).
+ * @param pts           input presentation timestamp.
+ * @param dts           input decoding timestamp.
+ * @param pos           input byte position in stream.
+ * @return the number of bytes of the input bitstream used.
+ *
+ * Example:
+ * @code
+ *   while (in_len) do
+ *   begin
+ *     len := av_parser_parse2(myparser, AVCodecContext, data, size,
+ *                                       in_data, in_len,
+ *                                       pts, dts, pos);
+ *      in_data := in_data + len;
+ *      in_len  := in_len  - len;
+ *
+ *      if (size) then
+ *        decode_frame(data, size);
+ *   end;
+ * @endcode
+ *)
+function av_parser_parse2(s:    PAVCodecParserContext;
+                  avctx:        PAVCodecContext;
+                  poutbuf:      PPointer;
+                  poutbuf_size: PCint;
+                  buf: {const}  PByteArray;
+                  buf_size:     cint;
+                  pts:          cint64;
+                  dts:          cint64;
+                  pos:          cint64): cint;
+   cdecl; external av__codec;
+{$IFEND}
+
 function av_parser_change(s: PAVCodecParserContext;
                    avctx: PAVCodecContext;
                    poutbuf: PPointer; poutbuf_size: PCint;
@@ -3395,6 +4095,22 @@ function av_bitstream_filter_next(f: PAVBitStreamFilter): PAVBitStreamFilter;
 procedure av_fast_realloc(ptr: pointer; size: PCuint; min_size: cuint);
   cdecl; external av__codec;
 
+{$IF LIBAVCODEC_VERSION < 52025000} // 52.25.0
+(**
+ * Allocates a buffer, reusing the given one if large enough.
+ *
+ * Contrary to av_fast_realloc the current buffer contents might not be
+ * preserved and on error the old buffer is freed, thus no special
+ * handling to avoid memleaks is necessary.
+ *
+ * @param ptr pointer to pointer to already allocated buffer, overwritten with pointer to new buffer
+ * @param size size of the buffer *ptr points to
+ * @param min_size minimum size of *ptr buffer after returning, *ptr will be NULL and
+ *                 *size 0 if an error occurred.
+ *)
+procedure av_fast_malloc(ptr: pointer; size: PCuint; min_size: cuint);
+  cdecl; external av__codec;
+{$IFEND}
 
 {$IF LIBAVCODEC_VERSION < 51057000} // 51.57.0
 (* for static data only *)
@@ -3407,7 +4123,7 @@ procedure av_fast_realloc(ptr: pointer; size: PCuint; min_size: cuint);
  * and should correctly use static arrays
  *
  *)
-procedure  av_free_static();
+procedure av_free_static();
   cdecl; external av__codec; deprecated;
 
 (**
@@ -3433,22 +4149,49 @@ procedure av_realloc_static(ptr: pointer; size: cuint);
 (**
  * Copy image 'src' to 'dst'.
  *)
-procedure av_picture_copy(dst: PAVPicture; src: {const} PAVPicture;
-              pix_fmt: cint; width: cint; height: cint);
+procedure av_picture_copy(dst: PAVPicture; 
+              src: {const} PAVPicture;
+{$IF LIBAVCODEC_VERSION < 52022001} // 52.22.1
+              pix_fmt: cint;
+{$ELSE}
+              pix_fmt: TAVPixelFormat;
+{$IFEND}
+              width:  cint;
+              height: cint);
   cdecl; external av__codec;
 
 (**
  * Crop image top and left side.
  *)
-function av_picture_crop(dst: PAVPicture; src: {const} PAVPicture;
-             pix_fmt: cint; top_band: cint; left_band: cint): cint;
+function av_picture_crop(dst: PAVPicture;
+              src: {const} PAVPicture;
+{$IF LIBAVCODEC_VERSION < 52022001} // 52.22.1
+              pix_fmt: cint;
+{$ELSE}
+              pix_fmt: TAVPixelFormat;
+{$IFEND}
+              top_band:  cint;
+              left_band: cint): cint;
   cdecl; external av__codec;
 
 (**
  * Pad image.
  *)
-function av_picture_pad(dst: PAVPicture; src: {const} PAVPicture; height: cint; width: cint; pix_fmt: cint;
-            padtop: cint; padbottom: cint; padleft: cint; padright: cint; color: PCint): cint;
+function av_picture_pad(dst: PAVPicture;
+            src: {const} PAVPicture;
+            height: cint;
+            width: cint;
+{$IF LIBAVCODEC_VERSION < 52022001} // 52.22.1
+            pix_fmt: cint;
+{$ELSE}
+            pix_fmt: TAVPixelFormat;
+{$IFEND}
+            padtop: cint;
+            padbottom: cint;
+            padleft: cint;
+            padright:
+            cint;
+            color: PCint): cint;
   cdecl; external av__codec;
 {$IFEND}
 
@@ -3481,7 +4224,7 @@ function av_xiphlacing(s: PByte; v: cuint): cuint;
 
 {$IF LIBAVCODEC_VERSION >= 51041000} // 51.41.0
 (**
- * Parses \p str and put in \p width_ptr and \p height_ptr the detected values.
+ * Parses str and put in width_ptr and height_ptr the detected values.
  *
  * @return 0 in case of a successful parsing, a negative value otherwise
  * @param[in] str the string to parse: it has to be a string in the format
@@ -3495,11 +4238,11 @@ function av_parse_video_frame_size(width_ptr: PCint; height_ptr: PCint; str: {co
   cdecl; external av__codec;
 
 (**
- * Parses \p str and put in \p frame_rate the detected values.
+ * Parses str and put in frame_rate the detected values.
  *
  * @return 0 in case of a successful parsing, a negative value otherwise
  * @param[in] str the string to parse: it has to be a string in the format
- * <frame_rate_nom>/<frame_rate_den>, a float number or a valid video rate abbreviation
+ * <frame_rate_num>/<frame_rate_den>, a float number or a valid video rate abbreviation
  * @param[in,out] frame_rate pointer to the AVRational which will contain the detected
  * frame rate
  *)
@@ -3559,11 +4302,75 @@ const
   AVERROR_NOMEM       = AVERROR_SIGN * ENOMEM;  (**< not enough memory *)
   AVERROR_NOFMT       = AVERROR_SIGN * EILSEQ;  (**< unknown format *)
   AVERROR_NOTSUPP     = AVERROR_SIGN * ENOSYS;  (**< Operation not supported. *)
-  AVERROR_NOENT       = AVERROR_SIGN * ENOENT;  {**< No such file or directory. *}
+  AVERROR_NOENT       = AVERROR_SIGN * ENOENT;  (**< No such file or directory. *)
+{$IF LIBAVCODEC_VERSION >= 52017000} // 52.17.0
+  AVERROR_EOF         = AVERROR_SIGN * EPIPE;   (**< End of file. *)
+{$IFEND}
   // Note: function calls as constant-initializers are invalid
   //AVERROR_PATCHWELCOME = -MKTAG('P','A','W','E'); {**< Not yet implemented in FFmpeg. Patches welcome. *}
   AVERROR_PATCHWELCOME = -(ord('P') or (ord('A') shl 8) or (ord('W') shl 16) or (ord('E') shl 24));
 
+{$IF LIBAVCODEC_VERSION >= 52018000} // 52.18.0
+(**
+ * Registers the hardware accelerator hwaccel.
+ *)
+procedure av_register_hwaccel (hwaccel: PAVHWAccel)
+  cdecl; external av__codec;
+
+(**
+ * If hwaccel is NULL, returns the first registered hardware accelerator,
+ * if hwaccel is non-NULL, returns the next registered hardware accelerator
+ * after hwaccel, or NULL if hwaccel is the last one.
+ *)
+function av_hwaccel_next (hwaccel: PAVHWAccel): PAVHWAccel;
+  cdecl; external av__codec;
+{$IFEND}
+
+{$IF LIBAVCODEC_VERSION >= 52030000} // 52.30.0
+(**
+ * Lock operation used by lockmgr
+ *)
+type
+  TAVLockOp = (
+    AV_LOCK_CREATE,  ///< Create a mutex
+    AV_LOCK_OBTAIN,  ///< Lock the mutex
+    AV_LOCK_RELEASE, ///< Unlock the mutex
+    AV_LOCK_DESTROY  ///< Free mutex resources
+  );
+
+(**
+ * Register a user provided lock manager supporting the operations
+ * specified by AVLockOp. mutex points to a (void *) where the
+ * lockmgr should store/get a pointer to a user allocated mutex. It's
+ * NULL upon AV_LOCK_CREATE and != NULL for all other ops.
+ *
+ * @param cb User defined callback. Note: FFmpeg may invoke calls to this
+ *           callback during the call to av_lockmgr_register().
+ *           Thus, the application must be prepared to handle that.
+ *           If cb is set to NULL the lockmgr will be unregistered.
+ *           Also note that during unregistration the previously registered
+ *           lockmgr callback may also be invoked.
+ *)
+function av_lockmgr_register(cb: function (mutex: Ppointer; op: TAVLockOp)): cint;
+  cdecl; external av__codec;
+{$IFEND}
+
 implementation
 
+{$IF (LIBAVCODEC_VERSION >= 52025000) and (LIBAVCODEC_VERSION <= 5202700)} // 52.25.0
+procedure av_free_packet(pkt: PAVPacket);{$IFDEF HASINLINE} inline; {$ENDIF} 
+begin
+  if (pkt <> nil) then
+  begin
+    if (pkt.destruct <> nil) then
+      pkt.destruct(pkt)
+    else
+    begin
+      pkt.data = NULL;
+      pkt.size = 0;
+    end;
+  end;
+end;
+{$IFEND}
+
 end.