diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/lib/ffmpeg7/ToDo.txt | 11 | ||||
| -rw-r--r-- | src/lib/ffmpeg7/avutil.pas | 604 | ||||
| -rw-r--r-- | src/lib/ffmpeg7/dict.pas | 109 | ||||
| -rw-r--r-- | src/lib/ffmpeg7/opt.pas | 281 |
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. |