more for ffmpeg7

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

4 files changed, 1005 insertions, 0 deletions

diff --git a/src/lib/ffmpeg7/ToDo.txt b/src/lib/ffmpeg7/ToDo.txt
new file mode 100644
index 00000000..e9591b56
--- /dev/null
+++ b/src/lib/ffmpeg7/ToDo.txt
@@ -0,0 +1,11 @@
+1)	rational.pas
+inline function of av_cmp_q
+
+	error.pas
+	opt.pas
+	mathematics.pas
+	avutil.pas
+	avcodec.pas
+	avio.pas
+	swscale.pas
+	avformat.pas
\ No newline at end of file
diff --git a/src/lib/ffmpeg7/avutil.pas b/src/lib/ffmpeg7/avutil.pas
new file mode 100644
index 00000000..e2cfd496
--- /dev/null
+++ b/src/lib/ffmpeg7/avutil.pas
@@ -0,0 +1,604 @@
+(*
+ * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * This is a part of Pascal porting of ffmpeg.
+ * - Originally by Victor Zinetz for Delphi and Free Pascal on Windows.
+ * - For Mac OS X, some modifications were made by The Creative CAT, denoted as CAT
+ *   in the source codes.
+ * - Changes and updates by the UltraStar Deluxe Team
+ *
+ * Conversions of
+ *
+ * libavutil/avutil.h:
+ * version: 50.43.0
+ *
+ * libavutil/mem.h:
+ *
+ * libavutil/log.h:
+ *
+ * include/keep pixfmt.h (change in revision 50.01.0)
+ * Maybe, the pixelformats are not needed, but it has not been checked.
+ * log.h is only partial.
+ *
+ *)
+
+unit avutil;
+
+{$IFDEF FPC}
+  {$MODE DELPHI}
+  {$PACKENUM 4}    (* use 4-byte enums *)
+  {$PACKRECORDS C} (* C/C++-compatible record packing *)
+{$ELSE}
+  {$MINENUMSIZE 4} (* use 4-byte enums *)
+{$ENDIF}
+
+{$IFDEF DARWIN}
+  {$linklib libavutil}
+{$ENDIF}
+
+interface
+
+uses
+  ctypes,
+  mathematics,
+  opt,
+  rational,
+  {$IFDEF UNIX}
+  BaseUnix,
+  {$ENDIF}
+  UConfig;
+
+const
+  (* Max. supported version by this header *)
+  LIBAVUTIL_MAX_VERSION_MAJOR   = 50;
+  LIBAVUTIL_MAX_VERSION_MINOR   = 43;
+  LIBAVUTIL_MAX_VERSION_RELEASE = 0;
+  LIBAVUTIL_MAX_VERSION = (LIBAVUTIL_MAX_VERSION_MAJOR * VERSION_MAJOR) +
+                          (LIBAVUTIL_MAX_VERSION_MINOR * VERSION_MINOR) +
+                          (LIBAVUTIL_MAX_VERSION_RELEASE * VERSION_RELEASE);
+
+  (* Min. supported version by this header *)
+  LIBAVUTIL_MIN_VERSION_MAJOR   = 50;
+  LIBAVUTIL_MIN_VERSION_MINOR   = 43;
+  LIBAVUTIL_MIN_VERSION_RELEASE = 0;
+  LIBAVUTIL_MIN_VERSION = (LIBAVUTIL_MIN_VERSION_MAJOR * VERSION_MAJOR) +
+                          (LIBAVUTIL_MIN_VERSION_MINOR * VERSION_MINOR) +
+                          (LIBAVUTIL_MIN_VERSION_RELEASE * VERSION_RELEASE);
+
+(* Check if linked versions are supported *)
+{$IF (LIBAVUTIL_VERSION < LIBAVUTIL_MIN_VERSION)}
+  {$MESSAGE Error 'Linked version of libavutil is too old!'}
+{$IFEND}
+
+{$IF (LIBAVUTIL_VERSION > LIBAVUTIL_MAX_VERSION)}
+  {$MESSAGE Error 'Linked version of libavutil is not yet supported!'}
+{$IFEND}
+
+(**
+ * Return the LIBAVUTIL_VERSION_INT constant.
+ *)
+function avutil_version(): cuint;
+  cdecl; external av__util;
+
+(**
+ * Return the libavutil build-time configuration.
+ *)
+function avutil_configuration(): PAnsiChar;
+  cdecl; external av__util;
+
+(**
+ * Return the libavutil license.
+ *)
+function avutil_license(): PAnsiChar;
+  cdecl; external av__util;
+
+type
+  TAVMediaType = (
+    AVMEDIA_TYPE_UNKNOWN = -1,
+    AVMEDIA_TYPE_VIDEO,
+    AVMEDIA_TYPE_AUDIO,
+    AVMEDIA_TYPE_DATA,
+    AVMEDIA_TYPE_SUBTITLE,
+    AVMEDIA_TYPE_ATTACHMENT,
+    AVMEDIA_TYPE_NB
+  );
+
+const
+  FF_LAMBDA_SHIFT = 7;
+  FF_LAMBDA_SCALE = (1<<FF_LAMBDA_SHIFT);
+  FF_QP2LAMBDA    = 118; ///< factor to convert from H.263 QP to lambda
+  FF_LAMBDA_MAX   = (256*128-1);
+ 
+  FF_QUALITY_SCALE = FF_LAMBDA_SCALE; //FIXME maybe remove
+ 
+  AV_NOPTS_VALUE   = $8000000000000000;
+  AV_TIME_BASE     = 1000000;
+  AV_TIME_BASE_Q   : TAVRational = (num: 1; den: AV_TIME_BASE);
+
+(**
+ * Those FF_API_* defines are not part of public API.
+ * They may change, break or disappear at any time.
+ *)
+{$IFNDEF FF_API_OLD_IMAGE_NAMES}
+  {$DEFINE FF_API_OLD_IMAGE_NAMES = (LIBAVUTIL_VERSION_MAJOR < 51)}
+{$ENDIF}
+type
+  TAVPictureType = (
+    AV_PICTURE_TYPE_I = 1, ///< Intra
+    AV_PICTURE_TYPE_P,     ///< Predicted
+    AV_PICTURE_TYPE_B,     ///< Bi-dir predicted
+    AV_PICTURE_TYPE_S,     ///< S(GMC)-VOP MPEG4
+    AV_PICTURE_TYPE_SI,    ///< Switching Intra
+    AV_PICTURE_TYPE_SP,    ///< Switching Predicted
+    AV_PICTURE_TYPE_BI     ///< BI type
+  );
+
+(**
+ * Return 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, '?' if pict_type is unknown
+ *)
+function av_get_picture_type_char(pict_type: TAVPictureType): Pchar;
+  cdecl; external av__util;
+
+{$INCLUDE error.pas}
+
+(* libavutil/pixfmt.h version: 50.43.0 *)
+
+type
+(**
+ * Pixel format. Notes:
+ *
+ * PIX_FMT_RGB32 is handled in an endian-specific manner. An RGBA
+ * color is put together as:
+ *  (A << 24) | (R << 16) | (G << 8) | B
+ * This is stored as BGRA on little-endian CPU architectures and ARGB on
+ * big-endian CPUs.
+ *
+ * When the pixel format is palettized RGB (PIX_FMT_PAL8), the palettized
+ * image data is stored in AVFrame.data[0]. The palette is transported in
+ * AVFrame.data[1], is 1024 bytes long (256 4-byte entries) and is
+ * formatted the same as in PIX_FMT_RGB32 described above (i.e., it is
+ * also endian-specific). Note also that the individual RGB palette
+ * components stored in AVFrame.data[1] should be in the range 0..255.
+ * This is important as many custom PAL8 video codecs that were designed
+ * to run on the IBM VGA graphics adapter use 6-bit palette components.
+ *
+ * For all the 8bit per pixel formats, an RGB32 palette is in data[1] like
+ * for pal8. This palette is filled in automatically by the function
+ * allocating the picture.
+ *
+ * Note, make sure that all newly added big endian formats have pix_fmt&1==1
+ *       and that all newly added little endian formats have pix_fmt&1==0
+ *       this allows simpler detection of big vs little endian.
+ *)
+
+  PAVPixelFormat = ^TAVPixelFormat;
+  TAVPixelFormat = (
+    PIX_FMT_NONE= -1,
+    PIX_FMT_YUV420P,   ///< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
+    PIX_FMT_YUYV422,   ///< packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
+    PIX_FMT_RGB24,     ///< packed RGB 8:8:8, 24bpp, RGBRGB...
+    PIX_FMT_BGR24,     ///< packed RGB 8:8:8, 24bpp, BGRBGR...
+    PIX_FMT_YUV422P,   ///< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
+    PIX_FMT_YUV444P,   ///< planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
+    PIX_FMT_YUV410P,   ///< planar YUV 4:1:0,  9bpp, (1 Cr & Cb sample per 4x4 Y samples)
+    PIX_FMT_YUV411P,   ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
+    PIX_FMT_GRAY8,     ///<        Y        ,  8bpp
+    PIX_FMT_MONOWHITE, ///<        Y        ,  1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb
+    PIX_FMT_MONOBLACK, ///<        Y        ,  1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb
+    PIX_FMT_PAL8,      ///< 8 bit with PIX_FMT_RGB32 palette
+    PIX_FMT_YUVJ420P,  ///< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV420P and setting color_range
+    PIX_FMT_YUVJ422P,  ///< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV422P and setting color_range
+    PIX_FMT_YUVJ444P,  ///< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV444P and setting color_range
+    PIX_FMT_XVMC_MPEG2_MC,///< XVideo Motion Acceleration via common packet passing
+    PIX_FMT_XVMC_MPEG2_IDCT,
+    PIX_FMT_UYVY422,   ///< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
+    PIX_FMT_UYYVYY411, ///< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
+    PIX_FMT_BGR8,      ///< packed RGB 3:3:2,  8bpp, (msb)2B 3G 3R(lsb)
+    PIX_FMT_BGR4,      ///< packed RGB 1:2:1 bitstream,  4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits
+    PIX_FMT_BGR4_BYTE, ///< packed RGB 1:2:1,  8bpp, (msb)1B 2G 1R(lsb)
+    PIX_FMT_RGB8,      ///< packed RGB 3:3:2,  8bpp, (msb)2R 3G 3B(lsb)
+    PIX_FMT_RGB4,      ///< packed RGB 1:2:1 bitstream,  4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits
+    PIX_FMT_RGB4_BYTE, ///< packed RGB 1:2:1,  8bpp, (msb)1R 2G 1B(lsb)
+    PIX_FMT_NV12,      ///< planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)
+    PIX_FMT_NV21,      ///< as above, but U and V bytes are swapped
+
+    PIX_FMT_ARGB,      ///< packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
+    PIX_FMT_RGBA,      ///< packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
+    PIX_FMT_ABGR,      ///< packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
+    PIX_FMT_BGRA,      ///< packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
+
+    PIX_FMT_GRAY16BE,  ///<        Y        , 16bpp, big-endian
+    PIX_FMT_GRAY16LE,  ///<        Y        , 16bpp, little-endian
+    PIX_FMT_YUV440P,   ///< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
+    PIX_FMT_YUVJ440P,  ///< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of PIX_FMT_YUV440P and setting color_range
+    PIX_FMT_YUVA420P,  ///< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
+    PIX_FMT_VDPAU_H264,///< H.264 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
+    PIX_FMT_VDPAU_MPEG1,///< MPEG-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
+    PIX_FMT_VDPAU_MPEG2,///< MPEG-2 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
+    PIX_FMT_VDPAU_WMV3,///< WMV3 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
+    PIX_FMT_VDPAU_VC1, ///< VC-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
+    PIX_FMT_RGB48BE,   ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian
+    PIX_FMT_RGB48LE,   ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as little-endian
+
+    PIX_FMT_RGB565BE,  ///< packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), big-endian
+    PIX_FMT_RGB565LE,  ///< packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), little-endian
+    PIX_FMT_RGB555BE,  ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), big-endian, most significant bit to 0
+    PIX_FMT_RGB555LE,  ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), little-endian, most significant bit to 0
+
+    PIX_FMT_BGR565BE,  ///< packed BGR 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), big-endian
+    PIX_FMT_BGR565LE,  ///< packed BGR 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), little-endian
+    PIX_FMT_BGR555BE,  ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), big-endian, most significant bit to 1
+    PIX_FMT_BGR555LE,  ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), little-endian, most significant bit to 1
+
+    PIX_FMT_VAAPI_MOCO, ///< HW acceleration through VA API at motion compensation entry-point, Picture.data[3] contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers
+    PIX_FMT_VAAPI_IDCT, ///< HW acceleration through VA API at IDCT entry-point, Picture.data[3] contains a vaapi_render_state struct which contains fields extracted from headers
+    PIX_FMT_VAAPI_VLD,  ///< HW decoding through VA API, Picture.data[3] contains a vaapi_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
+
+    PIX_FMT_YUV420P16LE,  ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
+    PIX_FMT_YUV420P16BE,  ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
+    PIX_FMT_YUV422P16LE,  ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
+    PIX_FMT_YUV422P16BE,  ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
+    PIX_FMT_YUV444P16LE,  ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
+    PIX_FMT_YUV444P16BE,  ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
+    PIX_FMT_VDPAU_MPEG4,  ///< MPEG4 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
+    PIX_FMT_DXVA2_VLD,    ///< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer
+
+    PIX_FMT_RGB444LE,  ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), little-endian, most significant bits to 0
+    PIX_FMT_RGB444BE,  ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), big-endian, most significant bits to 0
+    PIX_FMT_BGR444LE,  ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), little-endian, most significant bits to 1
+    PIX_FMT_BGR444BE,  ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), big-endian, most significant bits to 1
+    PIX_FMT_GRAY8A,    ///< 8bit gray, 8bit alpha
+    PIX_FMT_BGR48BE,   ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian
+    PIX_FMT_BGR48LE,   ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as little-endian
+
+    //the following 10 formats have the disadvantage of needing 1 format for each bit depth, thus
+    //If you want to support multiple bit depths, then using PIX_FMT_YUV420P16* with the bpp stored seperately
+    //is better
+    PIX_FMT_YUV420P9BE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
+    PIX_FMT_YUV420P9LE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
+    PIX_FMT_YUV420P10BE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
+    PIX_FMT_YUV420P10LE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
+    PIX_FMT_YUV422P10BE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
+    PIX_FMT_YUV422P10LE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
+    PIX_FMT_YUV444P9BE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
+    PIX_FMT_YUV444P9LE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
+    PIX_FMT_YUV444P10BE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
+    PIX_FMT_YUV444P10LE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
+
+    PIX_FMT_NB         ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
+  );
+
+const
+    PIX_FMT_Y400A   = PIX_FMT_GRAY8A;
+
+{$ifdef WORDS_BIGENDIAN}
+    PIX_FMT_RGB32   = PIX_FMT_ARGB;
+    PIX_FMT_RGB32_1 = PIX_FMT_RGBA;
+    PIX_FMT_BGR32   = PIX_FMT_ABGR;
+    PIX_FMT_BGR32_1 = PIX_FMT_BGRA;
+
+    PIX_FMT_GRAY16  = PIX_FMT_GRAY16BE;
+    PIX_FMT_RGB48   = PIX_FMT_RGB48BE;
+    PIX_FMT_RGB565  = PIX_FMT_RGB565BE;
+    PIX_FMT_RGB555  = PIX_FMT_RGB555BE;
+    PIX_FMT_RGB444  = PIX_FMT_RGB444BE;
+    PIX_FMT_BGR48   = PIX_FMT_BGR48BE;
+    PIX_FMT_BGR565  = PIX_FMT_BGR565BE;
+    PIX_FMT_BGR555  = PIX_FMT_BGR555BE;
+    PIX_FMT_BGR444  = PIX_FMT_BGR444BE;
+
+    PIX_FMT_YUV420P9  = PIX_FMT_YUV420P9BE;
+    PIX_FMT_YUV444P9  = PIX_FMT_YUV444P9BE;
+    PIX_FMT_YUV420P10 = PIX_FMT_YUV420P10BE;
+    PIX_FMT_YUV422P10 = PIX_FMT_YUV422P10BE;
+    PIX_FMT_YUV444P10 = PIX_FMT_YUV444P10BE;
+    PIX_FMT_YUV420P16 = PIX_FMT_YUV420P16BE;
+    PIX_FMT_YUV422P16 = PIX_FMT_YUV422P16BE;
+    PIX_FMT_YUV444P16 = PIX_FMT_YUV444P16BE;
+{$else}
+    PIX_FMT_RGB32   = PIX_FMT_BGRA;
+    PIX_FMT_RGB32_1 = PIX_FMT_ABGR;
+    PIX_FMT_BGR32   = PIX_FMT_RGBA;
+    PIX_FMT_BGR32_1 = PIX_FMT_ARGB;
+
+    PIX_FMT_GRAY16  = PIX_FMT_GRAY16LE;
+    PIX_FMT_RGB48   = PIX_FMT_RGB48LE;
+    PIX_FMT_RGB565  = PIX_FMT_RGB565LE;
+    PIX_FMT_RGB555  = PIX_FMT_RGB555LE;
+    PIX_FMT_RGB444  = PIX_FMT_RGB444LE;
+    PIX_FMT_BGR48   = PIX_FMT_BGR48LE;
+    PIX_FMT_BGR565  = PIX_FMT_BGR565LE;
+    PIX_FMT_BGR555  = PIX_FMT_BGR555LE;
+    PIX_FMT_BGR444  = PIX_FMT_BGR444LE;
+
+    PIX_FMT_YUV420P9  = PIX_FMT_YUV420P9LE;
+    PIX_FMT_YUV444P9  = PIX_FMT_YUV444P9LE;
+    PIX_FMT_YUV420P10 = PIX_FMT_YUV420P10LE;
+    PIX_FMT_YUV422P10 = PIX_FMT_YUV422P10LE;
+    PIX_FMT_YUV444P10 = PIX_FMT_YUV444P10LE;
+    PIX_FMT_YUV420P16 = PIX_FMT_YUV420P16LE;
+    PIX_FMT_YUV422P16 = PIX_FMT_YUV422P16LE;
+    PIX_FMT_YUV444P16 = PIX_FMT_YUV444P16LE;
+{$ENDIF}
+
+(* libavutil/common.h *) // until now MKTAG and MKBETAG is all from common.h KMS 19/5/2010
+
+function MKTAG  (a, b, c, d: AnsiChar): integer;
+function MKBETAG(a, b, c, d: AnsiChar): integer;
+
+(* libavutil/mem.h *)
+
+(* memory handling functions *)
+
+type
+  FF_INTERNAL_MEM_TYPE = cuint;
+  
+(**
+ * Allocate a block of size bytes with alignment suitable for all
+ * memory accesses (including vectors if available on the CPU).
+ * @param size Size in bytes for the memory block to be allocated.
+ * @return Pointer to the allocated block, NULL if the block cannot
+ * be allocated.
+ * @see av_mallocz()
+ *)
+function av_malloc(size: FF_INTERNAL_MEM_TYPE): pointer;
+  cdecl; external av__util; {av_malloc_attrib av_alloc_size(1)}
+
+(**
+ * Allocate or reallocate a block of memory.
+ * If ptr is NULL and size > 0, allocate a new block. If 
+ * size is zero, free the memory block pointed to by ptr.
+ * @param size Size in bytes for the memory block to be allocated or
+ * reallocated.
+ * @param ptr Pointer to a memory block already allocated with
+ * av_malloc(z)() or av_realloc() or NULL.
+ * @return Pointer to a newly reallocated block or NULL if the block
+ * cannot be allocated or the function is used to free the memory block.
+ * @see av_fast_realloc()
+ *)
+function av_realloc(ptr: pointer; size: FF_INTERNAL_MEM_TYPE): pointer;
+  cdecl; external av__util; {av_alloc_size(2)}
+
+(**
+ * Free a memory block which has been allocated with av_malloc(z)() or
+ * av_realloc().
+ * @param ptr Pointer to the memory block which should be freed.
+ * @note ptr = NULL is explicitly allowed.
+ * @note It is recommended that you use av_freep() instead.
+ * @see av_freep()
+ *)
+procedure av_free(ptr: pointer);
+  cdecl; external av__util;
+
+(**
+ * Allocate a block of size bytes with alignment suitable for all
+ * memory accesses (including vectors if available on the CPU) and
+ * zeroes all the bytes of the block.
+ * @param size Size in bytes for the memory block to be allocated.
+ * @return Pointer to the allocated block, NULL if it cannot be allocated.
+ * @see av_malloc()
+ *)
+function av_mallocz(size: FF_INTERNAL_MEM_TYPE): pointer;
+  cdecl; external av__util; {av_malloc_attrib av_alloc_size(1)}
+
+(**
+ * Duplicate the string s.
+ * @param s string to be duplicated.
+ * @return Pointer to a newly allocated string containing a
+ * copy of s or NULL if the string cannot be allocated.
+ *)
+function av_strdup({const} s: PAnsiChar): PAnsiChar;
+  cdecl; external av__util; {av_malloc_attrib}
+
+(**
+ * Free a memory block which has been allocated with av_malloc(z)() or
+ * av_realloc() and set the pointer pointing to it to NULL.
+ * @param ptr Pointer to the pointer to the memory block which should
+ * be freed.
+ * @see av_free()
+ *)
+procedure av_freep (ptr: pointer);
+  cdecl; external av__util;
+
+(**
+ * Add an element to a dynamic array.
+ *
+ * @param tab_ptr Pointer to the array.
+ * @param nb_ptr  Pointer to the number of elements in the array.
+ * @param elem    Element to be added.
+ *)
+procedure av_dynarray_add(tab_ptr: pointer; nb_ptr: PCint; elem: pointer);
+  cdecl; external av__util;
+
+(* libavutil/log.h *)
+
+type
+(**
+ * Describe the class of an AVClass context structure. That is an
+ * arbitrary struct of which the first field is a pointer to an
+ * AVClass struct (e.g. AVCodecContext, AVFormatContext etc.).
+ *)
+  PAVClass = ^TAVClass;
+  TAVClass = record
+    (**
+     * The name of the class; usually it is the same name as the
+     * context structure type to which the AVClass is associated.
+     *)
+    class_name: PAnsiChar;
+
+    (**
+     * A pointer to a function which returns the name of a context
+     * instance ctx associated with the class.
+     *)
+    item_name: function(): PAnsiChar; cdecl;
+
+    (**
+     * a pointer to the first option specified in the class if any or NULL
+     *
+     * @see av_set_default_options()
+     *)
+    option: PAVOption;
+
+    (**
+     * LIBAVUTIL_VERSION with which this structure was created.
+     * This is used to allow fields to be added without requiring major
+     * version bumps everywhere.
+     *)
+    version: cint;
+
+    (**
+     * Offset in the structure where log_level_offset is stored.
+     * 0 means there is no such variable
+     *)
+    log_level_offset_offset: cint;
+
+    (**
+     * Offset in the structure where a pointer to the parent context for loging is stored.
+     * for example a decoder that uses eval.c could pass its AVCodecContext to eval as such
+     * parent context. And a av_log() implementation could then display the parent context
+     * can be NULL of course
+     *)
+    parent_log_context_offset: cint;
+    
+    (**
+     * A function for extended searching, e.g. in possible
+     * children objects.
+     *)
+    opt_find: function(): PAVOption; cdecl;
+  end;
+
+
+const
+  AV_LOG_QUIET   = -8;
+
+(**
+ * Something went really wrong and we will crash now.
+ *)
+  AV_LOG_PANIC   =  0;
+
+(**
+ * Something went wrong and recovery is not possible.
+ * For example, no header was found for a format which depends
+ * on headers or an illegal combination of parameters is used.
+ *)
+  AV_LOG_FATAL   =  8;
+
+(**
+ * Something went wrong and cannot losslessly be recovered.
+ * However, not all future data is affected.
+ *)
+  AV_LOG_ERROR   = 16;
+
+(**
+ * Something somehow does not look correct. This may or may not
+ * lead to problems. An example would be the use of '-vstrict -2'.
+ *)
+  AV_LOG_WARNING = 24;
+
+  AV_LOG_INFO    = 32;
+  AV_LOG_VERBOSE = 40;
+
+(**
+ * Stuff which is only useful for libav* developers.
+ *)
+  AV_LOG_DEBUG   = 48;
+
+(**
+ * Send the specified message to the log if the level is less than or equal
+ * to the current av_log_level. By default, all logging messages are sent to
+ * stderr. This behavior can be altered by setting a different av_vlog callback
+ * function.
+ *
+ * @param avcl A pointer to an arbitrary struct of which the first field is a
+ * pointer to an AVClass struct.
+ * @param level The importance level of the message, lower values signifying
+ * higher importance.
+ * @param fmt The format string (printf-compatible) that specifies how
+ * subsequent arguments are converted to output.
+ * @see av_vlog
+ *)
+
+{** to be translated if needed
+#ifdef __GNUC__
+void av_log(void*, int level, const char *fmt, ...) __attribute__ ((__format__ (__printf__, 3, 4)));
+#else
+void av_log(void*, int level, const char *fmt, ...);
+#endif
+**}
+
+type
+  va_list = pointer;
+
+procedure av_vlog(avcl: pointer; level: cint; fmt: {const} PAnsiChar; dummy: va_list);
+  cdecl; external av__util;
+function av_log_get_level(): cint;
+  cdecl; external av__util;
+procedure av_log_set_level(level: cint);
+  cdecl; external av__util;
+
+{** to be translated if needed
+void av_log_set_callback(void (*)(void*, int, const char*, va_list));
+void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl);
+**}
+
+function av_default_item_name (ctx: pointer): PAnsiChar;
+  cdecl; external av__util;
+
+(**
+ * av_dlog macros
+ * Useful to print debug messages that shouldn't get compiled in normally.
+ *)
+(** to be translated if needed
+#ifdef DEBUG
+#    define av_dlog(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__)
+#else
+#    define av_dlog(pctx, ...) do { if (0) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__); } while (0)
+#endif
+**)
+
+(**
+ * Skip repeated messages, this requires the user app to use av_log() instead of
+ * (f)printf as the 2 would otherwise interfere and lead to
+ * "Last message repeated x times" messages below (f)printf messages with some
+ * bad luck.
+ * Also to receive the last, "last repeated" line if any, the user app must
+ * call av_log(NULL, AV_LOG_QUIET, "%s", ""); at the end
+ *)
+const
+  AV_LOG_SKIP_REPEATED = 1;
+procedure av_log_set_flags(arg: cint);
+  cdecl; external av__util;
+
+implementation
+
+(* libavutil/common.h *)
+
+function MKTAG(a, b, c, d: AnsiChar): integer;
+begin
+  Result := (ord(a) or (ord(b) shl 8) or (ord(c) shl 16) or (ord(d) shl 24));
+end;
+
+function MKBETAG(a, b, c, d: AnsiChar): integer;
+begin
+  Result := (ord(d) or (ord(c) shl 8) or (ord(b) shl 16) or (ord(a) shl 24));
+end;
+
+end.
diff --git a/src/lib/ffmpeg7/dict.pas b/src/lib/ffmpeg7/dict.pas
new file mode 100644
index 00000000..ec2e96da
--- /dev/null
+++ b/src/lib/ffmpeg7/dict.pas
@@ -0,0 +1,109 @@
+(*
+ * AVDictionary
+ * copyright (c) 2011 Karl-Michael Schindler <karl-michael.schindler@web.de>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * This is a part of the Pascal port of ffmpeg.
+ *
+ * Conversion of libavutil/dict.h
+ * avutil version 50.43.0
+ *
+ *)
+
+unit dict;
+
+{$IFDEF FPC}
+  {$MODE DELPHI}
+  {$PACKENUM 4}    (* use 4-byte enums *)
+  {$PACKRECORDS C} (* C/C++-compatible record packing *)
+{$ELSE}
+  {$MINENUMSIZE 4} (* use 4-byte enums *)
+{$ENDIF}
+
+interface
+
+uses
+  ctypes,
+  UConfig;
+
+const
+  AV_DICT_MATCH_CASE      = 1;
+  AV_DICT_IGNORE_SUFFIX   = 2;
+  AV_DICT_DONT_STRDUP_KEY = 4;
+  AV_DICT_DONT_STRDUP_VAL = 8;
+  AV_DICT_DONT_OVERWRITE  = 16;   ///< Don't overwrite existing entries.
+  AV_DICT_APPEND          = 32;   (**< If the entry already exists, append to it.  Note that no
+                                      delimiter is added, the strings are simply concatenated. *)
+
+type
+  PAVDictionaryEntry = ^TAVDictionaryEntry;
+  TAVDictionaryEntry = record
+    key:   PAnsiChar;
+    value: PAnsiChar;
+  end;
+  
+(* with the "help" of libavutil/internal.h: *)
+
+  PAVDictionary = ^TAVDictionary;
+  TAVDictionary = record
+    count: cint;
+    elems: PAVDictionaryEntry;
+  end;
+
+(**
+ * Get a dictionary entry with matching key.
+ *
+ * @param prev Set to the previous matching element to find the next.
+ *             If set to NULL the first matching element is returned.
+ * @param flags Allows case as well as suffix-insensitive comparisons.
+ * @return Found entry or NULL, changing key or value leads to undefined behavior.
+ *)
+function av_dict_get(m: PAVDictionary; {const} key: PAnsiChar; {const} prev: PAVDictionaryEntry; flags: cint): PAVDictionaryEntry;
+  cdecl; external av__util;
+
+(**
+ * Set the given entry in *pm, overwriting an existing entry.
+ *
+ * @param pm pointer to a pointer to a dictionary struct. If *pm is NULL
+ * a dictionary struct is allocated and put in *pm.
+ * @param key entry key to add to *pm (will be av_strduped depending on flags)
+ * @param value entry value to add to *pm (will be av_strduped depending on flags).
+ *        Passing a NULL value will cause an existing tag to be deleted.
+ * @return >= 0 on success otherwise an error code <0
+ *)
+function av_dict_set(var pm: PAVDictionary; {const} key: PAnsiChar; {const} value: PAnsiChar; flags: cint): cint;
+  cdecl; external av__util;
+
+(**
+ * Copy entries from one AVDictionary struct into another.
+ * @param dst pointer to a pointer to a AVDictionary struct. If *dst is NULL,
+ *            this function will allocate a struct for you and put it in *dst
+ * @param src pointer to source AVDictionary struct
+ * @param flags flags to use when setting entries in *dst
+ * @note metadata is read using the AV_DICT_IGNORE_SUFFIX flag
+ *)
+procedure av_dict_copy(var dst: PAVDictionary; src: PAVDictionary; flags: cint);
+  cdecl; external av__util;
+
+(**
+ * Free all the memory allocated for an AVDictionary struct.
+ *)
+procedure av_dict_free(var m: PAVDictionary);
+  cdecl; external av__util;
+
+implementation
+
+end.
diff --git a/src/lib/ffmpeg7/opt.pas b/src/lib/ffmpeg7/opt.pas
new file mode 100644
index 00000000..a779056e
--- /dev/null
+++ b/src/lib/ffmpeg7/opt.pas
@@ -0,0 +1,281 @@
+(*
+ * AVOptions
+ * copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * This is a part of Pascal porting of ffmpeg.
+ * - Originally by Victor Zinetz for Delphi and Free Pascal on Windows.
+ * - For Mac OS X, some modifications were made by The Creative CAT, denoted as CAT
+ *   in the source codes.
+ * - Changes and updates by the UltraStar Deluxe Team
+ *
+ * Conversion of libavutil/opt.h
+ * avutil version 50.43.0
+ *
+ *)
+
+unit opt;
+
+{$IFDEF FPC}
+  {$MODE DELPHI}
+  {$PACKENUM 4}    (* use 4-byte enums *)
+  {$PACKRECORDS C} (* C/C++-compatible record packing *)
+{$ELSE}
+  {$MINENUMSIZE 4} (* use 4-byte enums *)
+{$ENDIF}
+
+interface
+
+uses
+  ctypes,
+  dict,
+  rational,
+  UConfig;
+
+type
+  TAVOptionType = (
+    FF_OPT_TYPE_FLAGS,
+    FF_OPT_TYPE_INT,
+    FF_OPT_TYPE_INT64,
+    FF_OPT_TYPE_DOUBLE,
+    FF_OPT_TYPE_FLOAT,
+    FF_OPT_TYPE_STRING,
+    FF_OPT_TYPE_RATIONAL,
+    FF_OPT_TYPE_BINARY,  ///< offset must point to a pointer immediately followed by an int for the length
+    FF_OPT_TYPE_CONST = 128
+  );
+
+const
+  AV_OPT_FLAG_ENCODING_PARAM  = 1;   ///< a generic parameter which can be set by the user for muxing or encoding
+  AV_OPT_FLAG_DECODING_PARAM  = 2;   ///< a generic parameter which can be set by the user for demuxing or decoding
+  AV_OPT_FLAG_METADATA        = 4;   ///< some data extracted or inserted into the file like title, comment, ...
+  AV_OPT_FLAG_AUDIO_PARAM     = 8;
+  AV_OPT_FLAG_VIDEO_PARAM     = 16;
+  AV_OPT_FLAG_SUBTITLE_PARAM  = 32;
+
+type
+  (**
+   * AVOption
+   *)
+  PAVOption = ^TAVOption;
+  TAVOption = record
+    name: {const} PAnsiChar;
+    
+    (**
+     * short English help text
+     * @todo What about other languages?
+     *)
+    help: {const} PAnsiChar;
+
+    (**
+     * The offset relative to the context structure where the option
+     * value is stored. It should be 0 for named constants.
+     *)
+    offset: cint;
+    type_: TAVOptionType;
+
+    (**
+     * the default value for scalar options
+     *)
+    default_val: record
+      case cint of
+        0: (dbl: cdouble);
+        1: (str: PAnsiChar);
+        (* TODO those are unused now *)
+        2: (i64: cint64);
+        3: (q: TAVRational);
+      end;
+    min: cdouble;                ///< minimum valid value for the option
+    max: cdouble;                ///< maximum valid value for the option
+
+    flags: cint;
+//FIXME think about enc-audio, ... style flags
+
+    (**
+     * The logical unit to which the option belongs. Non-constant
+     * options and corresponding named constants share the same
+     * unit. May be NULL.
+     *)
+    unit_: {const} PAnsiChar;
+  end;
+
+{$IFDEF FF_API_FIND_OPT}
+(**
+ * Look for an option in obj. Look only for the options which
+ * have the flags set as specified in mask and flags (that is,
+ * for which it is the case that opt->flags & mask == flags).
+ *
+ * @param[in] obj a pointer to a struct whose first element is a
+ * pointer to an AVClass
+ * @param[in] name the name of the option to look for
+ * @param[in] unit the unit of the option to look for, or any if NULL
+ * @return a pointer to the option found, or NULL if no option
+ * has been found
+ *)
+function av_find_opt(obj: Pointer; {const} name: {const} PAnsiChar; {const} unit_: PAnsiChar; mask: cint; flags: cint): {const} PAVOption;
+  cdecl; external av__util; deprecated;
+{$ENDIF}
+
+(**
+ * Set the field of obj with the given name to value.
+ *
+ * @param[in] obj A struct whose first element is a pointer to an
+ * AVClass.
+ * @param[in] name the name of the field to set
+ * @param[in] val The value to set. If the field is not of a string
+ * type, then the given string is parsed.
+ * SI postfixes and some named scalars are supported.
+ * If the field is of a numeric type, it has to be a numeric or named
+ * scalar. Behavior with more than one scalar and +- infix operators
+ * is undefined.
+ * If the field is of a flags type, it has to be a sequence of numeric
+ * scalars or named flags separated by '+' or '-'. Prefixing a flag
+ * with '+' causes it to be set without affecting the other flags;
+ * similarly, '-' unsets a flag.
+ * @param[out] o_out if non-NULL put here a pointer to the AVOption
+ * found
+ * @param alloc when 1 then the old value will be av_freed() and the
+ *                     new av_strduped()
+ *              when 0 then no av_free() nor av_strdup() will be used
+ * @return 0 if the value has been set, or an AVERROR code in case of
+ * error:
+ * AVERROR(ENOENT) if no matching option exists
+ * AVERROR(ERANGE) if the value is out of range
+ * AVERROR(EINVAL) if the value is not valid
+ *)
+function av_set_string3(obj: Pointer; name: {const} PAnsiChar; val: {const} PAnsiChar; alloc: cint; out o_out: {const} PAVOption): cint;
+  cdecl; external av__util;
+
+function av_set_double(obj: pointer; name: {const} PAnsiChar; n: cdouble): PAVOption;
+  cdecl; external av__util;
+function av_set_q(obj: pointer; name: {const} PAnsiChar; n: TAVRational): PAVOption;
+  cdecl; external av__util;
+function av_set_int(obj: pointer; name: {const} PAnsiChar; n: cint64): PAVOption;
+  cdecl; external av__util;
+function av_get_double(obj: pointer; name: {const} PAnsiChar; var o_out: {const} PAVOption): cdouble;
+  cdecl; external av__util;
+function av_get_q(obj: pointer; name: {const} PAnsiChar; var o_out: {const} PAVOption): TAVRational;
+  cdecl; external av__util;
+function av_get_int(obj: pointer; name: {const} PAnsiChar; var o_out: {const} PAVOption): cint64;
+  cdecl; external av__util;
+function av_get_string(obj: pointer; name: {const} PAnsiChar; var o_out: {const} PAVOption; buf: PAnsiChar; buf_len: cint): PAnsiChar;
+  cdecl; external av__util;
+function av_next_option(obj: pointer; last: {const} PAVOption): PAVOption;
+  cdecl; external av__util;
+
+(**
+ * Show the obj options.
+ *
+ * @param req_flags requested flags for the options to show. Show only the
+ * options for which it is opt->flags & req_flags.
+ * @param rej_flags rejected flags for the options to show. Show only the
+ * options for which it is !(opt->flags & req_flags).
+ * @param av_log_obj log context to use for showing the options
+ *)
+function av_opt_show2(obj: pointer; av_log_obj: pointer; req_flags: cint; rej_flags: cint): cint;
+  cdecl; external av__util;
+
+procedure av_opt_set_defaults(s: pointer);
+  cdecl; external av__util;
+procedure av_opt_set_defaults2(s: Pointer; mask: cint; flags: cint);
+  cdecl; external av__util;
+
+(**
+ * Parse the key/value pairs list in opts. For each key/value pair
+ * found, stores the value in the field in ctx that is named like the
+ * key. ctx must be an AVClass context, storing is done using
+ * AVOptions.
+ *
+ * @param opts options string to parse, may be NULL
+ * @param key_val_sep a 0-terminated list of characters used to
+ * separate key from value
+ * @param pairs_sep a 0-terminated list of characters used to separate
+ * two pairs from each other
+ * @return the number of successfully set key/value pairs, or a negative
+ * value corresponding to an AVERROR code in case of error:
+ * AVERROR(EINVAL) if opts cannot be parsed,
+ * the error code issued by av_set_string3() if a key/value pair
+ * cannot be set
+*)
+function av_set_options_string(ctx: pointer; opts: {const} PAnsiChar;
+                      key_val_sep: {const} PAnsiChar; pairs_sep: {const} PAnsiChar): cint;
+  cdecl; external av__util;
+
+(**
+ * Free all string and binary options in obj.
+ *)
+procedure av_opt_free(obj: pointer);
+  cdecl; external av__util;
+
+(**
+ * Check whether a particular flag is set in a flags field.
+ *
+ * @param field_name the name of the flag field option
+ * @param flag_name the name of the flag to check
+ * @return non-zero if the flag is set, zero if the flag isn't set,
+ *         isn't of the right type, or the flags field doesn't exist.
+ *)
+function av_opt_flag_is_set(obj: pointer; field_name: {const} PAnsiChar; flag_name: {const} PAnsiChar): cint;
+  cdecl; external av__util;
+
+(**
+ * Set all the options from a given dictionary on an object.
+ *
+ * @param obj a struct whose first element is a pointer to AVClass
+ * @param options options to process. This dictionary will be freed and replaced
+ *                by a new one containing all options not found in obj.
+ *                Of course this new dictionary needs to be freed by caller
+ *                with av_dict_free().
+ *
+ * @return 0 on success, a negative AVERROR if some option was found in obj,
+ *         but could not be set.
+ *
+ * @see av_dict_copy()
+ *)
+function av_opt_set_dict(obj: pointer; var options: PAVDictionary): cint;
+  cdecl; external av__util;
+
+const
+  AV_OPT_SEARCH_CHILDREN = 0001; (**< Search in possible children of the
+                                      given object first.*)
+
+(**
+ * Look for an option in an object. Consider only options which
+ * have all the specified flags set.
+ *
+ * @param[in] obj A pointer to a struct whose first element is a
+ *                pointer to an AVClass.
+ * @param[in] name The name of the option to look for.
+ * @param[in] unit When searching for named constants, name of the unit
+ *                 it belongs to.
+ * @param opt_flags Find only options with all the specified flags set (AV_OPT_FLAG).
+ * @param search_flags A combination of AV_OPT_SEARCH_*.
+ *
+ * @return A pointer to the option found, or NULL if no option
+ *         was found.
+ *
+ * @note Options found with AV_OPT_SEARCH_CHILDREN flag may not be settable
+ * directly with av_set_string3(). Use special calls which take an options
+ * AVDictionary (e.g. avformat_open_input()) to set options found with this
+ * flag.
+ *)
+function av_opt_find(obj: pointer; name: {const} PAnsiChar; unit_: {const} PAnsiChar;
+                             opt_flags: cint; search_flags: cint): PAVOption;
+  cdecl; external av__util;
+
+implementation
+
+end.