From bd0393026e4536775fc3cee78057231f2ae96d12 Mon Sep 17 00:00:00 2001 From: Olivier Huber Date: Fri, 17 Dec 2010 12:11:58 +0100 Subject: update mplayer, works w/ mpeg2 --- media-video/mplayer/Manifest | 6 + .../files/vaapi-take2/01-mplayer-vaapi.patch | 3906 ++++++++++++++++++++ .../02-mplayer-vaapi-gma500-workaround.patch | 97 + .../files/vaapi-take2/03-mplayer-vaapi-0.29.patch | 675 ++++ .../files/vaapi-take2/04-mplayer-vdpau.patch | 1243 +++++++ .../mplayer/mplayer-1.0_rc4_p20101114-r50.ebuild | 740 ++++ net-misc/mimms/Manifest | 2 - net-misc/mimms/mimms-3.2.1.ebuild | 25 - www-apps/joomla/Manifest | 8 +- www-apps/joomla/joomla-1.5.17.ebuild | 54 - 10 files changed, 6673 insertions(+), 83 deletions(-) create mode 100644 media-video/mplayer/files/vaapi-take2/01-mplayer-vaapi.patch create mode 100644 media-video/mplayer/files/vaapi-take2/02-mplayer-vaapi-gma500-workaround.patch create mode 100644 media-video/mplayer/files/vaapi-take2/03-mplayer-vaapi-0.29.patch create mode 100644 media-video/mplayer/files/vaapi-take2/04-mplayer-vdpau.patch create mode 100644 media-video/mplayer/mplayer-1.0_rc4_p20101114-r50.ebuild delete mode 100644 net-misc/mimms/Manifest delete mode 100644 net-misc/mimms/mimms-3.2.1.ebuild delete mode 100644 www-apps/joomla/joomla-1.5.17.ebuild diff --git a/media-video/mplayer/Manifest b/media-video/mplayer/Manifest index 430fa95..969dd59 100644 --- a/media-video/mplayer/Manifest +++ b/media-video/mplayer/Manifest @@ -1,3 +1,7 @@ +AUX vaapi-take2/01-mplayer-vaapi.patch 124283 RMD160 2eb017742707aba7dc4e7bb14221a044b3f2ebc3 SHA1 1333105c753235d02c9648e1c9c47086a4aac7e2 SHA256 6b82bf6a27685cd0cf082259a749bacb0c60752d4eaec70d46c4c52154f0a87c +AUX vaapi-take2/02-mplayer-vaapi-gma500-workaround.patch 3008 RMD160 3293051f87ec0f6663ef880ba79c71953d7f0174 SHA1 e27544b891fa5d19183e34ab56c255ae9ea5a3f7 SHA256 4ebde5f4e4e483346fc99fd813b9a94c0a3bbb0ad7517674737e9f23fe359abd +AUX vaapi-take2/03-mplayer-vaapi-0.29.patch 46329 RMD160 823bcafc8bc69a3d414c842d5944087495b2cfa8 SHA1 a1889c9996f8ec8d317b3ce033e3300472c6f840 SHA256 59afee2a470fb79cbc9844ff68b846b665aebff36612103fb3bc468f198f9cd4 +AUX vaapi-take2/04-mplayer-vdpau.patch 45086 RMD160 c3ea2f31039ac3bb951836bd9462879a76c752f1 SHA1 798e287550f965d1f540843a0729a14d90d2d928 SHA256 e648f6c97cdbcd6bdc86d61f4d385b1756ff5f2a764c168ff3e3fe98120d194b AUX vaapi/01-mplayer-vaapi.patch 125634 RMD160 add288326843d97fc33d0d1eba9e3818a5a778bd SHA1 6821081a03627715223d7a55044ce04e02c07350 SHA256 0373141e6d662ba65a3a37f8d7808b073f7e740746a897a81cb40ea36450f670 AUX vaapi/02-mplayer-vaapi-gma500-workaround.patch 2994 RMD160 cc3911d951c42ec1468eae4b8976697f47df050a SHA1 408c6783aae243fdb60fa7ea851cb5ec6184d4f4 SHA256 c145b2f8523bc99340d097f17c57538197b9c49175fce0b38d6eced3e06828a5 AUX vaapi/03-mplayer-vaapi-0.29.patch 46210 RMD160 1d90e15164aac446d29450265890048c2e2bbca8 SHA1 f0553b65bf90178d4aac8f14f977b74e282b67d2 SHA256 f87d5c7e1a4fa084c5b07e19a92496ad1ffa0dd866196669af5cb4469600efdd @@ -7,6 +11,8 @@ DIST font-arial-cp1250.tar.bz2 249705 RMD160 a2fc7ae07b0d80936ea58e168e1047efccb DIST font-arial-iso-8859-1.tar.bz2 234242 RMD160 666697cd5efd9387057a898c714175e7c2aacbcd SHA1 152c40bf20de34aa8802d7f80d34d673b0b67212 SHA256 9730f481764f367c9089d0166fb6ccf9148808ffbbfeca635cf0e6db75765d29 DIST font-arial-iso-8859-2.tar.bz2 222208 RMD160 562d4d92c4f5f3d537340fde3ad8d1495ac41acb SHA1 7b99bbe0e9ba89a57eccbea8f93c453c4f268181 SHA256 71debfc960007c2f6242dfc91e8b1c005b30a99e129aeb00ab8c03f4371b41c1 DIST mplayer-1.0_rc4_p20100612.tbz2 8968316 RMD160 4179808dc9b99404affa2c95189fba3bb6fe5ad8 SHA1 a8d758dca9473006f66a947fb9019c35c66baa6b SHA256 098e16793baea2a9c4cf24ebcc8bc41c639c9806347b08724168e17e367b5d74 +DIST mplayer-1.0_rc4_p20101114.tar.xz 8515160 RMD160 73aec83d64abaadf9c6b6110f5d42e6bfae1ca87 SHA1 b6cfd5e05ef5a48a9d3d2f272f6f629461de8474 SHA256 02d6a259e063304cbf2ebb89fcb89d5133383d514264df9a423872684eb36c2d DIST svgalib_helper-1.9.17-mplayer.tar.gz 7583 RMD160 927ff34f187e4fa9528e2e48208173d98b3d1d1b SHA1 bf789706d1d79c695f781644c7ea6d57c3eed4c3 SHA256 a6f803f3df4cd4544751d3a3ee936a8bf0e20e32a452639b3f7c7d9e73e65938 EBUILD mplayer-1.0_rc4_p20100612-r50.ebuild 20354 RMD160 5e0a18409cfb24e6dbaeb1c3a51d8fb98f18b953 SHA1 053978376a1ec7c3836197539296a4fb23ee3f38 SHA256 a05791c258d16c6dba09f1dc2a782afa0f1d03cb316bd3b6871621b6712ecd17 +EBUILD mplayer-1.0_rc4_p20101114-r50.ebuild 20280 RMD160 a85a39739d94dad854f1cb6b718979242e6312f1 SHA1 9a28c2c5925fe903be518e6c3be891caa225ac78 SHA256 4cb97389439a616f936d5f67ef83f96cd0048706c2e92c2446e9b01df1f192e4 MISC metadata.xml 3591 RMD160 883e9161526d98f546d5b790a76da78ae6b03b94 SHA1 bf3ab6509cfa4a72a088ba005c9a92e44bac6df1 SHA256 956383713923533a4caa6e39fbe8067b2afa7c7aecc3e52c9dd0715435226ef8 diff --git a/media-video/mplayer/files/vaapi-take2/01-mplayer-vaapi.patch b/media-video/mplayer/files/vaapi-take2/01-mplayer-vaapi.patch new file mode 100644 index 0000000..bd3903e --- /dev/null +++ b/media-video/mplayer/files/vaapi-take2/01-mplayer-vaapi.patch @@ -0,0 +1,3906 @@ +diff --git a/Makefile b/Makefile +index 9d1bca1..c593ba2 100644 +--- a/Makefile ++++ b/Makefile +@@ -624,6 +624,7 @@ SRCS_MPLAYER-$(TDFXVID) += libvo/vo_tdfx_vid.c + SRCS_MPLAYER-$(TGA) += libvo/vo_tga.c + SRCS_MPLAYER-$(V4L2) += libvo/vo_v4l2.c + SRCS_MPLAYER-$(V4L2) += libao2/ao_v4l2.c ++SRCS_MPLAYER-$(VAAPI) += libvo/vo_vaapi.c + SRCS_MPLAYER-$(VDPAU) += libvo/vo_vdpau.c + SRCS_MPLAYER-$(VESA) += libvo/gtf.c libvo/vo_vesa.c libvo/vesa_lvo.c + SRCS_MPLAYER-$(VIDIX) += libvo/vo_cvidix.c \ +@@ -677,6 +678,7 @@ SRCS_MPLAYER = command.c \ + libvo/aspect.c \ + libvo/geometry.c \ + libvo/video_out.c \ ++ libvo/stats.c \ + libvo/vo_mpegpes.c \ + libvo/vo_null.c \ + sub/spuenc.c \ +diff --git a/cfg-common.h b/cfg-common.h +index 4f8c7ba..c2cbbf1 100644 +--- a/cfg-common.h ++++ b/cfg-common.h +@@ -244,6 +244,7 @@ const m_option_t common_opts[] = { + {"vfm", &video_fm_list, CONF_TYPE_STRING_LIST, 0, 0, 0, NULL}, + {"ac", &audio_codec_list, CONF_TYPE_STRING_LIST, 0, 0, 0, NULL}, + {"vc", &video_codec_list, CONF_TYPE_STRING_LIST, 0, 0, 0, NULL}, ++ {"va", &video_hwaccel_name, CONF_TYPE_STRING, 0, 0, 0, NULL}, + + // postprocessing: + #ifdef CONFIG_LIBAVCODEC +diff --git a/codec-cfg.c b/codec-cfg.c +index b8ca998..6a75293 100644 +--- a/codec-cfg.c ++++ b/codec-cfg.c +@@ -224,6 +224,13 @@ static const struct { + {"VDPAU_VC1",IMGFMT_VDPAU_VC1}, + {"VDPAU_MPEG4",IMGFMT_VDPAU_MPEG4}, + ++ {"VAAPI_MPEG2", IMGFMT_VAAPI_MPEG2}, ++ {"VAAPI_MPEG4", IMGFMT_VAAPI_MPEG4}, ++ {"VAAPI_H263", IMGFMT_VAAPI_H263}, ++ {"VAAPI_H264", IMGFMT_VAAPI_H264}, ++ {"VAAPI_WMV3", IMGFMT_VAAPI_WMV3}, ++ {"VAAPI_VC1", IMGFMT_VAAPI_VC1}, ++ + {NULL, 0} + }; + +diff --git a/configure b/configure +index 55ff660..89a0a9a 100755 +--- a/configure ++++ b/configure +@@ -385,6 +385,9 @@ Codecs: + --disable-muxer=MUXER disable specified FFmpeg muxer + --enable-muxer=MUXER enable specified FFmpeg muxer + ++Hardware acceleration: ++ --enable-vaapi enable VA-API acceleration [disable] ++ + Video output: + --disable-vidix disable VIDIX [for x86 *nix] + --with-vidix-drivers[=*] list of VIDIX drivers to be compiled in +@@ -414,6 +417,7 @@ Video output: + --enable-dvb enable DVB video output [autodetect] + --enable-mga enable mga_vid video output [autodetect] + --enable-xmga enable mga_vid X11 video output [autodetect] ++ --enable-xrender enable Xrender video output [autodetect] + --enable-xv enable Xv video output [autodetect] + --enable-xvmc enable XvMC acceleration [disable] + --enable-vdpau enable VDPAU acceleration [autodetect] +@@ -582,8 +586,7 @@ _libavparsers=$libavparsers_all + libavbsfs_all=$(sed -n 's/^[^#]*BSF.*(.*, *\(.*\)).*/\1_bsf/p' ffmpeg/libavcodec/allcodecs.c | tr '[a-z]' '[A-Z]') + libavbsfs=$libavbsfs_all + libavhwaccels_all=$(sed -n 's/^[^#]*HWACCEL.*(.*, *\(.*\)).*/\1_hwaccel/p' ffmpeg/libavcodec/allcodecs.c | tr '[a-z]' '[A-Z]') +-# Disable all hardware accelerators for now. +-libavhwaccels= ++libavhwaccels=$(for h in $libavhwaccels_all; do case $h in (*_VAAPI_HWACCEL) echo $h;; esac; done) + libavdemuxers_all=$(sed -n 's/^[^#]*DEMUX.*(.*, *\(.*\)).*/\1_demuxer/p' ffmpeg/libavformat/allformats.c | tr '[a-z]' '[A-Z]') + libavdemuxers=$(echo $libavdemuxers_all | sed -e 's/ LIB[A-Z0-9_]*_DEMUXER//g' -e s/REDIR_DEMUXER// -e s/AVISYNTH_DEMUXER//) + libavmuxers_all=$(sed -n 's/^[^#]*_MUX.*(.*, *\(.*\)).*/\1_muxer/p' ffmpeg/libavformat/allformats.c | tr '[a-z]' '[A-Z]') +@@ -600,11 +603,15 @@ _libswscale_so=auto + _libavcodec_mpegaudio_hp=yes + _mencoder=yes + _mplayer=yes ++_vaapi=auto ++_vaapi_glx=no ++_libgtop=auto + _x11=auto + _xshape=auto + _xss=auto + _dga1=auto + _dga2=auto ++_xrender=auto + _xv=auto + _xvmc=no #auto when complete + _vdpau=auto +@@ -944,10 +951,14 @@ for ac_option do + --disable-xshape) _xshape=no ;; + --enable-xss) _xss=yes ;; + --disable-xss) _xss=no ;; ++ --enable-xrender) _xrender=yes ;; ++ --disable-xrender) _xrender=no ;; + --enable-xv) _xv=yes ;; + --disable-xv) _xv=no ;; + --enable-xvmc) _xvmc=yes ;; + --disable-xvmc) _xvmc=no ;; ++ --enable-vaapi) _vaapi=yes ;; ++ --disable-vaapi) _vaapi=no ;; + --enable-vdpau) _vdpau=yes ;; + --disable-vdpau) _vdpau=no ;; + --enable-sdl) _sdl=yes ;; +@@ -3966,6 +3977,28 @@ fi + echores "$_gettimeofday" + + ++echocheck "clock_gettime()" ++cat > $TMPC << EOF ++#include ++int main(void) { ++ struct timespec t; ++ clock_gettime(CLOCK_REALTIME, &t); ++ return 0; ++} ++EOF ++_clock_gettime=no ++cc_check -lrt && _clock_gettime=yes ++if test "$_clock_gettime" = yes ; then ++ def_clock_gettime='#define HAVE_CLOCK_GETTIME 1' ++ extra_ldflags="$extra_ldflags -lrt" ++ _need_clock_gettime=no ++else ++ def_clock_gettime='#undef HAVE_CLOCK_GETTIME' ++ _need_clock_gettime=yes ++fi ++echores "$_clock_gettime" ++ ++ + echocheck "glob()" + cat > $TMPC << EOF + #include +@@ -4405,7 +4438,7 @@ else + novomodules="x11 $novomodules" + res_comment="check if the dev(el) packages are installed" + # disable stuff that depends on X +- _xv=no ; _xvmc=no ; _xinerama=no ; _vm=no ; _xf86keysym=no ; _vdpau=no ++ _xv=no ; _xvmc=no ; _xinerama=no ; _vm=no ; _xf86keysym=no ; _vaapi=no ; _vdpau=no + fi + echores "$_x11" + +@@ -4462,6 +4495,30 @@ else + fi + + ++echocheck "Xrender" ++if test "$_xrender" = auto ; then ++ cat > $TMPC < ++#include ++int main(void) { ++ (void) XRenderCreatePicture(0, 0, 0, 0, 0); ++ return 0; } ++EOF ++ _xrender=no ++ cc_check -lXrender && _xrender=yes ++fi ++ ++if test "$_xrender" = yes ; then ++ def_xrender='#define CONFIG_XRENDER 1' ++ libs_mplayer="$libs_mplayer -lXrender" ++ vomodules="xrender $vomodules" ++else ++ def_xrender='#undef CONFIG_XRENDER' ++ novomodules="xrender $novomodules" ++fi ++echores "$_xrender" ++ ++ + echocheck "Xv" + if test "$_xv" = auto ; then + cat > $TMPC < $TMPC << EOF ++#include ++#include ++int main(void) { return 0; } ++EOF ++cc_check $($_pkg_config --libs --cflags libgtop-2.0) && tmp_run && _libgtop=yes ++ ++ fi ++fi ++echores "$_libgtop" ++ ++if test "$_libgtop" = yes ; then ++ def_libgtop='#define CONFIG_LIBGTOP 1' ++ libs_mplayer="$libs_mplayer $($_pkg_config --libs libgtop-2.0)" ++ extra_cflags="$extra_cflags $($_pkg_config --cflags libgtop-2.0)" ++else ++ def_libgtop='#define CONFIG_LIBGTOP 0' ++fi ++ ++ + echocheck "PNG support" + if test "$_png" = auto ; then + _png=no +@@ -5375,6 +5457,23 @@ else + fi + echores "$_gl" + ++echocheck "OpenGL utilities (GLU)" ++_glu=no ++if test "$_gl" = yes; then ++ cat > $TMPC << EOF ++#include ++int main(void) { ++ gluPerspective(0.0, 0.0, 0.0, 0.0); ++ return 0; ++} ++EOF ++ cc_check -lGLU && _glu=yes ++fi ++if test "$_glu" = yes; then ++ libs_mplayer="$libs_mplayer -lGLU" ++fi ++echores "$_glu" ++ + + echocheck "MatrixView" + if test "$_gl" = no ; then +@@ -5995,6 +6094,52 @@ echores "$_dart" + fi #if os2 + + ++######################### ++# HARDWARE ACCELERATORS # ++######################### ++ ++echocheck "VA-API" ++if test "$_vaapi" = yes -o "$_vaapi" = auto; then ++ _vaapi=no ++ cat > $TMPC < ++int main(void) { (void) vaGetDisplay(0); return 0; } ++EOF ++ cc_check -lva-x11 && _vaapi=yes ++fi ++ ++if test "$_vaapi" = yes ; then ++ def_vaapi='#define CONFIG_VAAPI 1' ++ libs_mencoder="$libs_mencoder -lva" ++ libs_mplayer="$libs_mplayer -lva-x11 -lva" ++ vomodules="vaapi $vomodules" ++else ++ def_vaapi='#define CONFIG_VAAPI 0' ++ novomodules="vaapi $novomodules" ++ _libavhwaccels=`echo $_libavhwaccels | sed -e "s/\(MPEG[124]\|H26[34]\|WMV3\|VC1\)_VAAPI_HWACCEL//g"` ++fi ++echores "$_vaapi" ++ ++echocheck "VA-API (with GLX support)" ++if test "$_vaapi" = yes; then ++ _vaapi_glx=no ++ if test "$_gl" = "yes" -a "$_glu" = yes; then ++ cat > $TMPC < ++int main(void) { (void) vaGetDisplayGLX(0); return 0; } ++EOF ++ cc_check -lva-glx && _vaapi_glx=yes ++ fi ++fi ++if test "$_vaapi_glx" = yes; then ++ def_vaapi_glx='#define CONFIG_VAAPI_GLX 1' ++ libs_mplayer="$libs_mplayer -lva-glx" ++else ++ def_vaapi_glx='#define CONFIG_VAAPI_GLX 0' ++fi ++echores "$_vaapi_glx" ++ ++ + # set default CD/DVD devices + if win32 || os2 ; then + default_cdrom_device="D:" +@@ -8677,6 +8822,7 @@ TV_V4L2 = $_tv_v4l2 + TWOLAME=$_twolame + UNRAR_EXEC = $_unrar_exec + V4L2 = $_v4l2 ++VAAPI = $_vaapi + VCD = $_vcd + VDPAU = $_vdpau + VESA = $_vesa +@@ -8774,7 +8920,9 @@ CONFIG_MLIB = $_mlib + CONFIG_MUXERS = $_mencoder + CONFIG_POSTPROC = yes + CONFIG_RTPDEC = $networking ++CONFIG_VAAPI = $_vaapi + CONFIG_VDPAU = $_vdpau ++CONFIG_XRENDER = $_xrender + CONFIG_XVMC = $_xvmc + CONFIG_ZLIB = $_zlib + +@@ -8893,6 +9041,7 @@ $def_winsock2_h + + + /* system functions */ ++$def_clock_gettime + $def_gethostbyname2 + $def_gettimeofday + $def_glob +@@ -8924,6 +9073,7 @@ $def_extern_asm + $def_extern_prefix + $def_iconv + $def_kstat ++$def_libgtop + $def_macosx_bundle + $def_macosx_finder + $def_maemo +@@ -9155,6 +9305,8 @@ $def_tdfxfb + $def_tdfxvid + $def_tga + $def_v4l2 ++$def_vaapi ++$def_vaapi_glx + $def_vdpau + $def_vesa + $def_vidix +@@ -9180,6 +9332,7 @@ $def_xf86keysym + $def_xinerama + $def_xmga + $def_xss ++$def_xrender + $def_xv + $def_xvmc + $def_xvr100 +diff --git a/etc/codecs.conf b/etc/codecs.conf +index a8d2ae0..8eece64 100644 +--- a/etc/codecs.conf ++++ b/etc/codecs.conf +@@ -172,6 +172,7 @@ videocodec ffmpeg2 + fourcc slif ; SoftLab MPEG-2 I-frames Codec + driver ffmpeg + dll "mpeg2video" ++ out VAAPI_MPEG2 + out YV12,I420,IYUV + out 422P,444P + +@@ -901,6 +902,7 @@ videocodec ffwmv3 + fourcc WMV3,wmv3 + driver ffmpeg + dll wmv3 ++ out VAAPI_WMV3 + out YV12,I420,IYUV + + videocodec ffwmv3vdpau +@@ -918,6 +920,7 @@ videocodec ffvc1 + fourcc vc-1,VC-1 + driver ffmpeg + dll vc1 ++ out VAAPI_VC1 + out YV12,I420,IYUV + + videocodec ffvc1vdpau +@@ -939,6 +942,7 @@ videocodec ffh264 + format 0x10000005 + driver ffmpeg + dll h264 ++ out VAAPI_H264 + out YV12,I420,IYUV + + videocodec ffh264vdpau +@@ -1008,6 +1012,7 @@ videocodec ffodivx + fourcc SIPP ; Samsung SHR-6040 + driver ffmpeg + dll mpeg4 ;opendivx ++ out VAAPI_MPEG4 + out YV12,I420,IYUV + + videocodec ffodivxvdpau +@@ -1577,6 +1582,7 @@ videocodec ffh263 + fourcc VX1K ; Agora Labs VX1000S H263 + driver ffmpeg + dll h263 ++ out VAAPI_H263 + out YV12,I420,IYUV + + videocodec ffzygo +diff --git a/fmt-conversion.c b/fmt-conversion.c +index 9e88100..bd32ce8 100644 +--- a/fmt-conversion.c ++++ b/fmt-conversion.c +@@ -18,12 +18,14 @@ + + #include "mp_msg.h" + #include "libavutil/avutil.h" ++#include "libavcodec/avcodec.h" + #include "libmpcodecs/img_format.h" + #include "fmt-conversion.h" + + static const struct { + int fmt; + enum PixelFormat pix_fmt; ++ enum CodecID codec_id; + } conversion_map[] = { + {IMGFMT_ARGB, PIX_FMT_ARGB}, + {IMGFMT_BGRA, PIX_FMT_BGRA}, +@@ -95,6 +97,17 @@ static const struct { + {IMGFMT_VDPAU_WMV3, PIX_FMT_VDPAU_WMV3}, + {IMGFMT_VDPAU_VC1, PIX_FMT_VDPAU_VC1}, + {IMGFMT_VDPAU_MPEG4, PIX_FMT_VDPAU_MPEG4}, ++ ++ /* VA-API formats */ ++ {IMGFMT_VAAPI_MPEG2, PIX_FMT_VAAPI_VLD, CODEC_ID_MPEG2VIDEO}, ++ {IMGFMT_VAAPI_MPEG2_IDCT,PIX_FMT_VAAPI_IDCT, CODEC_ID_MPEG2VIDEO}, ++ {IMGFMT_VAAPI_MPEG2_MOCO,PIX_FMT_VAAPI_MOCO, CODEC_ID_MPEG2VIDEO}, ++ {IMGFMT_VAAPI_MPEG4, PIX_FMT_VAAPI_VLD, CODEC_ID_MPEG4}, ++ {IMGFMT_VAAPI_H263, PIX_FMT_VAAPI_VLD, CODEC_ID_H263}, ++ {IMGFMT_VAAPI_H264, PIX_FMT_VAAPI_VLD, CODEC_ID_H264}, ++ {IMGFMT_VAAPI_WMV3, PIX_FMT_VAAPI_VLD, CODEC_ID_WMV3}, ++ {IMGFMT_VAAPI_VC1, PIX_FMT_VAAPI_VLD, CODEC_ID_VC1}, ++ + {0, PIX_FMT_NONE} + }; + +@@ -111,12 +124,14 @@ enum PixelFormat imgfmt2pixfmt(int fmt) + return pix_fmt; + } + +-int pixfmt2imgfmt(enum PixelFormat pix_fmt) ++int pixfmt2imgfmt(enum PixelFormat pix_fmt, int codec_id) + { + int i; + int fmt; + for (i = 0; conversion_map[i].pix_fmt != PIX_FMT_NONE; i++) +- if (conversion_map[i].pix_fmt == pix_fmt) ++ if (conversion_map[i].pix_fmt == pix_fmt && ++ (conversion_map[i].codec_id == 0 || ++ conversion_map[i].codec_id == codec_id)) + break; + fmt = conversion_map[i].fmt; + if (!fmt) +diff --git a/fmt-conversion.h b/fmt-conversion.h +index 9e133a8..962ca4e 100644 +--- a/fmt-conversion.h ++++ b/fmt-conversion.h +@@ -23,6 +23,6 @@ + #include "libavutil/avutil.h" + + enum PixelFormat imgfmt2pixfmt(int fmt); +-int pixfmt2imgfmt(enum PixelFormat pix_fmt); ++int pixfmt2imgfmt(enum PixelFormat pix_fmt, int codec_id); + + #endif /* MPLAYER_FMT_CONVERSION_H */ +diff --git a/gui/mplayer/gtk/opts.c b/gui/mplayer/gtk/opts.c +index 0a26245..e66e263 100644 +--- a/gui/mplayer/gtk/opts.c ++++ b/gui/mplayer/gtk/opts.c +@@ -66,9 +66,11 @@ static GtkWidget * CLVDrivers; + GtkWidget * prEFontName; + GtkWidget * prEDVDDevice; + GtkWidget * prECDRomDevice; ++static GtkWidget * EVHW; + static GtkWidget * EVFM; + static GtkWidget * EAFM; + ++static GtkWidget * CBVHW; + static GtkWidget * CBVFM; + static GtkWidget * CBAFM; + static GtkWidget * CBAudioEqualizer; +@@ -354,6 +356,26 @@ void ShowPreferences( void ) + // -- 5. page + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( CBNonInterlaved ),force_ni ); + if ( index_mode == 1 ) gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( CBIndex ),1 ); ++ ++ { ++ int i; ++ GList * Items = NULL; ++ char * name = NULL; ++ ++ Items = g_list_append(Items, MSGTR_PREFERENCES_None); ++ for (i = 0; i < HWACCEL_COUNT; i++) { ++ const char *hwaccel_name = get_video_hwaccel_name(i); ++ if (!hwaccel_name) ++ continue; ++ Items = g_list_append(Items, hwaccel_name); ++ if (video_hwaccel_name && !gstrcmp(video_hwaccel_name, get_video_hwaccel_short_name(i) ) ) name = hwaccel_name; ++ } ++ gtk_combo_set_popdown_strings(GTK_COMBO(CBVHW), Items); ++ g_list_free(Items); ++ if (name) ++ gtk_entry_set_text(GTK_ENTRY(EVHW), name); ++ } ++ + { + int i; + GList * Items = NULL; +@@ -600,6 +622,17 @@ static void prButton( GtkButton * button, gpointer user_data ) + if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( CBIndex ) ) ) index_mode=1; + + { ++ int i; ++ const char *tmp = gtk_entry_get_text(GTK_ENTRY(EVHW)); ++ for (i = 0; i < HWACCEL_COUNT; i++) { ++ if (!gstrcmp(tmp, get_video_hwaccel_name(i))) { ++ video_hwaccel_name = get_video_hwaccel_short_name(i); ++ break; ++ } ++ } ++ } ++ ++ { + int i; + const char * tmp = gtk_entry_get_text( GTK_ENTRY( EVFM ) ); + for( i=0;mpcodecs_vd_drivers[i];i++ ) +@@ -1199,6 +1232,20 @@ GtkWidget * create_Preferences( void ) + + hbox5=AddHBox( vbox602,1 ); + ++ AddLabel( MSGTR_PREFERENCES_VideoHardwareAcceleration,hbox5 ); ++ ++ CBVHW=gtk_combo_new(); ++ gtk_widget_set_name( CBVHW,"CBVHW" ); ++ gtk_widget_show( CBVHW ); ++ gtk_box_pack_start( GTK_BOX( hbox5 ),CBVHW,TRUE,TRUE,0 ); ++ ++ EVHW=GTK_COMBO( CBVHW )->entry; ++ gtk_widget_set_name( EVHW,"CEVHW" ); ++ gtk_entry_set_editable( GTK_ENTRY( EVHW ),FALSE ); ++ gtk_widget_show( EVHW ); ++ ++ hbox5=AddHBox( vbox602,1 ); ++ + AddLabel( MSGTR_PREFERENCES_VideoCodecFamily,hbox5 ); + + CBVFM=gtk_combo_new(); +diff --git a/help/help_mp-en.h b/help/help_mp-en.h +index a112418..121eac9 100644 +--- a/help/help_mp-en.h ++++ b/help/help_mp-en.h +@@ -717,6 +717,7 @@ static const char help_text[]= + #define MSGTR_PREFERENCES_IDX "Rebuild index table, if needed" + #define MSGTR_PREFERENCES_VideoCodecFamily "Video codec family:" + #define MSGTR_PREFERENCES_AudioCodecFamily "Audio codec family:" ++#define MSGTR_PREFERENCES_VideoHardwareAcceleration "Video hardware acceleration:" + #define MSGTR_PREFERENCES_FRAME_OSD_Level "OSD level" + #define MSGTR_PREFERENCES_FRAME_Subtitle "Subtitle" + #define MSGTR_PREFERENCES_FRAME_Font "Font" +@@ -1653,6 +1654,7 @@ static const char help_text[]= + #define MSGTR_MPCODECS_UnexpectedInitVoError "[VD_FFMPEG] Unexpected init_vo error.\n" + #define MSGTR_MPCODECS_UnrecoverableErrorRenderBuffersNotTaken "[VD_FFMPEG] Unrecoverable error, render buffers not taken.\n" + #define MSGTR_MPCODECS_OnlyBuffersAllocatedByVoXvmcAllowed "[VD_FFMPEG] Only buffers allocated by vo_xvmc allowed.\n" ++#define MSGTR_MPCODECS_VAAPIAcceleratedCodec "[VD_FFMPEG] VA API accelerated codec.\n" + + // libmpcodecs/ve_lavc.c + #define MSGTR_MPCODECS_HighQualityEncodingSelected "[VE_LAVC] High quality encoding selected (non-realtime)!\n" +diff --git a/libmpcodecs/dec_video.c b/libmpcodecs/dec_video.c +index 1dd6e42..ce9facc 100644 +--- a/libmpcodecs/dec_video.c ++++ b/libmpcodecs/dec_video.c +@@ -56,9 +56,47 @@ extern double vout_time_usage; + int field_dominance = -1; + + int divx_quality = 0; ++char *video_hwaccel_name=NULL; + + const vd_functions_t *mpvdec = NULL; + ++int get_video_hwaccel(void) ++{ ++ static int video_hwaccel = -1; ++ if (video_hwaccel < 0) { ++ video_hwaccel = HWACCEL_NONE; ++ if (video_hwaccel_name) { ++ if (!strcmp(video_hwaccel_name,"xvmc")) ++ video_hwaccel = HWACCEL_XVMC; ++ else if (!strcmp(video_hwaccel_name,"vaapi")) ++ video_hwaccel = HWACCEL_VAAPI; ++ else if (!strcmp(video_hwaccel_name,"vdpau")) ++ video_hwaccel = HWACCEL_VDPAU; ++ } ++ } ++ return video_hwaccel; ++} ++ ++const char *get_video_hwaccel_name(int hwaccel) ++{ ++ switch (hwaccel) { ++ case HWACCEL_XVMC: return "XvMC"; ++ case HWACCEL_VAAPI: return "VA API"; ++ case HWACCEL_VDPAU: return "VDPAU"; ++ } ++ return NULL; ++} ++ ++const char *get_video_hwaccel_short_name(int hwaccel) ++{ ++ switch (hwaccel) { ++ case HWACCEL_XVMC: return "xvmc"; ++ case HWACCEL_VAAPI: return "vaapi"; ++ case HWACCEL_VDPAU: return "vdpau"; ++ } ++ return NULL; ++} ++ + int get_video_quality_max(sh_video_t *sh_video) + { + vf_instance_t *vf = sh_video->vfilter; +diff --git a/libmpcodecs/dec_video.h b/libmpcodecs/dec_video.h +index 04fc8f4..a9bedb0 100644 +--- a/libmpcodecs/dec_video.h ++++ b/libmpcodecs/dec_video.h +@@ -21,6 +21,14 @@ + + #include "libmpdemux/stheader.h" + ++enum { ++ HWACCEL_NONE = 0, ++ HWACCEL_XVMC, ++ HWACCEL_VAAPI, ++ HWACCEL_VDPAU, ++ HWACCEL_COUNT ++}; ++ + // dec_video.c: + void vfm_help(void); + +@@ -41,6 +49,11 @@ int set_rectangle(sh_video_t *sh_video, int param, int value); + void resync_video_stream(sh_video_t *sh_video); + int get_current_video_decoder_lag(sh_video_t *sh_video); + ++int get_video_hwaccel(void); ++const char *get_video_hwaccel_name(int hwaccel); ++const char *get_video_hwaccel_short_name(int hwaccel); ++ + extern int divx_quality; ++extern char *video_hwaccel_name; + + #endif /* MPLAYER_DEC_VIDEO_H */ +diff --git a/libmpcodecs/img_format.c b/libmpcodecs/img_format.c +index bdf4d2f..65f0bd1 100644 +--- a/libmpcodecs/img_format.c ++++ b/libmpcodecs/img_format.c +@@ -96,6 +96,14 @@ const char *vo_format_name(int format) + case IMGFMT_ZRMJPEGIB: return "Zoran MJPEG bottom field first"; + case IMGFMT_XVMC_MOCO_MPEG2: return "MPEG1/2 Motion Compensation"; + case IMGFMT_XVMC_IDCT_MPEG2: return "MPEG1/2 Motion Compensation and IDCT"; ++ case IMGFMT_VAAPI_MPEG2: return "MPEG-2 VA-API Acceleration"; ++ case IMGFMT_VAAPI_MPEG2_IDCT: return "MPEG-2 VA-API Acceleration (Motion Compensation and IDCT)"; ++ case IMGFMT_VAAPI_MPEG2_MOCO: return "MPEG-2 VA-API Acceleration (Motion Compensation)"; ++ case IMGFMT_VAAPI_MPEG4: return "MPEG-4 VA-API Acceleration"; ++ case IMGFMT_VAAPI_H263: return "H.263 VA-API Acceleration"; ++ case IMGFMT_VAAPI_H264: return "H.264 VA-API Acceleration"; ++ case IMGFMT_VAAPI_WMV3: return "WMV3 VA-API Acceleration"; ++ case IMGFMT_VAAPI_VC1: return "VC-1 VA-API Acceleration"; + case IMGFMT_VDPAU_MPEG1: return "MPEG1 VDPAU acceleration"; + case IMGFMT_VDPAU_MPEG2: return "MPEG2 VDPAU acceleration"; + case IMGFMT_VDPAU_H264: return "H.264 VDPAU acceleration"; +diff --git a/libmpcodecs/img_format.h b/libmpcodecs/img_format.h +index e580082..d0aaa45 100644 +--- a/libmpcodecs/img_format.h ++++ b/libmpcodecs/img_format.h +@@ -182,6 +182,26 @@ + #define IMGFMT_XVMC_MOCO_MPEG2 (IMGFMT_XVMC|0x02) + #define IMGFMT_XVMC_IDCT_MPEG2 (IMGFMT_XVMC|0x82) + ++/* VA-API Formats */ ++ ++#define IMGFMT_VAAPI 0x56410000 /* 'VA'00 */ ++#define IMGFMT_VAAPI_MASK 0xFFFF0000 ++#define IMGFMT_IS_VAAPI(fmt) (((fmt) & IMGFMT_VAAPI_MASK) == IMGFMT_VAAPI) ++#define IMGFMT_VAAPI_CODEC_MASK 0x000000F0 ++#define IMGFMT_VAAPI_CODEC(fmt) ((fmt) & IMGFMT_VAAPI_CODEC_MASK) ++#define IMGFMT_VAAPI_CODEC_MPEG2 (0x10) ++#define IMGFMT_VAAPI_CODEC_MPEG4 (0x20) ++#define IMGFMT_VAAPI_CODEC_H264 (0x30) ++#define IMGFMT_VAAPI_CODEC_VC1 (0x40) ++#define IMGFMT_VAAPI_MPEG2 (IMGFMT_VAAPI|IMGFMT_VAAPI_CODEC_MPEG2) ++#define IMGFMT_VAAPI_MPEG2_IDCT (IMGFMT_VAAPI|IMGFMT_VAAPI_CODEC_MPEG2|1) ++#define IMGFMT_VAAPI_MPEG2_MOCO (IMGFMT_VAAPI|IMGFMT_VAAPI_CODEC_MPEG2|2) ++#define IMGFMT_VAAPI_MPEG4 (IMGFMT_VAAPI|IMGFMT_VAAPI_CODEC_MPEG4) ++#define IMGFMT_VAAPI_H263 (IMGFMT_VAAPI|IMGFMT_VAAPI_CODEC_MPEG4|1) ++#define IMGFMT_VAAPI_H264 (IMGFMT_VAAPI|IMGFMT_VAAPI_CODEC_H264) ++#define IMGFMT_VAAPI_VC1 (IMGFMT_VAAPI|IMGFMT_VAAPI_CODEC_VC1) ++#define IMGFMT_VAAPI_WMV3 (IMGFMT_VAAPI|IMGFMT_VAAPI_CODEC_VC1|1) ++ + // VDPAU specific format. + #define IMGFMT_VDPAU 0x1DC80000 + #define IMGFMT_VDPAU_MASK 0xFFFF0000 +@@ -193,7 +193,7 @@ + #define IMGFMT_VDPAU_VC1 (IMGFMT_VDPAU|0x05) + #define IMGFMT_VDPAU_MPEG4 (IMGFMT_VDPAU|0x06) + +-#define IMGFMT_IS_HWACCEL(fmt) (IMGFMT_IS_VDPAU(fmt) || IMGFMT_IS_XVMC(fmt)) ++#define IMGFMT_IS_HWACCEL(fmt) (IMGFMT_IS_VDPAU(fmt) || IMGFMT_IS_XVMC(fmt)) || IMGFMT_IS_VAAPI(fmt) + + typedef struct { + void* data;diff --git a/libmpcodecs/mp_image.c b/libmpcodecs/mp_image.c +index f239181..35438c9 100644 +diff --git a/libmpcodecs/vd.c b/libmpcodecs/vd.c +index ea6b6b2..dad5eb6 100644 +--- a/libmpcodecs/vd.c ++++ b/libmpcodecs/vd.c +@@ -403,3 +403,12 @@ void mpcodecs_draw_slice(sh_video_t *sh, unsigned char **src, int *stride, + if (vf->draw_slice) + vf->draw_slice(vf, src, stride, w, h, x, y); + } ++ ++void *mpcodecs_get_hwaccel_context(sh_video_t *sh) ++{ ++ void *ctx = NULL; ++ struct vf_instance *vf = sh->vfilter; ++ if (vf->control(vf, VFCTRL_GET_HWACCEL_CONTEXT, &ctx) == CONTROL_TRUE) ++ return ctx; ++ return NULL; ++} +diff --git a/libmpcodecs/vd.h b/libmpcodecs/vd.h +index 8f7c238..e655d60 100644 +--- a/libmpcodecs/vd.h ++++ b/libmpcodecs/vd.h +@@ -64,6 +64,7 @@ extern const m_option_t xvid_dec_opts[]; + int mpcodecs_config_vo(sh_video_t *sh, int w, int h, unsigned int preferred_outfmt); + mp_image_t* mpcodecs_get_image(sh_video_t *sh, int mp_imgtype, int mp_imgflag, int w, int h); + void mpcodecs_draw_slice(sh_video_t *sh, unsigned char** src, int* stride, int w,int h, int x, int y); ++void *mpcodecs_get_hwaccel_context(sh_video_t *sh); + + #define VDFLAGS_DROPFRAME 3 + +diff --git a/libmpcodecs/vd_ffmpeg.c b/libmpcodecs/vd_ffmpeg.c +index 38f1fbd..5b003fa 100644 +--- a/libmpcodecs/vd_ffmpeg.c ++++ b/libmpcodecs/vd_ffmpeg.c +@@ -32,6 +32,7 @@ + + #include "vd_internal.h" + #include "vd_ffmpeg.h" ++#include "dec_video.h" + + static const vd_info_t info = { + "FFmpeg's libavcodec codec family", +@@ -228,8 +229,8 @@ static void set_format_params(struct AVCodecContext *avctx, enum PixelFormat fmt + int imgfmt; + if (fmt == PIX_FMT_NONE) + return; +- imgfmt = pixfmt2imgfmt(fmt); ++ imgfmt = pixfmt2imgfmt(fmt, avctx->codec_id); + if (IMGFMT_IS_HWACCEL(imgfmt)) { + sh_video_t *sh = avctx->opaque; + vd_ffmpeg_ctx *ctx = sh->context; + ctx->do_dr1 = 1; +@@ -286,6 +287,12 @@ static int init(sh_video_t *sh){ + avctx->codec_type = CODEC_TYPE_VIDEO; + avctx->codec_id = lavc_codec->id; + ++#if CONFIG_VAAPI ++ if(get_video_hwaccel() == HWACCEL_VAAPI){ ++ mp_msg(MSGT_DECVIDEO, MSGL_INFO, MSGTR_MPCODECS_VAAPIAcceleratedCodec); ++ avctx->get_format = get_format; ++ } ++#endif /* CONFIG_VAAPI */ + #if CONFIG_VDPAU + if(lavc_codec->capabilities & CODEC_CAP_HWACCEL_VDPAU){ + avctx->get_format = get_format; +@@ -479,7 +486,7 @@ static void draw_slice(struct AVCodecContext *s, + const AVFrame *src, int offset[4], + int y, int type, int height){ + sh_video_t *sh = s->opaque; +- uint8_t *source[MP_MAX_PLANES]= {src->data[0] + offset[0], src->data[1] + offset[1], src->data[2] + offset[2]}; ++ uint8_t *source[MP_MAX_PLANES]= {src->data[0] + offset[0], src->data[1] + offset[1], src->data[2] + offset[2], src->data[3] + offset[3]}; + int strides[MP_MAX_PLANES] = {src->linesize[0], src->linesize[1], src->linesize[2]}; + #if 0 + int start=0, i; +@@ -558,9 +565,10 @@ static int init_vo(sh_video_t *sh, enum PixelFormat pix_fmt){ + sh->disp_w = width; + sh->disp_h = height; + ctx->pix_fmt = pix_fmt; +- ctx->best_csp = pixfmt2imgfmt(pix_fmt); ++ ctx->best_csp = pixfmt2imgfmt(pix_fmt, avctx->codec_id); + if (!mpcodecs_config_vo(sh, sh->disp_w, sh->disp_h, ctx->best_csp)) + return -1; ++ avctx->hwaccel_context = mpcodecs_get_hwaccel_context(sh); + ctx->vo_initialized = 1; + } + return 0; +@@ -955,24 +970,62 @@ static mp_image_t *decode(sh_video_t *sh, void *data, int len, int flags){ + return mpi; + } + +-#if CONFIG_XVMC || CONFIG_VDPAU ++#if CONFIG_XVMC || CONFIG_VAAPI || CONFIG_VDPAU ++static inline int is_hwaccel_format(int imgfmt) ++{ ++ switch (get_video_hwaccel()) { ++ case HWACCEL_VAAPI: return IMGFMT_IS_VAAPI(imgfmt) != 0; ++ case HWACCEL_VDPAU: return IMGFMT_IS_VDPAU(imgfmt) != 0; ++ case HWACCEL_XVMC: return IMGFMT_IS_XVMC(imgfmt) != 0; ++ } ++ return 0; ++} ++ ++static int query_format(sh_video_t *sh, int fmt) ++{ ++ vd_ffmpeg_ctx * const ctx = sh->context; ++ AVCodecContext * const avctx = ctx->avctx; ++ int r, width, height; ++ /* XXX: some codecs have not initialized width and height yet at ++ this point, so we are faking the dimensions so that init_vo() ++ doesn't fail because of 0x0 size */ ++ if ((width = avctx->width) == 0) ++ avctx->width = 64; ++ if ((height = avctx->height) == 0) ++ avctx->height = 64; ++ r = init_vo(sh, fmt); ++ avctx->width = width; ++ avctx->height = height; ++ return r; ++} ++ + static enum PixelFormat get_format(struct AVCodecContext *avctx, +- const enum PixelFormat *fmt){ +- enum PixelFormat selected_format; ++ const enum PixelFormat *fmt){ ++ enum PixelFormat selected_format = PIX_FMT_NONE; + int imgfmt; + sh_video_t *sh = avctx->opaque; +- int i; +- +- for(i=0;fmt[i]!=PIX_FMT_NONE;i++){ +- imgfmt = pixfmt2imgfmt(fmt[i]); +- if(!IMGFMT_IS_HWACCEL(imgfmt)) continue; +- mp_msg(MSGT_DECVIDEO, MSGL_INFO, MSGTR_MPCODECS_TryingPixfmt, i); +- if(init_vo(sh, fmt[i]) >= 0) { +- break; ++ int i, try_hwaccel; ++ ++ for (try_hwaccel = 1; try_hwaccel >= 0; --try_hwaccel) { ++ for (i = 0; fmt[i] != PIX_FMT_NONE; i++){ ++ imgfmt = pixfmt2imgfmt(fmt[i], avctx->codec_id); ++ if ((try_hwaccel ^ is_hwaccel_format(imgfmt)) != 0) ++ continue; ++ mp_msg(MSGT_DECVIDEO, MSGL_INFO, MSGTR_MPCODECS_TryingPixfmt, i); ++ if (query_format(sh, fmt[i]) >= 0) { ++ if (try_hwaccel) { ++ /* don't allow format conversion for HW acceleration */ ++ if (sh->codec->outfmt[sh->outfmtidx] != imgfmt) ++ continue; ++ } ++ selected_format = fmt[i]; ++ break; ++ } + } ++ if (selected_format != PIX_FMT_NONE) ++ break; + } +- selected_format = fmt[i]; + set_format_params(avctx, selected_format); + return selected_format; + } +-#endif /* CONFIG_XVMC || CONFIG_VDPAU */ ++#endif /* CONFIG_XVMC || CONFIG_VAAPI || CONFIG_VDPAU */ +diff --git a/libmpcodecs/vf.h b/libmpcodecs/vf.h +index 945fbc1..44e308a 100644 +--- a/libmpcodecs/vf.h ++++ b/libmpcodecs/vf.h +@@ -111,6 +111,7 @@ typedef struct vf_seteq_s + #define VFCTRL_GET_PTS 17 /* Return last pts value that reached vf_vo*/ + #define VFCTRL_SET_DEINTERLACE 18 /* Set deinterlacing status */ + #define VFCTRL_GET_DEINTERLACE 19 /* Get deinterlacing status */ ++#define VFCTRL_GET_HWACCEL_CONTEXT 20 /* Get HW accelerator context */ + + #include "vfcap.h" + +diff --git a/libmpcodecs/vf_vo.c b/libmpcodecs/vf_vo.c +index 061a34b..a11c2b7 100644 +--- a/libmpcodecs/vf_vo.c ++++ b/libmpcodecs/vf_vo.c +@@ -170,6 +170,12 @@ static int control(struct vf_instance *vf, int request, void* data) + *(double *)data = vf->priv->pts; + return CONTROL_TRUE; + } ++ case VFCTRL_GET_HWACCEL_CONTEXT: ++ { ++ if(!video_out) return CONTROL_FALSE; // vo not configured? ++ return(video_out->control(VOCTRL_GET_HWACCEL_CONTEXT, data) ++ == VO_TRUE) ? CONTROL_TRUE : CONTROL_FALSE; ++ } + } + // return video_out->control(request,data); + return CONTROL_UNKNOWN; +diff --git a/libvo/gl_common.c b/libvo/gl_common.c +index 9862dd9..638bd78 100644 +--- a/libvo/gl_common.c ++++ b/libvo/gl_common.c +@@ -140,6 +140,11 @@ void* (GLAPIENTRY *mpglAllocateMemoryMESA)(void *, int, size_t, float, float, fl + void (GLAPIENTRY *mpglFreeMemoryMESA)(void *, int, void *); + /** \} */ // end of glextfunctions group + ++void (GLAPIENTRY *mpglXBindTexImage)(Display *, GLXDrawable, int, const int *); ++void (GLAPIENTRY *mpglXReleaseTexImage)(Display *, GLXDrawable, int); ++GLXPixmap (GLAPIENTRY *mpglXCreatePixmap)(Display *, GLXFBConfig, Pixmap, const int *); ++void (GLAPIENTRY *mpglXDestroyPixmap)(Display *, GLXPixmap); ++ + //! \defgroup glgeneral OpenGL general helper functions + + //! \defgroup glcontext OpenGL context management helper functions +@@ -469,6 +474,10 @@ static const extfunc_desc_t extfuncs[] = { + {&mpglTexImage3D, NULL, {"glTexImage3D", NULL}}, + {&mpglAllocateMemoryMESA, "GLX_MESA_allocate_memory", {"glXAllocateMemoryMESA", NULL}}, + {&mpglFreeMemoryMESA, "GLX_MESA_allocate_memory", {"glXFreeMemoryMESA", NULL}}, ++ {&mpglXBindTexImage, "GLX_EXT_texture_from_pixmap", {"glXBindTexImageEXT", NULL}}, ++ {&mpglXReleaseTexImage, "GLX_EXT_texture_from_pixmap", {"glXReleaseTexImageEXT", NULL}}, ++ {&mpglXCreatePixmap, "GLX_EXT_texture_from_pixmap", {"glXCreatePixmap", NULL}}, ++ {&mpglXDestroyPixmap, "GLX_EXT_texture_from_pixmap", {"glXDestroyPixmap", NULL}}, + {NULL} + }; + +diff --git a/libvo/gl_common.h b/libvo/gl_common.h +index c4fb9bd..5614ac7 100644 +--- a/libvo/gl_common.h ++++ b/libvo/gl_common.h +@@ -507,4 +507,9 @@ extern void (GLAPIENTRY *mpglTexImage3D)(GLenum, GLint, GLenum, GLsizei, GLsizei + extern void* (GLAPIENTRY *mpglAllocateMemoryMESA)(void *, int, size_t, float, float, float); + extern void (GLAPIENTRY *mpglFreeMemoryMESA)(void *, int, void *); + ++extern void (GLAPIENTRY *mpglXBindTexImage)(Display *, GLXDrawable, int, const int *); ++extern void (GLAPIENTRY *mpglXReleaseTexImage)(Display *, GLXDrawable, int); ++extern GLXPixmap (GLAPIENTRY *mpglXCreatePixmap)(Display *, GLXFBConfig, Pixmap, const int *); ++extern void (GLAPIENTRY *mpglXDestroyPixmap)(Display *, GLXPixmap); ++ + #endif /* MPLAYER_GL_COMMON_H */ +diff --git a/libvo/stats.c b/libvo/stats.c +new file mode 100644 +index 0000000..c4ff0ca +--- /dev/null ++++ b/libvo/stats.c +@@ -0,0 +1,217 @@ ++#include "config.h" ++#include "stats.h" ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#if CONFIG_LIBGTOP ++#include ++#include ++#include ++#endif ++ ++// Process statistics ++struct proc_stats { ++ uint64_t utime; ++ uint64_t stime; ++ uint64_t cutime; ++ uint64_t cstime; ++ uint64_t frequency; ++ uint64_t cpu_time; ++ uint64_t start_time; ++ uint64_t current_time; ++}; ++ ++// Get current process stats ++static int get_proc_stats(struct proc_stats *pstats); ++ ++void stats_init(void) ++{ ++#if CONFIG_LIBGTOP ++ glibtop_init(); ++#endif ++} ++ ++void stats_exit(void) ++{ ++#if CONFIG_LIBGTOP ++ glibtop_close(); ++#endif ++} ++ ++// Get CPU frequency ++unsigned int get_cpu_frequency(void) ++{ ++ unsigned int freq = 0; ++#if defined __linux__ ++ { ++ FILE *proc_file = fopen("/proc/cpuinfo", "r"); ++ if (proc_file) { ++ char line[256]; ++ char *old_locale = setlocale(LC_NUMERIC, NULL); ++ setlocale(LC_NUMERIC, "C"); ++ while(fgets(line, sizeof(line), proc_file)) { ++ float f; ++ int len = strlen(line); ++ if (len == 0) ++ continue; ++ line[len - 1] = 0; ++ if (sscanf(line, "cpu MHz : %f", &f) == 1) ++ freq = (unsigned int)f; ++ } ++ setlocale(LC_NUMERIC, old_locale); ++ fclose(proc_file); ++ } ++ } ++#endif ++ return freq; ++} ++ ++// Get CPU usage in percent ++static float get_cpu_usage_1(void) ++{ ++ static struct proc_stats prev_stats; ++ struct proc_stats curr_stats; ++ uint64_t prev_proc_time = 0, curr_proc_time = 0; ++ float pcpu = 0.0f; ++ ++ if (get_proc_stats(&curr_stats) == 0) { ++ prev_proc_time += prev_stats.utime; ++ prev_proc_time += prev_stats.stime; ++ prev_proc_time += prev_stats.cutime; ++ prev_proc_time += prev_stats.cstime; ++ curr_proc_time += curr_stats.utime; ++ curr_proc_time += curr_stats.stime; ++ curr_proc_time += curr_stats.cutime; ++ curr_proc_time += curr_stats.cstime; ++ if (prev_stats.start_time > 0) ++ pcpu = 100.0 * ((float)(curr_proc_time - prev_proc_time) / ++ (float)(curr_stats.cpu_time - prev_stats.cpu_time)); ++ prev_stats = curr_stats; ++ } ++ return pcpu; ++} ++ ++float get_cpu_usage(enum CpuUsageType type) ++{ ++ static float pcpu_total = 0.0; ++ static unsigned int n_samples; ++ float pcpu; ++ ++ pcpu = get_cpu_usage_1(); ++ pcpu_total += pcpu / 100.0; ++ ++n_samples; ++ ++ if (type == CPU_USAGE_AVERAGE) ++ pcpu = 100.0 * (pcpu_total / n_samples); ++ return pcpu; ++} ++ ++// For ELF executable, notes are pushed before environment and args ++static int find_elf_note(unsigned long match, unsigned long *pval) ++{ ++ unsigned long *ep = (unsigned long *)__environ; ++ while (*ep++); ++ for (; *ep != 0; ep += 2) { ++ if (ep[0] == match) { ++ *pval = ep[1]; ++ return 0; ++ } ++ } ++ return -1; ++} ++ ++#ifndef AT_CLKTCK ++#define AT_CLKTCK 17 ++#endif ++ ++// Get current process stats ++int get_proc_stats(struct proc_stats *pstats) ++{ ++ int error = -1; ++ char line[256], *str, *end; ++ char vc; ++ int vi; ++ unsigned long vul; ++ unsigned long long vull; ++ float vf; ++#if defined __linux__ ++ { ++ FILE *proc_file = fopen("/proc/self/stat", "r"); ++ if (proc_file) { ++ if (fgets(line, sizeof(line), proc_file)) { ++ unsigned long utime, stime, cutime, cstime, start_time; ++ str = strrchr(line, ')'); ++ if (str && sscanf(str + 2, ++ "%c " ++ "%d %d %d %d %d " ++ "%lu %lu %lu %lu %lu %lu %lu " ++ "%ld %ld %ld %ld %ld %ld " ++ "%lu %lu ", ++ &vc, ++ &vi, &vi, &vi, &vi, &vi, ++ &vul, &vul, &vul, &vul, &vul, &utime, &stime, ++ &cutime, &cstime, &vul, &vul, &vul, &vul, ++ &start_time, &vul) == 21) { ++ pstats->utime = utime; ++ pstats->stime = stime; ++ pstats->cutime = cutime; ++ pstats->cstime = cstime; ++ pstats->start_time = start_time; ++ error = 0; ++ } ++ } ++ fclose(proc_file); ++ } ++ if (error) ++ return error; ++ error = -1; ++ ++ if (find_elf_note(AT_CLKTCK, &vul) == 0) { ++ pstats->frequency = vul; ++ error = 0; ++ } ++ if (error) ++ return error; ++ error = -1; ++ ++ proc_file = fopen("/proc/uptime", "r"); ++ if (proc_file) { ++ if (fgets(line, sizeof(line), proc_file)) { ++ char *old_locale = setlocale(LC_NUMERIC, NULL); ++ setlocale(LC_NUMERIC, "C"); ++ if (sscanf(line, "%f", &vf) == 1) { ++ pstats->cpu_time = (uint64_t)(vf * (float)pstats->frequency); ++ error = 0; ++ } ++ setlocale(LC_NUMERIC, old_locale); ++ } ++ fclose(proc_file); ++ } ++ } ++#elif CONFIG_LIBGTOP ++ { ++ glibtop_cpu cpu; ++ glibtop_proc_time proc_time; ++ glibtop_proc_state proc_state; ++ ++ glibtop_get_cpu(&cpu); ++ glibtop_get_proc_state(&proc_state, getpid()); ++ pstats->cpu_time = cpu.xcpu_total[proc_state.processor]; ++ ++ glibtop_get_proc_time(&proc_time, getpid()); ++ pstats->utime = proc_time.utime; ++ pstats->stime = proc_time.stime; ++ pstats->cutime = proc_time.cutime; ++ pstats->cstime = proc_time.cstime; ++ pstats->start_time = proc_time.start_time; ++ pstats->frequency = proc_time.frequency; ++ ++ error = 0; ++ } ++#endif ++ return error; ++} +diff --git a/libvo/stats.h b/libvo/stats.h +new file mode 100644 +index 0000000..62e7412 +--- /dev/null ++++ b/libvo/stats.h +@@ -0,0 +1,21 @@ ++#ifndef MPLAYER_STATS_H ++#define MPLAYER_STATS_H ++ ++#include ++ ++void stats_init(void); ++void stats_exit(void); ++ ++/// CPU usage model ++enum CpuUsageType { ++ CPU_USAGE_QUANTUM = 1, ///< CPU usage since the last call to cpu_get_usage() ++ CPU_USAGE_AVERAGE ///< CPU usage average'd since program start ++}; ++ ++/// Get CPU frequency ++unsigned int get_cpu_frequency(void); ++ ++/// Get CPU usage in percent ++float get_cpu_usage(enum CpuUsageType type); ++ ++#endif /* MPLAYER_STATS_H */ +diff --git a/libvo/video_out.c b/libvo/video_out.c +index 0318867..3373475 100644 +--- a/libvo/video_out.c ++++ b/libvo/video_out.c +@@ -95,6 +95,7 @@ extern const vo_functions_t video_out_xmga; + extern const vo_functions_t video_out_x11; + extern vo_functions_t video_out_xover; + extern const vo_functions_t video_out_xvmc; ++extern const vo_functions_t video_out_vaapi; + extern const vo_functions_t video_out_vdpau; + extern const vo_functions_t video_out_xv; + extern const vo_functions_t video_out_gl_nosw; +@@ -290,6 +291,9 @@ const vo_functions_t* const video_out_drivers[] = + #ifdef CONFIG_MD5SUM + &video_out_md5sum, + #endif ++#if CONFIG_VAAPI ++ &video_out_vaapi, ++#endif + NULL + }; + +diff --git a/libvo/video_out.h b/libvo/video_out.h +index 5e64b0e..785c6d2 100644 +--- a/libvo/video_out.h ++++ b/libvo/video_out.h +@@ -99,6 +99,10 @@ typedef struct { + int w,h; + } mp_win_t; + ++// Return current HW acceleration context ++// void *get_hwaccel_context(void); ++#define VOCTRL_GET_HWACCEL_CONTEXT 33 ++ + #define VO_TRUE 1 + #define VO_FALSE 0 + #define VO_ERROR -1 +diff --git a/libvo/vo_vaapi.c b/libvo/vo_vaapi.c +new file mode 100644 +index 0000000..c888656 +--- /dev/null ++++ b/libvo/vo_vaapi.c +@@ -0,0 +1,2668 @@ ++/* ++ * VA API output module ++ * ++ * Copyright (C) 2008-2009 Splitted-Desktop Systems ++ * ++ * This file is part of MPlayer. ++ * ++ * MPlayer is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * MPlayer 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 General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License along ++ * with MPlayer; if not, write to the Free Software Foundation, Inc., ++ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. ++ */ ++ ++#include "config.h" ++#include "mp_msg.h" ++#include "help_mp.h" ++#include "subopt-helper.h" ++#include "video_out.h" ++#include "video_out_internal.h" ++#include "fastmemcpy.h" ++#include "sub/sub.h" ++#include "x11_common.h" ++#include "libavutil/common.h" ++#include "libavcodec/vaapi.h" ++#include "gui/interface.h" ++#include "stats.h" ++#include "sub/ass_mp.h" ++#include "sub/eosd.h" ++#include ++ ++#if CONFIG_GL ++#include "gl_common.h" ++#include ++#include ++#endif ++ ++#include ++#include ++#include ++#include ++#if CONFIG_VAAPI_GLX ++#include ++#endif ++ ++#if CONFIG_XRENDER ++#include ++#endif ++ ++/* Compatibility glue with VA-API >= 0.30 */ ++#ifndef VA_INVALID_ID ++#define VA_INVALID_ID 0xffffffff ++#endif ++#ifndef VA_FOURCC ++#define VA_FOURCC(ch0, ch1, ch2, ch3) \ ++ ((uint32_t)(uint8_t)(ch0) | \ ++ ((uint32_t)(uint8_t)(ch1) << 8) | \ ++ ((uint32_t)(uint8_t)(ch2) << 16) | \ ++ ((uint32_t)(uint8_t)(ch3) << 24 )) ++#endif ++#if defined VA_SRC_BT601 && defined VA_SRC_BT709 ++#define USE_VAAPI_COLORSPACE 1 ++#else ++#define USE_VAAPI_COLORSPACE 0 ++#endif ++ ++/* Defined to 1 if IA44/AI44 subpicture formats are allowed */ ++/* XXX: they are not visually attractive... */ ++#define USE_VAAPI_IA44_FORMATS 0 ++ ++/* Defined to 1 if VA/GLX 'bind' API is available */ ++#define USE_VAAPI_GLX_BIND \ ++ (VA_MAJOR_VERSION == 0 && \ ++ ((VA_MINOR_VERSION == 30 && \ ++ VA_MICRO_VERSION == 4 && VA_SDS_VERSION >= 5) || \ ++ (VA_MINOR_VERSION == 31 && \ ++ VA_MICRO_VERSION == 0 && VA_SDS_VERSION < 5))) ++ ++/* Compatibility glue with VA-API >= 0.31 */ ++#if defined VA_CHECK_VERSION ++#if VA_CHECK_VERSION(0,31,0) ++#define vaPutImage2 vaPutImage ++#define vaAssociateSubpicture2 vaAssociateSubpicture ++#endif ++#endif ++ ++static vo_info_t info = { ++ "VA API with X11", ++ "vaapi", ++ "Gwenole Beauchesne ", ++ "" ++}; ++ ++const LIBVO_EXTERN(vaapi) ++ ++/* Numbers of video surfaces */ ++#define MAX_OUTPUT_SURFACES 2 /* Maintain synchronisation points in flip_page() */ ++#define MAX_VIDEO_SURFACES 21 /* Maintain free surfaces in a queue (use least-recently-used) */ ++#define NUM_VIDEO_SURFACES_MPEG2 3 /* 1 decode frame, up to 2 references */ ++#define NUM_VIDEO_SURFACES_MPEG4 3 /* 1 decode frame, up to 2 references */ ++#define NUM_VIDEO_SURFACES_H264 21 /* 1 decode frame, up to 20 references */ ++#define NUM_VIDEO_SURFACES_VC1 3 /* 1 decode frame, up to 2 references */ ++ ++static void ensure_osd(void); ++static int reset_xrender_specific(void); ++ ++typedef void (*draw_alpha_func)(int x0, int y0, int w, int h, ++ unsigned char *src, unsigned char *srca, ++ int stride); ++ ++typedef void (*eosd_draw_alpha_func)(unsigned char *src, ++ int src_w, int src_h, int src_stride, ++ int dst_x, int dst_y, ++ uint32_t color); ++ ++struct vaapi_surface { ++ VASurfaceID id; ++ VAImage image; ++ int is_bound; /* Flag: image bound to the surface? */ ++}; ++ ++struct vaapi_equalizer { ++ VADisplayAttribute brightness; ++ VADisplayAttribute contrast; ++ VADisplayAttribute hue; ++ VADisplayAttribute saturation; ++}; ++ ++static int g_is_visible; ++static int g_is_paused; ++static uint32_t g_image_width; ++static uint32_t g_image_height; ++static uint32_t g_image_format; ++static uint32_t g_image_fields; ++static Pixmap g_image_pixmap; ++static struct vo_rect g_output_rect; ++static struct vaapi_surface *g_output_surfaces[MAX_OUTPUT_SURFACES]; ++static unsigned int g_output_surface; ++static int g_deint; ++static int g_deint_type; ++static int g_colorspace; ++ ++static int gl_enabled; ++static int gl_use_tfp; ++#if CONFIG_GL ++static MPGLContext gl_context; ++static int gl_binding; ++static int gl_reflect; ++static int gl_finish; ++static GLuint gl_texture; ++static GLuint gl_font_base; ++static Pixmap gl_pixmap; ++static int gl_visual_attr[] = { ++ GLX_RGBA, ++ GLX_RED_SIZE, 1, ++ GLX_GREEN_SIZE, 1, ++ GLX_BLUE_SIZE, 1, ++ GLX_DOUBLEBUFFER, ++ GL_NONE ++}; ++#endif ++ ++#if CONFIG_VAAPI_GLX ++static void *gl_surface; ++#endif ++ ++static int xr_enabled; ++#if CONFIG_XRENDER ++static Pixmap g_image_pixmap; ++static Picture xr_video_picture; ++static Picture xr_window_picture; ++#endif ++ ++static struct vaapi_context *va_context; ++static VAProfile *va_profiles; ++static int va_num_profiles; ++static VAEntrypoint *va_entrypoints; ++static int va_num_entrypoints; ++static VASurfaceID *va_surface_ids; ++static int va_num_surfaces; ++static struct vaapi_surface **va_free_surfaces; ++static int va_free_surfaces_head_index; ++static int va_free_surfaces_tail_index; ++static VAImageFormat *va_image_formats; ++static int va_num_image_formats; ++static VAImageFormat *va_subpic_formats; ++static unsigned int *va_subpic_flags; ++static int va_num_subpic_formats; ++static VAImage va_osd_image; ++static uint8_t *va_osd_image_data; ++static VASubpictureID va_osd_subpicture; ++static int va_osd_associated; ++static draw_alpha_func va_osd_draw_alpha; ++static uint8_t *va_osd_palette; ++static struct vaapi_equalizer va_equalizer; ++static VAImage va_eosd_image; ++static uint8_t *va_eosd_image_data; ++static VASubpictureID va_eosd_subpicture; ++static int va_eosd_associated; ++static eosd_draw_alpha_func va_eosd_draw_alpha; ++ ++///< Flag: direct surface mapping: use mpi->number to select free VA surface? ++static int va_dm; ++ ++///< Flag: gather run-time statistics (CPU usage, frequency) ++static int cpu_stats; ++static unsigned int cpu_frequency; ++static float cpu_usage; ++ ++// X error trap ++static int x11_error_code = 0; ++static int (*old_error_handler)(Display *, XErrorEvent *); ++ ++static int error_handler(Display *dpy, XErrorEvent *error) ++{ ++ x11_error_code = error->error_code; ++ return 0; ++} ++ ++static void x11_trap_errors(void) ++{ ++ x11_error_code = 0; ++ old_error_handler = XSetErrorHandler(error_handler); ++} ++ ++static int x11_untrap_errors(void) ++{ ++ XSetErrorHandler(old_error_handler); ++ return x11_error_code; ++} ++ ++static int check_status(VAStatus status, const char *msg) ++{ ++ if (status != VA_STATUS_SUCCESS) { ++ mp_msg(MSGT_VO, MSGL_ERR, "[vo_vaapi] %s: %s\n", msg, vaErrorStr(status)); ++ return 0; ++ } ++ return 1; ++} ++ ++static const char *string_of_VAImageFormat(VAImageFormat *imgfmt) ++{ ++ static char str[5]; ++ str[0] = imgfmt->fourcc; ++ str[1] = imgfmt->fourcc >> 8; ++ str[2] = imgfmt->fourcc >> 16; ++ str[3] = imgfmt->fourcc >> 24; ++ str[4] = '\0'; ++ return str; ++} ++ ++static const char *string_of_VAProfile(VAProfile profile) ++{ ++ switch (profile) { ++#define PROFILE(profile) \ ++ case VAProfile##profile: return "VAProfile" #profile ++ PROFILE(MPEG2Simple); ++ PROFILE(MPEG2Main); ++ PROFILE(MPEG4Simple); ++ PROFILE(MPEG4AdvancedSimple); ++ PROFILE(MPEG4Main); ++ PROFILE(H264Baseline); ++ PROFILE(H264Main); ++ PROFILE(H264High); ++ PROFILE(VC1Simple); ++ PROFILE(VC1Main); ++ PROFILE(VC1Advanced); ++#undef PROFILE ++ } ++ return ""; ++} ++ ++static const char *string_of_VAEntrypoint(VAEntrypoint entrypoint) ++{ ++ switch (entrypoint) { ++#define ENTRYPOINT(entrypoint) \ ++ case VAEntrypoint##entrypoint: return "VAEntrypoint" #entrypoint ++ ENTRYPOINT(VLD); ++ ENTRYPOINT(IZZ); ++ ENTRYPOINT(IDCT); ++ ENTRYPOINT(MoComp); ++ ENTRYPOINT(Deblocking); ++#undef ENTRYPOINT ++ } ++ return ""; ++} ++ ++static int has_profile(VAProfile profile) ++{ ++ if (va_profiles && va_num_profiles > 0) { ++ int i; ++ for (i = 0; i < va_num_profiles; i++) { ++ if (va_profiles[i] == profile) ++ return 1; ++ } ++ } ++ return 0; ++} ++ ++static int VAProfile_from_imgfmt(uint32_t format) ++{ ++ static const int mpeg2_profiles[] = ++ { VAProfileMPEG2Main, VAProfileMPEG2Simple, -1 }; ++ static const int mpeg4_profiles[] = ++ { VAProfileMPEG4Main, VAProfileMPEG4AdvancedSimple, VAProfileMPEG4Simple, -1 }; ++ static const int h264_profiles[] = ++ { VAProfileH264High, VAProfileH264Main, VAProfileH264Baseline, -1 }; ++ static const int wmv3_profiles[] = ++ { VAProfileVC1Main, VAProfileVC1Simple, -1 }; ++ static const int vc1_profiles[] = ++ { VAProfileVC1Advanced, -1 }; ++ ++ const int *profiles = NULL; ++ switch (IMGFMT_VAAPI_CODEC(format)) { ++ case IMGFMT_VAAPI_CODEC_MPEG2: ++ profiles = mpeg2_profiles; ++ break; ++ case IMGFMT_VAAPI_CODEC_MPEG4: ++ profiles = mpeg4_profiles; ++ break; ++ case IMGFMT_VAAPI_CODEC_H264: ++ profiles = h264_profiles; ++ break; ++ case IMGFMT_VAAPI_CODEC_VC1: ++ switch (format) { ++ case IMGFMT_VAAPI_WMV3: ++ profiles = wmv3_profiles; ++ break; ++ case IMGFMT_VAAPI_VC1: ++ profiles = vc1_profiles; ++ break; ++ } ++ break; ++ } ++ ++ if (profiles) { ++ for (int i = 0; profiles[i] != -1; i++) { ++ if (has_profile(profiles[i])) ++ return profiles[i]; ++ } ++ } ++ return -1; ++} ++ ++static int has_entrypoint(VAEntrypoint entrypoint) ++{ ++ if (va_entrypoints && va_num_entrypoints > 0) { ++ int i; ++ for (i = 0; i < va_num_entrypoints; i++) { ++ if (va_entrypoints[i] == entrypoint) ++ return 1; ++ } ++ } ++ return 0; ++} ++ ++static int VAEntrypoint_from_imgfmt(uint32_t format) ++{ ++ int entrypoint = 0; ++ switch (format) { ++ case IMGFMT_VAAPI_MPEG2: ++ case IMGFMT_VAAPI_MPEG4: ++ case IMGFMT_VAAPI_H263: ++ case IMGFMT_VAAPI_H264: ++ case IMGFMT_VAAPI_WMV3: ++ case IMGFMT_VAAPI_VC1: ++ entrypoint = VAEntrypointVLD; ++ break; ++ case IMGFMT_VAAPI_MPEG2_IDCT: ++ entrypoint = VAEntrypointIDCT; ++ break; ++ case IMGFMT_VAAPI_MPEG2_MOCO: ++ entrypoint = VAEntrypointMoComp; ++ break; ++ } ++ ++ if (entrypoint) ++ return has_entrypoint(entrypoint); ++ ++ return -1; ++} ++ ++static VAImageFormat *find_image_format(uint32_t fourcc) ++{ ++ if (va_image_formats && va_num_image_formats > 0) { ++ int i; ++ for (i = 0; i < va_num_image_formats; i++) { ++ if (va_image_formats[i].fourcc == fourcc) ++ return &va_image_formats[i]; ++ } ++ } ++ return NULL; ++} ++ ++static VAImageFormat *VAImageFormat_from_imgfmt(uint32_t format) ++{ ++ uint32_t fourcc = 0; ++ ++ switch (format) { ++ case IMGFMT_NV12: fourcc = VA_FOURCC('N','V','1','2'); break; ++ case IMGFMT_YV12: fourcc = VA_FOURCC('Y','V','1','2'); break; ++ case IMGFMT_I420: fourcc = VA_FOURCC('I','4','2','0'); break; ++ case IMGFMT_IYUV: fourcc = VA_FOURCC('I','Y','U','V'); break; ++ } ++ ++ if (fourcc) ++ return find_image_format(fourcc); ++ ++ return NULL; ++} ++ ++static struct vaapi_surface *alloc_vaapi_surface(unsigned int width, ++ unsigned int height, ++ unsigned int format) ++{ ++ struct vaapi_surface *surface = NULL; ++ struct vaapi_surface **surfaces; ++ VASurfaceID *surface_ids; ++ VAStatus status; ++ ++ surface = calloc(1, sizeof(*surface)); ++ if (!surface) ++ goto error; ++ ++ surfaces = realloc(va_free_surfaces, ++ (1 + va_num_surfaces) * sizeof(surfaces[0])); ++ if (!surfaces) ++ goto error; ++ ++ surface_ids = realloc(va_surface_ids, ++ (1 + va_num_surfaces) * sizeof(surface_ids[0])); ++ if (!surface_ids) ++ goto error; ++ ++ status = vaCreateSurfaces(va_context->display, width, height, format, ++ 1, &surface->id); ++ if (!check_status(status, "vaCreateSurfaces()")) ++ goto error; ++ ++ va_surface_ids = surface_ids; ++ va_surface_ids[va_num_surfaces] = surface->id; ++ va_free_surfaces = surfaces; ++ va_free_surfaces[va_num_surfaces] = surface; ++ surface->image.image_id = VA_INVALID_ID; ++ surface->image.buf = VA_INVALID_ID; ++ ++va_num_surfaces; ++ return surface; ++error: ++ free(surface); ++ return NULL; ++} ++ ++static void resize(void) ++{ ++ struct vo_rect src; ++ ++ calc_src_dst_rects(g_image_width, g_image_height, ++ &src, &g_output_rect, NULL, NULL); ++ ++ ensure_osd(); ++ ++ vo_x11_clearwindow(mDisplay, vo_window); ++ ++#if CONFIG_GL ++#define FOVY 60.0f ++#define ASPECT 1.0f ++#define Z_NEAR 0.1f ++#define Z_FAR 100.0f ++#define Z_CAMERA 0.869f ++ ++ if (gl_enabled) { ++ glViewport(0, 0, vo_dwidth, vo_dheight); ++ glMatrixMode(GL_PROJECTION); ++ glLoadIdentity(); ++ gluPerspective(FOVY, ASPECT, Z_NEAR, Z_FAR); ++ glMatrixMode(GL_MODELVIEW); ++ glLoadIdentity(); ++ ++ glTranslatef(-0.5f, -0.5f, -Z_CAMERA); ++ glScalef(1.0f / (GLfloat)vo_dwidth, ++ -1.0f / (GLfloat)vo_dheight, ++ 1.0f / (GLfloat)vo_dwidth); ++ glTranslatef(0.0f, -1.0f * (GLfloat)vo_dheight, 0.0f); ++ } ++#endif ++ ++#if CONFIG_XRENDER ++ if (xr_enabled) ++ reset_xrender_specific(); ++#endif ++ ++ if (g_is_visible) ++ flip_page(); ++} ++ ++#if CONFIG_GL ++static int gl_build_font(void) ++{ ++ XFontStruct *fi; ++ ++ gl_font_base = glGenLists(96); ++ ++ fi = XLoadQueryFont(mDisplay, "-adobe-helvetica-medium-r-normal--16-*-*-*-p-*-iso8859-1" ); ++ if (!fi) { ++ fi = XLoadQueryFont(mDisplay, "fixed"); ++ if (!fi) ++ return -1; ++ } ++ ++ glXUseXFont(fi->fid, 32, 96, gl_font_base); ++ XFreeFont(mDisplay, fi); ++ return 0; ++} ++ ++static void gl_printf(const char *format, ...) ++{ ++ va_list args; ++ char *text; ++ int textlen; ++ ++ va_start(args, format); ++ textlen = vsnprintf(NULL, 0, format, args); ++ va_end(args); ++ ++ text = malloc(textlen + 1); ++ if (!text) ++ return; ++ ++ va_start(args, format); ++ vsprintf(text, format, args); ++ va_end(args); ++ ++ glPushAttrib(GL_LIST_BIT); ++ glListBase(gl_font_base - 32); ++ glCallLists(textlen, GL_UNSIGNED_BYTE, text); ++ glPopAttrib(); ++ free(text); ++} ++ ++static void gl_draw_rectangle(int x, int y, int w, int h, unsigned int rgba) ++{ ++ glColor4f((GLfloat)((rgba >> 24) & 0xff) / 255.0, ++ (GLfloat)((rgba >> 16) & 0xff) / 255.0, ++ (GLfloat)((rgba >> 8) & 0xff) / 255.0, ++ (GLfloat)(rgba & 0xff) / 255.0); ++ ++ glTranslatef((GLfloat)x, (GLfloat)y, 0.0f); ++ glBegin(GL_QUADS); ++ { ++ glVertex2i(0, 0); ++ glVertex2i(w, 0); ++ glVertex2i(w, h); ++ glVertex2i(0, h); ++ } ++ glEnd(); ++} ++#endif ++ ++#if CONFIG_XRENDER ++static int init_xrender(void) ++{ ++ int dummy; ++ ++ return XRenderQueryExtension(mDisplay, &dummy, &dummy); ++} ++ ++static void uninit_xrender(void) ++{ ++} ++#endif ++ ++static inline unsigned char *get_osd_image_data(int x0, int y0) ++{ ++ return (va_osd_image_data + ++ va_osd_image.offsets[0] + ++ va_osd_image.pitches[0] * y0 + ++ x0 * ((va_osd_image.format.bits_per_pixel + 7) / 8)); ++} ++ ++static void draw_alpha_rgb32(int x0, int y0, int w, int h, ++ unsigned char *src, unsigned char *srca, ++ int stride) ++{ ++ int x, y; ++ const unsigned int dststride = va_osd_image.pitches[0]; ++ unsigned char *dst = get_osd_image_data(x0, y0); ++ ++ for (y = 0; y < h; y++, dst += dststride, src += stride, srca += stride) ++ for (x = 0; x < w; x++) { ++ const unsigned char c = src[x]; ++ dst[4*x + 0] = c; ++ dst[4*x + 1] = c; ++ dst[4*x + 2] = c; ++ dst[4*x + 3] = -srca[x]; ++ } ++} ++ ++#if USE_VAAPI_IA44_FORMATS ++static void draw_alpha_IA44(int x0, int y0, int w, int h, ++ unsigned char *src, unsigned char *srca, ++ int stride) ++{ ++ int x, y; ++ const unsigned int dststride = va_osd_image.pitches[0]; ++ unsigned char *dst = get_osd_image_data(x0, y0); ++ ++ for (y = 0; y < h; y++, dst += dststride) ++ for (x = 0; x < w; x++) ++ dst[x] = (src[y*stride + x] & 0xf0) | (-srca[y*stride + x] >> 4); ++} ++ ++static void draw_alpha_AI44(int x0, int y0, int w, int h, ++ unsigned char *src, unsigned char *srca, ++ int stride) ++{ ++ int x, y; ++ const unsigned int dststride = va_osd_image.pitches[0]; ++ unsigned char *dst = get_osd_image_data(x0, y0); ++ ++ for (y = 0; y < h; y++, dst += dststride) ++ for (x = 0; x < w; x++) ++ dst[x] = (src[y*stride + x] >> 4) | (-srca[y*stride + x] & 0xf0); ++} ++#endif ++ ++static void draw_alpha_IA88(int x0, int y0, int w, int h, ++ unsigned char *src, unsigned char *srca, ++ int stride) ++{ ++ int x, y; ++ const unsigned int dststride = va_osd_image.pitches[0]; ++ unsigned char *dst = get_osd_image_data(x0, y0); ++ ++ for (y = 0; y < h; y++, dst += dststride) ++ for (x = 0; x < w; x++) { ++ dst[2*x + 0] = src [y*stride + x]; ++ dst[2*x + 1] = -srca[y*stride + x]; ++ } ++} ++ ++static void draw_alpha_AI88(int x0, int y0, int w, int h, ++ unsigned char *src, unsigned char *srca, ++ int stride) ++{ ++ int x, y; ++ const unsigned int dststride = va_osd_image.pitches[0]; ++ unsigned char *dst = get_osd_image_data(x0, y0); ++ ++ for (y = 0; y < h; y++, dst += dststride) ++ for (x = 0; x < w; x++) { ++ dst[2*x + 0] = -srca[y*stride + x]; ++ dst[2*x + 1] = src [y*stride + x]; ++ } ++} ++ ++///< List of subpicture formats in preferred order ++static const struct { ++ uint32_t format; ++ draw_alpha_func draw_alpha; ++} ++va_osd_info[] = { ++#if USE_VAAPI_IA44_FORMATS ++ { VA_FOURCC('I','A','4','4'), draw_alpha_IA44 }, ++ { VA_FOURCC('A','I','4','4'), draw_alpha_AI44 }, ++#endif ++ { VA_FOURCC('I','A','8','8'), draw_alpha_IA88 }, ++ { VA_FOURCC('A','I','8','8'), draw_alpha_AI88 }, ++ { VA_FOURCC('B','G','R','A'), draw_alpha_rgb32 }, ++ { VA_FOURCC('R','G','B','A'), draw_alpha_rgb32 }, ++ { 0, NULL } ++}; ++ ++static uint8_t *gen_osd_palette(const VAImage *image) ++{ ++ uint8_t *palette; ++ int i, is_rgb; ++ int r_idx = -1, g_idx = -1, b_idx = -1; ++ int y_idx = -1, u_idx = -1, v_idx = -1; ++ int i_idx = -1, a_idx = -1; ++ ++ if (image->num_palette_entries < 1) ++ return NULL; ++ ++ palette = malloc(image->num_palette_entries * image->entry_bytes); ++ if (!palette) ++ return NULL; ++ ++ for (i = 0; i < image->entry_bytes; i++) { ++ switch (image->component_order[i]) { ++ case 'R': r_idx = i; is_rgb = 1; break; ++ case 'G': g_idx = i; is_rgb = 1; break; ++ case 'B': b_idx = i; is_rgb = 1; break; ++ case 'Y': y_idx = i; is_rgb = 0; break; ++ case 'U': u_idx = i; is_rgb = 0; break; ++ case 'V': v_idx = i; is_rgb = 0; break; ++ case 'I': i_idx = i; break; ++ case 'A': a_idx = i; break; ++ } ++ } ++ ++ if (r_idx != -1 && g_idx != -1 && b_idx != -1) { /* RGB format */ ++ for (i = 0; i < image->num_palette_entries; i++) { ++ const int n = i * image->entry_bytes; ++ palette[n + r_idx] = i * 0xff / (image->num_palette_entries - 1); ++ palette[n + g_idx] = i * 0xff / (image->num_palette_entries - 1); ++ palette[n + b_idx] = i * 0xff / (image->num_palette_entries - 1); ++ } ++ } ++ else if (y_idx != -1 && u_idx != -1 && v_idx != -1) { /* YUV format */ ++ for (i = 0; i < image->num_palette_entries; i++) { ++ const int n = i * image->entry_bytes; ++ palette[n + y_idx] = i * 0xff / (image->num_palette_entries - 1); ++ palette[n + u_idx] = 0x80; ++ palette[n + v_idx] = 0x80; ++ } ++ } ++ else if (i_idx != -1 && a_idx != -1) {/* AYUV format (GMA500 "psb" bug) */ ++ for (i = 0; i < image->num_palette_entries; i++) { ++ const int n = i * image->entry_bytes; ++ palette[n + 0] = 0x80; ++ palette[n + 1] = 0x80; ++ palette[n + 2] = 16 + i * 220 / (image->num_palette_entries - 1); ++ palette[n + 3] = 0; ++ } ++ } ++ else { ++ mp_msg(MSGT_VO, MSGL_ERR, "[vo_vaapi] Could not set up subpicture palette\n"); ++ free(palette); ++ palette = NULL; ++ } ++ return palette; ++} ++ ++static void disable_osd(void) ++{ ++ if (!va_osd_associated) ++ return; ++ ++ vaDeassociateSubpicture(va_context->display, ++ va_osd_subpicture, ++ va_surface_ids, va_num_surfaces); ++ ++ va_osd_associated = 0; ++} ++ ++static int enable_osd(void) ++{ ++ VAStatus status; ++ ++ disable_osd(); ++ ++ status = vaAssociateSubpicture2(va_context->display, ++ va_osd_subpicture, ++ va_surface_ids, va_num_surfaces, ++ 0, 0, ++ va_osd_image.width, va_osd_image.height, ++ 0, 0, ++ g_image_width, g_image_height, ++ 0); ++ if (!check_status(status, "vaAssociateSubpicture()")) ++ return -1; ++ ++ va_osd_associated = 1; ++ return 0; ++} ++ ++static void destroy_osd(void) ++{ ++ disable_osd(); ++ ++ if (va_osd_subpicture != VA_INVALID_ID) { ++ vaDestroySubpicture(va_context->display, va_osd_subpicture); ++ va_osd_subpicture = VA_INVALID_ID; ++ } ++ ++ if (va_osd_image.image_id != VA_INVALID_ID) { ++ vaDestroyImage(va_context->display, va_osd_image.image_id); ++ va_osd_image.image_id = VA_INVALID_ID; ++ va_osd_image.width = 0; ++ va_osd_image.height = 0; ++ } ++} ++ ++static void create_osd(void) ++{ ++ VAStatus status; ++ int i, j; ++ ++ for (i = 0; va_osd_info[i].format; i++) { ++ for (j = 0; j < va_num_subpic_formats; j++) ++ if (va_subpic_formats[j].fourcc == va_osd_info[i].format) ++ break; ++ if (j < va_num_subpic_formats && ++ vaCreateImage(va_context->display, &va_subpic_formats[j], ++ g_output_rect.width, g_output_rect.height, ++ &va_osd_image) == VA_STATUS_SUCCESS) { ++ va_osd_palette = gen_osd_palette(&va_osd_image); ++ if (((!va_osd_image.num_palette_entries) ^ (!va_osd_palette)) == 0) ++ break; ++ vaDestroyImage(va_context->display, va_osd_image.image_id); ++ va_osd_image.image_id = VA_INVALID_ID; ++ } ++ } ++ ++ if (va_osd_info[i].format && ++ vaCreateSubpicture(va_context->display, va_osd_image.image_id, ++ &va_osd_subpicture) == VA_STATUS_SUCCESS) { ++ va_osd_draw_alpha = va_osd_info[i].draw_alpha; ++ if (va_osd_palette) { ++ status = vaSetImagePalette(va_context->display, ++ va_osd_image.image_id, va_osd_palette); ++ check_status(status, "vaSetImagePalette()"); ++ } ++ mp_msg(MSGT_VO, MSGL_DBG2, "[vo_vaapi] Using %s surface for OSD\n", ++ string_of_VAImageFormat(&va_osd_image.format)); ++ } ++} ++ ++static void ensure_osd(void) ++{ ++ if (g_output_rect.width == va_osd_image.width && ++ g_output_rect.height == va_osd_image.height) ++ return; ++ ++ destroy_osd(); ++ create_osd(); ++} ++ ++static inline unsigned char *get_eosd_image_data(int x0, int y0) ++{ ++ return (va_eosd_image_data + ++ va_eosd_image.offsets[0] + ++ va_eosd_image.pitches[0] * y0 + ++ x0 * ((va_eosd_image.format.bits_per_pixel + 7) / 8)); ++} ++ ++static void eosd_draw_alpha_bgra(unsigned char *src, ++ int src_w, int src_h, int src_stride, ++ int dst_x, int dst_y, ++ uint32_t color) ++{ ++ int x, y; ++ const unsigned int dst_stride = va_eosd_image.pitches[0]; ++ unsigned char *dst = get_eosd_image_data(dst_x, dst_y); ++ const unsigned int r = (color >> 24) & 0xff; ++ const unsigned int g = (color >> 16) & 0xff; ++ const unsigned int b = (color >> 8) & 0xff; ++ const unsigned int a = 0xff - (color & 0xff); ++ ++ for (y = 0; y < src_h; y++, dst += dst_stride, src += src_stride) ++ for (x = 0; x < src_w; x++) { ++ const unsigned int v = src[x]; ++ dst[4*x + 0] = (b * v + dst[4*x + 0] * (0xff - v)) / 255; ++ dst[4*x + 1] = (g * v + dst[4*x + 1] * (0xff - v)) / 255; ++ dst[4*x + 2] = (r * v + dst[4*x + 2] * (0xff - v)) / 255; ++ dst[4*x + 3] = (a * v + dst[4*x + 3] * (0xff - v)) / 255; ++ } ++} ++ ++static void eosd_draw_alpha_rgba(unsigned char *src, ++ int src_w, int src_h, int src_stride, ++ int dst_x, int dst_y, ++ uint32_t color) ++{ ++ int x, y; ++ const unsigned int dst_stride = va_eosd_image.pitches[0]; ++ unsigned char *dst = get_eosd_image_data(dst_x, dst_y); ++ const unsigned int r = (color >> 24) & 0xff; ++ const unsigned int g = (color >> 16) & 0xff; ++ const unsigned int b = (color >> 8) & 0xff; ++ const unsigned int a = 0xff - (color & 0xff); ++ ++ for (y = 0; y < src_h; y++, dst += dst_stride, src += src_stride) ++ for (x = 0; x < src_w; x++) { ++ const unsigned int v = src[x]; ++ dst[4*x + 0] = (r * v + dst[4*x + 0] * (0xff - v)) / 255; ++ dst[4*x + 1] = (g * v + dst[4*x + 1] * (0xff - v)) / 255; ++ dst[4*x + 2] = (b * v + dst[4*x + 2] * (0xff - v)) / 255; ++ dst[4*x + 3] = (a * v + dst[4*x + 3] * (0xff - v)) / 255; ++ } ++} ++ ++static void disable_eosd(void) ++{ ++ if (!va_eosd_associated) ++ return; ++ ++ vaDeassociateSubpicture(va_context->display, ++ va_eosd_subpicture, ++ va_surface_ids, va_num_surfaces); ++ ++ va_eosd_associated = 0; ++} ++ ++static int enable_eosd(void) ++{ ++ VAStatus status; ++ ++ if (va_eosd_associated) ++ return 0; ++ ++ status = vaAssociateSubpicture2(va_context->display, ++ va_eosd_subpicture, ++ va_surface_ids, va_num_surfaces, ++ 0, 0, g_image_width, g_image_height, ++ 0, 0, g_image_width, g_image_height, ++ 0); ++ if (!check_status(status, "vaAssociateSubpicture()")) ++ return -1; ++ ++ va_eosd_associated = 1; ++ return 0; ++} ++ ++///< List of subpicture formats in preferred order ++static const struct { ++ uint32_t format; ++ eosd_draw_alpha_func draw_alpha; ++} ++va_eosd_info[] = { ++ { VA_FOURCC('B','G','R','A'), eosd_draw_alpha_bgra }, ++ { VA_FOURCC('R','G','B','A'), eosd_draw_alpha_rgba }, ++ { 0, NULL } ++}; ++ ++static int is_direct_mapping_init(void) ++{ ++ VADisplayAttribute attr; ++ VAStatus status; ++ ++ if (va_dm < 2) ++ return va_dm; ++ ++ /* If the driver doesn't make a copy of the VA surface for ++ display, then we have to retain it until it's no longer the ++ visible surface. In other words, if the driver is using ++ DirectSurface mode, we don't want to decode the new surface ++ into the previous one that was used for display. */ ++ attr.type = VADisplayAttribDirectSurface; ++ attr.flags = VA_DISPLAY_ATTRIB_GETTABLE; ++ ++ status = vaGetDisplayAttributes(va_context->display, &attr, 1); ++ if (status == VA_STATUS_SUCCESS) ++ return !attr.value; ++ return 0; ++} ++ ++static inline int is_direct_mapping(void) ++{ ++ static int dm = -1; ++ if (dm < 0) { ++ dm = is_direct_mapping_init(); ++ if (dm) ++ mp_msg(MSGT_VO, MSGL_INFO, ++ "[vo_vaapi] Using 1:1 VA surface mapping\n"); ++ } ++ return dm; ++} ++ ++static int int_012(int *n) ++{ ++ return *n >= 0 && *n <= 2; ++} ++ ++static const opt_t subopts[] = { ++ { "dm", OPT_ARG_INT, &va_dm, (opt_test_f)int_012 }, ++ { "stats", OPT_ARG_BOOL, &cpu_stats, NULL }, ++ { "deint", OPT_ARG_INT, &g_deint, (opt_test_f)int_012 }, ++#if USE_VAAPI_COLORSPACE ++ { "colorspace", OPT_ARG_INT, &g_colorspace, (opt_test_f)int_012 }, ++#endif ++#if CONFIG_GL ++ { "gl", OPT_ARG_BOOL, &gl_enabled, NULL }, ++ { "glfinish", OPT_ARG_BOOL, &gl_finish, NULL }, ++#if USE_VAAPI_GLX_BIND ++ { "bind", OPT_ARG_BOOL, &gl_binding, NULL }, ++#endif ++ { "reflect", OPT_ARG_BOOL, &gl_reflect, NULL }, ++ { "tfp", OPT_ARG_BOOL, &gl_use_tfp, NULL }, ++#endif ++#if CONFIG_XRENDER ++ { "xrender", OPT_ARG_BOOL, &xr_enabled, NULL }, ++#endif ++ { NULL, } ++}; ++ ++static int preinit(const char *arg) ++{ ++ VADisplayAttribute *display_attrs; ++ VAStatus status; ++ int va_major_version, va_minor_version; ++ int i, max_image_formats, max_subpic_formats, max_profiles; ++ int num_display_attrs, max_display_attrs; ++ ++ va_dm = 2; ++ g_deint = 0; ++ g_deint_type = 2; ++ g_colorspace = 1; ++ if (subopt_parse(arg, subopts) != 0) { ++ mp_msg(MSGT_VO, MSGL_FATAL, ++ "\n-vo vaapi command line help:\n" ++ "Example: mplayer -vo vaapi:gl\n" ++ "\nOptions:\n" ++ " dm\n" ++ " 0: use least-recently-used VA surface\n" ++ " 1: identify VA surface with MPI index\n" ++ " 2: auto-detect use of direct surface mapping (default)\n" ++ " deint (all modes > 0 respect -field-dominance)\n" ++ " 0: no deinterlacing (default)\n" ++ " 1: only show first field\n" ++ " 2: bob deinterlacing\n" ++ " colorspace\n" ++ " 0: guess based on video resolution\n" ++ " 1: ITU-R BT.601 (default)\n" ++ " 2: ITU-R BT.709\n" ++#if CONFIG_GL ++ " gl\n" ++ " Enable OpenGL rendering\n" ++ " glfinish\n" ++ " Call glFinish() before swapping buffers\n" ++ " tfp\n" ++ " Use GLX texture-from-pixmap instead of VA/GLX extensions\n" ++#if USE_VAAPI_GLX_BIND ++ " bind\n" ++ " Use VA surface binding instead of copy\n" ++#endif ++ " reflect\n" ++ " Enable OpenGL reflection effects\n" ++#endif ++#if CONFIG_XRENDER ++ " xrender\n" ++ " Enable Xrender rendering, thus vaPutSurface() to a Pixmap\n" ++#endif ++ "\n" ); ++ return -1; ++ } ++ if (gl_enabled && xr_enabled) { ++ mp_msg(MSGT_VO, MSGL_ERR, "[vo_vaapi] User requested both Xrender and OpenGL rendering\n"); ++ return -1; ++ } ++ if (g_deint) ++ g_deint_type = g_deint; ++#if CONFIG_GL ++ if (gl_enabled) ++ mp_msg(MSGT_VO, MSGL_INFO, "[vo_vaapi] Using OpenGL rendering%s\n", ++ gl_reflect ? ", with reflection effects" : ""); ++#endif ++#if CONFIG_XRENDER ++ if (xr_enabled) ++ mp_msg(MSGT_VO, MSGL_INFO, "[vo_vaapi] Using Xrender rendering\n"); ++#endif ++ ++ stats_init(); ++ ++#if CONFIG_GL ++ if (gl_enabled && !init_mpglcontext(&gl_context, GLTYPE_X11)) ++ return -1; ++ else ++#endif ++ if (!vo_init()) ++ return -1; ++#if CONFIG_XRENDER ++ if (xr_enabled && !init_xrender()) ++ return -1; ++#endif ++ ++ va_context = calloc(1, sizeof(*va_context)); ++ if (!va_context) ++ return -1; ++ ++#if CONFIG_VAAPI_GLX ++ if (gl_enabled) ++ va_context->display = vaGetDisplayGLX(mDisplay); ++ else ++#endif ++ va_context->display = vaGetDisplay(mDisplay); ++ if (!va_context->display) ++ return -1; ++ mp_msg(MSGT_VO, MSGL_DBG2, "[vo_vaapi] preinit(): VA display %p\n", va_context->display); ++ ++ status = vaInitialize(va_context->display, &va_major_version, &va_minor_version); ++ if (!check_status(status, "vaInitialize()")) ++ return -1; ++ mp_msg(MSGT_VO, MSGL_DBG2, "[vo_vaapi] preinit(): VA API version %d.%d\n", ++ va_major_version, va_minor_version); ++ ++ max_image_formats = vaMaxNumImageFormats(va_context->display); ++ va_image_formats = calloc(max_image_formats, sizeof(*va_image_formats)); ++ if (!va_image_formats) ++ return -1; ++ status = vaQueryImageFormats(va_context->display, va_image_formats, &va_num_image_formats); ++ if (!check_status(status, "vaQueryImageFormats()")) ++ return -1; ++ mp_msg(MSGT_VO, MSGL_DBG2, "[vo_vaapi] preinit(): %d image formats available\n", ++ va_num_image_formats); ++ for (i = 0; i < va_num_image_formats; i++) ++ mp_msg(MSGT_VO, MSGL_DBG2, " %s\n", string_of_VAImageFormat(&va_image_formats[i])); ++ ++ max_subpic_formats = vaMaxNumSubpictureFormats(va_context->display); ++ va_subpic_formats = calloc(max_subpic_formats, sizeof(*va_subpic_formats)); ++ if (!va_subpic_formats) ++ return -1; ++ va_subpic_flags = calloc(max_subpic_formats, sizeof(*va_subpic_flags)); ++ if (!va_subpic_flags) ++ return -1; ++ status = vaQuerySubpictureFormats(va_context->display, va_subpic_formats, va_subpic_flags, &va_num_subpic_formats); ++ if (!check_status(status, "vaQuerySubpictureFormats()")) ++ va_num_subpic_formats = 0; /* XXX: don't error out for IEGD */ ++ mp_msg(MSGT_VO, MSGL_DBG2, "[vo_vaapi] preinit(): %d subpicture formats available\n", ++ va_num_subpic_formats); ++ for (i = 0; i < va_num_subpic_formats; i++) ++ mp_msg(MSGT_VO, MSGL_DBG2, " %s, flags 0x%x\n", string_of_VAImageFormat(&va_subpic_formats[i]), va_subpic_flags[i]); ++ ++ max_profiles = vaMaxNumProfiles(va_context->display); ++ va_profiles = calloc(max_profiles, sizeof(*va_profiles)); ++ if (!va_profiles) ++ return -1; ++ status = vaQueryConfigProfiles(va_context->display, va_profiles, &va_num_profiles); ++ if (!check_status(status, "vaQueryConfigProfiles()")) ++ return -1; ++ mp_msg(MSGT_VO, MSGL_DBG2, "[vo_vaapi] preinit(): %d profiles available\n", ++ va_num_profiles); ++ for (i = 0; i < va_num_profiles; i++) ++ mp_msg(MSGT_VO, MSGL_DBG2, " %s\n", string_of_VAProfile(va_profiles[i])); ++ ++ va_osd_subpicture = VA_INVALID_ID; ++ va_osd_image.image_id = VA_INVALID_ID; ++ va_eosd_subpicture = VA_INVALID_ID; ++ va_eosd_image.image_id = VA_INVALID_ID; ++ ++ max_display_attrs = vaMaxNumDisplayAttributes(va_context->display); ++ display_attrs = calloc(max_display_attrs, sizeof(*display_attrs)); ++ if (display_attrs) { ++ num_display_attrs = 0; ++ status = vaQueryDisplayAttributes(va_context->display, ++ display_attrs, &num_display_attrs); ++ if (check_status(status, "vaQueryDisplayAttributes()")) { ++ for (i = 0; i < num_display_attrs; i++) { ++ VADisplayAttribute *attr; ++ switch (display_attrs[i].type) { ++ case VADisplayAttribBrightness: ++ attr = &va_equalizer.brightness; ++ break; ++ case VADisplayAttribContrast: ++ attr = &va_equalizer.contrast; ++ break; ++ case VADisplayAttribHue: ++ attr = &va_equalizer.hue; ++ break; ++ case VADisplayAttribSaturation: ++ attr = &va_equalizer.saturation; ++ break; ++ default: ++ attr = NULL; ++ break; ++ } ++ if (attr) ++ *attr = display_attrs[i]; ++ } ++ } ++ free(display_attrs); ++ } ++ return 0; ++} ++ ++static void free_video_specific(void) ++{ ++ int i; ++ ++#if CONFIG_VAAPI_GLX ++ if (gl_surface) { ++ VAStatus status; ++ status = vaDestroySurfaceGLX(va_context->display, gl_surface); ++ check_status(status, "vaDestroySurfaceGLX()"); ++ gl_surface = NULL; ++ } ++#endif ++ ++ if (va_context && va_context->context_id) { ++ vaDestroyContext(va_context->display, va_context->context_id); ++ va_context->context_id = 0; ++ } ++ ++ if (va_free_surfaces) { ++ for (i = 0; i < va_num_surfaces; i++) { ++ if (!va_free_surfaces[i]) ++ continue; ++ if (va_free_surfaces[i]->image.image_id != VA_INVALID_ID) { ++ vaDestroyImage(va_context->display, ++ va_free_surfaces[i]->image.image_id); ++ va_free_surfaces[i]->image.image_id = VA_INVALID_ID; ++ } ++ free(va_free_surfaces[i]); ++ va_free_surfaces[i] = NULL; ++ } ++ free(va_free_surfaces); ++ va_free_surfaces = NULL; ++ va_free_surfaces_head_index = 0; ++ va_free_surfaces_tail_index = 0; ++ } ++ ++ g_output_surface = 0; ++ memset(g_output_surfaces, 0, sizeof(g_output_surfaces)); ++ ++ if (va_osd_palette) { ++ free(va_osd_palette); ++ va_osd_palette = NULL; ++ } ++ ++ disable_eosd(); ++ disable_osd(); ++ ++ if (va_eosd_subpicture != VA_INVALID_ID) { ++ vaDestroySubpicture(va_context->display, va_eosd_subpicture); ++ va_eosd_subpicture = VA_INVALID_ID; ++ } ++ ++ if (va_eosd_image.image_id != VA_INVALID_ID) { ++ vaDestroyImage(va_context->display, va_eosd_image.image_id); ++ va_eosd_image.image_id = VA_INVALID_ID; ++ } ++ ++ destroy_osd(); ++ ++ if (va_surface_ids) { ++ vaDestroySurfaces(va_context->display, va_surface_ids, va_num_surfaces); ++ free(va_surface_ids); ++ va_surface_ids = NULL; ++ va_num_surfaces = 0; ++ } ++ ++ if (va_context && va_context->config_id) { ++ vaDestroyConfig(va_context->display, va_context->config_id); ++ va_context->config_id = 0; ++ } ++ ++ if (va_entrypoints) { ++ free(va_entrypoints); ++ va_entrypoints = NULL; ++ } ++ ++#if CONFIG_GL ++ if (gl_pixmap) { ++ x11_trap_errors(); ++ mpglXDestroyPixmap(mDisplay, gl_pixmap); ++ XSync(mDisplay, False); ++ x11_untrap_errors(); ++ gl_pixmap = None; ++ } ++ ++ if (g_image_pixmap) { ++ XFreePixmap(mDisplay, g_image_pixmap); ++ g_image_pixmap = None; ++ } ++ ++ if (gl_texture) { ++ glDeleteTextures(1, &gl_texture); ++ gl_texture = GL_NONE; ++ } ++#endif ++ ++#if CONFIG_XRENDER ++ if (xr_window_picture) { ++ XRenderFreePicture(mDisplay, xr_window_picture); ++ xr_window_picture = None; ++ } ++#endif ++ ++ g_is_visible = 0; ++} ++ ++static void uninit(void) ++{ ++ if (!vo_config_count) ++ return; ++ ++ free_video_specific(); ++ ++ if (va_profiles) { ++ free(va_profiles); ++ va_profiles = NULL; ++ } ++ ++ if (va_subpic_flags) { ++ free(va_subpic_flags); ++ va_subpic_flags = NULL; ++ } ++ ++ if (va_subpic_formats) { ++ free(va_subpic_formats); ++ va_subpic_formats = NULL; ++ } ++ ++ if (va_image_formats) { ++ free(va_image_formats); ++ va_image_formats = NULL; ++ } ++ ++ if (va_context && va_context->display) { ++ vaTerminate(va_context->display); ++ va_context->display = NULL; ++ } ++ ++ if (va_context) { ++ free(va_context); ++ va_context = NULL; ++ } ++ ++#ifdef CONFIG_XF86VM ++ vo_vm_close(); ++#endif ++#if CONFIG_XRENDER ++ if (xr_enabled) ++ uninit_xrender(); ++#endif ++#if CONFIG_GL ++ if (gl_enabled) ++ uninit_mpglcontext(&gl_context); ++ else ++#endif ++ vo_x11_uninit(); ++ ++ stats_exit(); ++} ++ ++static int config_x11(uint32_t width, uint32_t height, ++ uint32_t display_width, uint32_t display_height, ++ uint32_t flags, char *title) ++{ ++ Colormap cmap; ++ XVisualInfo visualInfo; ++ XVisualInfo *vi; ++ XSetWindowAttributes xswa; ++ unsigned long xswa_mask; ++ XWindowAttributes wattr; ++ int depth; ++ ++#ifdef CONFIG_GUI ++ if (use_gui) ++ guiGetEvent(guiSetShVideo, 0); // the GUI will set up / resize our window ++ else ++#endif ++ { ++#ifdef CONFIG_XF86VM ++ if (flags & VOFLAG_MODESWITCHING) ++ vo_vm_switch(); ++#endif ++ XGetWindowAttributes(mDisplay, DefaultRootWindow(mDisplay), &wattr); ++ depth = wattr.depth; ++ if (depth != 15 && depth != 16 && depth != 24 && depth != 32) ++ depth = 24; ++ XMatchVisualInfo(mDisplay, mScreen, depth, TrueColor, &visualInfo); ++ ++#if CONFIG_GL ++ if (gl_enabled) { ++ vi = glXChooseVisual(mDisplay, mScreen, gl_visual_attr); ++ if (!vi) ++ return -1; ++ cmap = XCreateColormap(mDisplay, mRootWin, vi->visual, AllocNone); ++ if (cmap == None) ++ return -1; ++ } ++ else ++#endif ++ { ++ vi = &visualInfo; ++ XMatchVisualInfo(mDisplay, mScreen, depth, TrueColor, vi); ++ cmap = CopyFromParent; ++ } ++ ++ vo_x11_create_vo_window(vi, ++ vo_dx, vo_dy, display_width, display_height, ++ flags, cmap, "vaapi", title); ++ ++ if (vi != &visualInfo) ++ XFree(vi); ++ ++ xswa_mask = CWBorderPixel | CWBackPixel; ++ xswa.border_pixel = 0; ++ xswa.background_pixel = 0; ++ XChangeWindowAttributes(mDisplay, vo_window, xswa_mask, &xswa); ++ ++#ifdef CONFIG_XF86VM ++ if (flags & VOFLAG_MODESWITCHING) { ++ /* Grab the mouse pointer in our window */ ++ if (vo_grabpointer) ++ XGrabPointer(mDisplay, vo_window, True, 0, ++ GrabModeAsync, GrabModeAsync, ++ vo_window, None, CurrentTime); ++ XSetInputFocus(mDisplay, vo_window, RevertToNone, CurrentTime); ++ } ++#endif ++ } ++ return 0; ++} ++ ++#if CONFIG_GL ++static GLXFBConfig *get_fbconfig_for_depth(int depth) ++{ ++ GLXFBConfig *fbconfigs, *ret = NULL; ++ int n_elements, i, found; ++ int db, stencil, alpha, mipmap, rgba, value; ++ ++ static GLXFBConfig *cached_config = NULL; ++ static int have_cached_config = 0; ++ ++ if (have_cached_config) ++ return cached_config; ++ ++ fbconfigs = glXGetFBConfigs(mDisplay, mScreen, &n_elements); ++ ++ db = SHRT_MAX; ++ stencil = SHRT_MAX; ++ mipmap = 0; ++ rgba = 0; ++ ++ found = n_elements; ++ ++ for (i = 0; i < n_elements; i++) { ++ XVisualInfo *vi; ++ int visual_depth; ++ ++ vi = glXGetVisualFromFBConfig(mDisplay, fbconfigs[i]); ++ if (!vi) ++ continue; ++ ++ visual_depth = vi->depth; ++ XFree(vi); ++ ++ if (visual_depth != depth) ++ continue; ++ ++ glXGetFBConfigAttrib(mDisplay, fbconfigs[i], GLX_ALPHA_SIZE, &alpha); ++ glXGetFBConfigAttrib(mDisplay, fbconfigs[i], GLX_BUFFER_SIZE, &value); ++ if (value != depth && (value - alpha) != depth) ++ continue; ++ ++ value = 0; ++ if (depth == 32) { ++ glXGetFBConfigAttrib(mDisplay, fbconfigs[i], ++ GLX_BIND_TO_TEXTURE_RGBA_EXT, &value); ++ if (value) ++ rgba = 1; ++ } ++ ++ if (!value) { ++ if (rgba) ++ continue; ++ ++ glXGetFBConfigAttrib(mDisplay, fbconfigs[i], ++ GLX_BIND_TO_TEXTURE_RGB_EXT, &value); ++ if (!value) ++ continue; ++ } ++ ++ glXGetFBConfigAttrib(mDisplay, fbconfigs[i], GLX_DOUBLEBUFFER, &value); ++ if (value > db) ++ continue; ++ db = value; ++ ++ glXGetFBConfigAttrib(mDisplay, fbconfigs[i], GLX_STENCIL_SIZE, &value); ++ if (value > stencil) ++ continue; ++ stencil = value; ++ ++ found = i; ++ } ++ ++ if (found != n_elements) { ++ ret = malloc(sizeof(*ret)); ++ *ret = fbconfigs[found]; ++ } ++ ++ if (n_elements) ++ XFree(fbconfigs); ++ ++ have_cached_config = 1; ++ cached_config = ret; ++ return ret; ++} ++ ++static int config_tfp(unsigned int width, unsigned int height) ++{ ++ GLXFBConfig *fbconfig; ++ int attribs[7], i = 0; ++ const int depth = 24; ++ ++ if (!mpglXBindTexImage || !mpglXReleaseTexImage) { ++ mp_msg(MSGT_VO, MSGL_ERR, "[vo_vaapi] No GLX texture-from-pixmap extension available\n"); ++ return -1; ++ } ++ ++ if (depth != 24 && depth != 32) ++ return -1; ++ ++ g_image_pixmap = XCreatePixmap(mDisplay, vo_window, width, height, depth); ++ if (!g_image_pixmap) { ++ mp_msg(MSGT_VO, MSGL_ERR, "[vo_vaapi] Could not create X11 pixmap\n"); ++ return -1; ++ } ++ ++ fbconfig = get_fbconfig_for_depth(depth); ++ if (!fbconfig) { ++ mp_msg(MSGT_VO, MSGL_ERR, "[vo_vaapi] Could not find an FBConfig for 32-bit pixmap\n"); ++ return -1; ++ } ++ ++ attribs[i++] = GLX_TEXTURE_TARGET_EXT; ++ attribs[i++] = GLX_TEXTURE_2D_EXT; ++ attribs[i++] = GLX_TEXTURE_FORMAT_EXT; ++ if (depth == 24) ++ attribs[i++] = GLX_TEXTURE_FORMAT_RGB_EXT; ++ else if (depth == 32) ++ attribs[i++] = GLX_TEXTURE_FORMAT_RGBA_EXT; ++ attribs[i++] = GLX_MIPMAP_TEXTURE_EXT; ++ attribs[i++] = GL_FALSE; ++ attribs[i++] = None; ++ ++ x11_trap_errors(); ++ gl_pixmap = mpglXCreatePixmap(mDisplay, *fbconfig, g_image_pixmap, attribs); ++ XSync(mDisplay, False); ++ if (x11_untrap_errors()) { ++ mp_msg(MSGT_VO, MSGL_ERR, "[vo_vaapi] Could not create GLX pixmap\n"); ++ return -1; ++ } ++ return 0; ++} ++ ++static int config_glx(unsigned int width, unsigned int height) ++{ ++ if (gl_context.setGlWindow(&gl_context) == SET_WINDOW_FAILED) ++ return -1; ++ ++ glDisable(GL_DEPTH_TEST); ++ glDepthMask(GL_FALSE); ++ glDisable(GL_CULL_FACE); ++ glEnable(GL_TEXTURE_2D); ++ glDrawBuffer(vo_doublebuffering ? GL_BACK : GL_FRONT); ++ glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); ++ glEnable(GL_BLEND); ++ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); ++ ++ /* Create TFP resources */ ++ if (gl_use_tfp && config_tfp(width, height) == 0) ++ mp_msg(MSGT_VO, MSGL_INFO, "[vo_vaapi] Using GLX texture-from-pixmap extension\n"); ++ else ++ gl_use_tfp = 0; ++ ++ /* Create OpenGL texture */ ++ /* XXX: assume GL_ARB_texture_non_power_of_two is available */ ++ glEnable(GL_TEXTURE_2D); ++ glGenTextures(1, &gl_texture); ++ mpglBindTexture(GL_TEXTURE_2D, gl_texture); ++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); ++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); ++ if (!gl_use_tfp) { ++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); ++ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); ++ glPixelStorei(GL_UNPACK_ALIGNMENT, 4); ++ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, ++ GL_BGRA, GL_UNSIGNED_BYTE, NULL); ++ } ++ mpglBindTexture(GL_TEXTURE_2D, 0); ++ glDisable(GL_TEXTURE_2D); ++ ++ glClearColor(0.0, 0.0, 0.0, 1.0); ++ glClear(GL_COLOR_BUFFER_BIT); ++ ++ if (gl_build_font() < 0) ++ return -1; ++ return 0; ++} ++#endif ++ ++#if CONFIG_XRENDER ++static XRenderPictFormat *get_xrender_argb32_format(void) ++{ ++ static XRenderPictFormat *pictformat = NULL; ++ XRenderPictFormat templ; ++ ++ const unsigned long mask = ++ PictFormatType | ++ PictFormatDepth | ++ PictFormatRed | ++ PictFormatRedMask | ++ PictFormatGreen | ++ PictFormatGreenMask | ++ PictFormatBlue | ++ PictFormatBlueMask | ++ PictFormatAlphaMask; ++ ++ if (pictformat) ++ return pictformat; ++ ++ /* First, look for a 32-bit format which ignores the alpha component */ ++ templ.depth = 32; ++ templ.type = PictTypeDirect; ++ templ.direct.red = 16; ++ templ.direct.green = 8; ++ templ.direct.blue = 0; ++ templ.direct.redMask = 0xff; ++ templ.direct.greenMask = 0xff; ++ templ.direct.blueMask = 0xff; ++ templ.direct.alphaMask = 0; ++ ++ pictformat = XRenderFindFormat(mDisplay, mask, &templ, 0); ++ ++ if (!pictformat) { ++ /* Not all X servers support xRGB32 formats. However, the ++ * XRENDER spec says that they must support an ARGB32 format, ++ * so we can always return that. ++ */ ++ pictformat = XRenderFindStandardFormat(mDisplay, PictStandardARGB32); ++ if (!pictformat) ++ mp_msg(MSGT_VO, MSGL_ERR, "XRENDER ARGB32 format not supported\n"); ++ } ++ return pictformat; ++} ++ ++static int create_xrender_specific(void) ++{ ++ XRenderPictFormat *pictformat; ++ ++ if (g_output_rect.width == 0 && g_output_rect.height == 0) ++ return 0; ++ ++ g_image_pixmap = XCreatePixmap(mDisplay, vo_window, g_output_rect.width, ++ g_output_rect.height, 32); ++ if (!g_image_pixmap) { ++ mp_msg(MSGT_VO, MSGL_ERR, "Could not create video pixmap\n"); ++ return -1; ++ } ++ ++ pictformat = get_xrender_argb32_format(); ++ if (!pictformat) ++ return -1; ++ xr_video_picture = XRenderCreatePicture(mDisplay, g_image_pixmap, ++ pictformat, 0, NULL); ++ if (!xr_video_picture) { ++ mp_msg(MSGT_VO, MSGL_ERR, "Could not create XRENDER backing picture for Pixmap\n"); ++ return -1; ++ } ++ return 0; ++} ++ ++static void free_xrender_specific(void) ++{ ++ if (xr_video_picture) { ++ XRenderFreePicture(mDisplay, xr_video_picture); ++ xr_video_picture = None; ++ } ++ ++ if (g_image_pixmap) { ++ XFreePixmap(mDisplay, g_image_pixmap); ++ g_image_pixmap = None; ++ } ++} ++ ++static int reset_xrender_specific(void) ++{ ++ free_xrender_specific(); ++ return create_xrender_specific(); ++} ++ ++/* XXX: create a Pixmap as large as the display rect */ ++static int config_xrender(unsigned int width, unsigned int height) ++{ ++ XWindowAttributes wattr; ++ XRenderPictFormat *pictformat; ++ ++ XGetWindowAttributes(mDisplay, vo_window, &wattr); ++ pictformat = XRenderFindVisualFormat(mDisplay, wattr.visual); ++ if (!pictformat) { ++ mp_msg(MSGT_VO, MSGL_ERR, "XRENDER does not support Window visual\n"); ++ return -1; ++ } ++ ++ xr_window_picture = XRenderCreatePicture(mDisplay, vo_window, pictformat, ++ 0, NULL); ++ if (!xr_window_picture) { ++ mp_msg(MSGT_VO, MSGL_ERR, "Could not create XRENDER backing picture for Window\n"); ++ return -1; ++ } ++ return reset_xrender_specific(); ++} ++#endif ++ ++static int config_vaapi(uint32_t width, uint32_t height, uint32_t format) ++{ ++ VAConfigAttrib attrib; ++ VAStatus status; ++ int i, j, profile, entrypoint, max_entrypoints, num_surfaces; ++ ++ /* Create video surfaces */ ++ if (!IMGFMT_IS_VAAPI(format)) ++ num_surfaces = MAX_OUTPUT_SURFACES; ++ else { ++ switch (IMGFMT_VAAPI_CODEC(format)) { ++ case IMGFMT_VAAPI_CODEC_MPEG2: ++ num_surfaces = NUM_VIDEO_SURFACES_MPEG2; ++ break; ++ case IMGFMT_VAAPI_CODEC_MPEG4: ++ num_surfaces = NUM_VIDEO_SURFACES_MPEG4; ++ break; ++ case IMGFMT_VAAPI_CODEC_H264: ++ num_surfaces = NUM_VIDEO_SURFACES_H264; ++ break; ++ case IMGFMT_VAAPI_CODEC_VC1: ++ num_surfaces = NUM_VIDEO_SURFACES_VC1; ++ break; ++ default: ++ num_surfaces = 0; ++ break; ++ } ++ if (num_surfaces == 0) ++ return -1; ++ if (!is_direct_mapping()) ++ num_surfaces = FFMIN(2 * num_surfaces, MAX_VIDEO_SURFACES); ++ } ++ for (i = 0; i < num_surfaces; i++) { ++ struct vaapi_surface *surface; ++ surface = alloc_vaapi_surface(width, height, VA_RT_FORMAT_YUV420); ++ if (!surface) ++ return -1; ++ } ++ assert(va_num_surfaces == num_surfaces); ++ ++#if CONFIG_VAAPI_GLX ++ /* Create GLX surfaces */ ++ if (gl_enabled && !gl_use_tfp) { ++ status = vaCreateSurfaceGLX(va_context->display, ++ GL_TEXTURE_2D, gl_texture, ++ &gl_surface); ++ if (!check_status(status, "vaCreateSurfaceGLX()")) ++ return -1; ++ } ++#endif ++ ++ /* Create OSD data */ ++ va_osd_draw_alpha = NULL; ++ va_osd_image.image_id = VA_INVALID_ID; ++ va_osd_image.buf = VA_INVALID_ID; ++ va_osd_subpicture = VA_INVALID_ID; ++ ensure_osd(); ++ ++ /* Create EOSD data */ ++ va_eosd_draw_alpha = NULL; ++ va_eosd_image.image_id = VA_INVALID_ID; ++ va_eosd_image.buf = VA_INVALID_ID; ++ va_eosd_subpicture = VA_INVALID_ID; ++ for (i = 0; va_eosd_info[i].format; i++) { ++ for (j = 0; j < va_num_subpic_formats; j++) ++ if (va_subpic_formats[j].fourcc == va_eosd_info[i].format) ++ break; ++ if (j < va_num_subpic_formats && ++ vaCreateImage(va_context->display, &va_subpic_formats[j], ++ width, height, &va_eosd_image) == VA_STATUS_SUCCESS) ++ break; ++ } ++ if (va_eosd_info[i].format && ++ vaCreateSubpicture(va_context->display, va_eosd_image.image_id, ++ &va_eosd_subpicture) == VA_STATUS_SUCCESS) { ++ va_eosd_draw_alpha = va_eosd_info[i].draw_alpha; ++ mp_msg(MSGT_VO, MSGL_DBG2, "[vo_vaapi] Using %s surface for EOSD\n", ++ string_of_VAImageFormat(&va_eosd_image.format)); ++ } ++ ++ /* Allocate VA images */ ++ if (!IMGFMT_IS_VAAPI(format)) { ++ VAImageFormat *image_format = VAImageFormat_from_imgfmt(format); ++ if (!image_format) ++ return -1; ++ for (i = 0; i < va_num_surfaces; i++) { ++ struct vaapi_surface * const s = va_free_surfaces[i]; ++ s->is_bound = 0; ++ status = vaDeriveImage(va_context->display, s->id, &s->image); ++ if (status == VA_STATUS_SUCCESS) { ++ /* vaDeriveImage() is supported, check format */ ++ if (s->image.format.fourcc != image_format->fourcc) { ++ vaDestroyImage(va_context->display, s->image.image_id); ++ return -1; ++ } ++ if (s->image.width == width && s->image.height == height) { ++ s->is_bound = 1; ++ mp_msg(MSGT_VO, MSGL_DBG2, "[vo_vaapi] Using vaDeriveImage()\n"); ++ } ++ else { ++ vaDestroyImage(va_context->display, s->image.image_id); ++ status = VA_STATUS_ERROR_OPERATION_FAILED; ++ } ++ ++ } ++ if (status != VA_STATUS_SUCCESS) { ++ status = vaCreateImage(va_context->display, image_format, ++ width, height, &s->image); ++ if (!check_status(status, "vaCreateImage()")) ++ return -1; ++ } ++ } ++ return 0; ++ } ++ ++ /* Check profile */ ++ profile = VAProfile_from_imgfmt(format); ++ if (profile < 0) ++ return -1; ++ ++ /* Check entry-point (only VLD for now) */ ++ max_entrypoints = vaMaxNumEntrypoints(va_context->display); ++ va_entrypoints = calloc(max_entrypoints, sizeof(*va_entrypoints)); ++ if (!va_entrypoints) ++ return -1; ++ ++ status = vaQueryConfigEntrypoints(va_context->display, profile, ++ va_entrypoints, &va_num_entrypoints); ++ if (!check_status(status, "vaQueryConfigEntrypoints()")) ++ return -1; ++ ++ mp_msg(MSGT_VO, MSGL_DBG2, "[vo_vaapi] config_vaapi(%s): %d entrypoints available\n", ++ string_of_VAProfile(profile), va_num_entrypoints); ++ for (i = 0; i < va_num_entrypoints; i++) ++ mp_msg(MSGT_VO, MSGL_DBG2, " %s\n", string_of_VAEntrypoint(va_entrypoints[i])); ++ ++ entrypoint = VAEntrypoint_from_imgfmt(format); ++ if (entrypoint != VAEntrypointVLD) ++ return -1; ++ ++ /* Check chroma format (only 4:2:0 for now) */ ++ attrib.type = VAConfigAttribRTFormat; ++ status = vaGetConfigAttributes(va_context->display, profile, entrypoint, &attrib, 1); ++ if (!check_status(status, "vaGetConfigAttributes()")) ++ return -1; ++ if ((attrib.value & VA_RT_FORMAT_YUV420) == 0) ++ return -1; ++ ++ /* Create a configuration for the decode pipeline */ ++ status = vaCreateConfig(va_context->display, profile, entrypoint, &attrib, 1, &va_context->config_id); ++ if (!check_status(status, "vaCreateConfig()")) ++ return -1; ++ ++ /* Create a context for the decode pipeline */ ++ status = vaCreateContext(va_context->display, va_context->config_id, ++ width, height, VA_PROGRESSIVE, ++ va_surface_ids, va_num_surfaces, ++ &va_context->context_id); ++ if (!check_status(status, "vaCreateContext()")) ++ return -1; ++ return 0; ++} ++ ++static int config(uint32_t width, uint32_t height, ++ uint32_t display_width, uint32_t display_height, ++ uint32_t flags, char *title, uint32_t format) ++{ ++ mp_msg(MSGT_VO, MSGL_DBG2, "[vo_vaapi] config(): size %dx%d, display size %dx%d, flags %x, title '%s', format %x (%s)\n", ++ width, height, display_width, display_height, flags, title, format, vo_format_name(format)); ++ ++ free_video_specific(); ++ ++ if (config_x11(width, height, display_width, display_height, flags, title) < 0) ++ return -1; ++ ++#if CONFIG_GL ++ if (gl_enabled && config_glx(width, height) < 0) ++ return -1; ++#endif ++ ++#if CONFIG_XRENDER ++ if (xr_enabled && config_xrender(width, height) < 0) ++ return -1; ++#endif ++ ++ if (config_vaapi(width, height, format) < 0) ++ return -1; ++ ++ g_is_visible = 0; ++ g_is_paused = 0; ++ g_image_width = width; ++ g_image_height = height; ++ g_image_format = format; ++ resize(); ++ return 0; ++} ++ ++static int query_format(uint32_t format) ++{ ++ const int default_caps = (VFCAP_CSP_SUPPORTED | ++ VFCAP_CSP_SUPPORTED_BY_HW | ++ VFCAP_HWSCALE_UP | ++ VFCAP_HWSCALE_DOWN | ++ VFCAP_OSD | ++ VFCAP_EOSD); ++ ++ mp_msg(MSGT_VO, MSGL_DBG2, "[vo_vaapi] query_format(): format %x (%s)\n", ++ format, vo_format_name(format)); ++ ++ switch (format) { ++ case IMGFMT_VAAPI_MPEG2: ++ case IMGFMT_VAAPI_MPEG4: ++ case IMGFMT_VAAPI_H263: ++ case IMGFMT_VAAPI_H264: ++ case IMGFMT_VAAPI_WMV3: ++ case IMGFMT_VAAPI_VC1: ++ return default_caps | VOCAP_NOSLICES; ++ case IMGFMT_NV12: ++ case IMGFMT_YV12: ++ case IMGFMT_I420: ++ case IMGFMT_IYUV: ++ if (VAImageFormat_from_imgfmt(format)) ++ return default_caps; ++ break; ++ } ++ return 0; ++} ++ ++static inline int get_field_flags(int i) ++{ ++ return (g_deint && (g_image_fields & MP_IMGFIELD_INTERLACED) ? ++ (((!!(g_image_fields & MP_IMGFIELD_TOP_FIRST)) ^ i) == 0 ? ++ VA_BOTTOM_FIELD : VA_TOP_FIELD) : VA_FRAME_PICTURE); ++} ++ ++static inline int get_colorspace_flags(void) ++{ ++ int csp = 0; ++#if USE_VAAPI_COLORSPACE ++ switch (g_colorspace) { ++ case 0: ++ csp = ((g_image_width >= 1280 || g_image_height > 576) ? ++ VA_SRC_BT709 : VA_SRC_BT601); ++ break; ++ case 1: ++ csp = VA_SRC_BT601; ++ break; ++ case 2: ++ csp = VA_SRC_BT709; ++ break; ++ default: ++ assert(0); ++ break; ++ } ++#endif ++ return csp; ++} ++ ++static void put_surface_x11(struct vaapi_surface *surface) ++{ ++ VAStatus status; ++ int i; ++ ++ for (i = 0; i <= !!(g_deint > 1); i++) { ++ status = vaPutSurface(va_context->display, ++ surface->id, ++ vo_window, ++ 0, 0, g_image_width, g_image_height, ++ g_output_rect.left, ++ g_output_rect.top, ++ g_output_rect.width, ++ g_output_rect.height, ++ NULL, 0, ++ get_field_flags(i) | get_colorspace_flags()); ++ if (!check_status(status, "vaPutSurface()")) ++ return; ++ } ++} ++ ++#if CONFIG_GL ++static void put_surface_glx(struct vaapi_surface *surface) ++{ ++ VAStatus status; ++ int i; ++ ++ if (gl_use_tfp) { ++ for (i = 0; i <= !!(g_deint > 1); i++) { ++ status = vaPutSurface(va_context->display, ++ surface->id, ++ g_image_pixmap, ++ 0, 0, g_image_width, g_image_height, ++ 0, 0, g_image_width, g_image_height, ++ NULL, 0, ++ get_field_flags(i) | get_colorspace_flags()); ++ if (!check_status(status, "vaPutSurface()")) ++ return; ++ } ++ g_output_surfaces[g_output_surface] = surface; ++ return; ++ } ++ ++#if CONFIG_VAAPI_GLX ++ if (gl_binding) { ++#if USE_VAAPI_GLX_BIND ++ for (i = 0; i <= !!(g_deint > 1); i++) { ++ status = vaAssociateSurfaceGLX(va_context->display, ++ gl_surface, ++ surface->id, ++ get_field_flags(i) | get_colorspace_flags()); ++ if (!check_status(status, "vaAssociateSurfaceGLX()")) ++ return; ++ } ++#else ++ mp_msg(MSGT_VO, MSGL_WARN, "vaAssociateSurfaceGLX() is not implemented\n"); ++ gl_binding = 0; ++#endif ++ } ++ ++ if (!gl_binding) { ++ for (i = 0; i <= !!(g_deint > 1); i++) { ++ status = vaCopySurfaceGLX(va_context->display, ++ gl_surface, ++ surface->id, ++ get_field_flags(i) | get_colorspace_flags()); ++ ++ if (status == VA_STATUS_ERROR_UNIMPLEMENTED) { ++ mp_msg(MSGT_VO, MSGL_WARN, ++ "[vo_vaapi] vaCopySurfaceGLX() is not implemented\n"); ++ gl_binding = 1; ++ } ++ else { ++ if (!check_status(status, "vaCopySurfaceGLX()")) ++ return; ++ } ++ } ++ } ++#endif ++ g_output_surfaces[g_output_surface] = surface; ++} ++ ++static int glx_bind_texture(void) ++{ ++ glEnable(GL_TEXTURE_2D); ++ mpglBindTexture(GL_TEXTURE_2D, gl_texture); ++ ++ if (gl_use_tfp) { ++ x11_trap_errors(); ++ mpglXBindTexImage(mDisplay, gl_pixmap, GLX_FRONT_LEFT_EXT, NULL); ++ XSync(mDisplay, False); ++ if (x11_untrap_errors()) ++ mp_msg(MSGT_VO, MSGL_WARN, "[vo_vaapi] Update bind_tex_image failed\n"); ++ } ++ ++#if USE_VAAPI_GLX_BIND ++ if (gl_binding) { ++ VAStatus status; ++ status = vaBeginRenderSurfaceGLX(va_context->display, gl_surface); ++ if (!check_status(status, "vaBeginRenderSurfaceGLX()")) ++ return -1; ++ } ++#endif ++ return 0; ++} ++ ++static int glx_unbind_texture(void) ++{ ++ if (gl_use_tfp) { ++ x11_trap_errors(); ++ mpglXReleaseTexImage(mDisplay, gl_pixmap, GLX_FRONT_LEFT_EXT); ++ if (x11_untrap_errors()) ++ mp_msg(MSGT_VO, MSGL_WARN, "[vo_vaapi] Failed to release?\n"); ++ } ++ ++#if USE_VAAPI_GLX_BIND ++ if (gl_binding) { ++ VAStatus status; ++ status = vaEndRenderSurfaceGLX(va_context->display, gl_surface); ++ if (!check_status(status, "vaEndRenderSurfaceGLX()")) ++ return -1; ++ } ++#endif ++ ++ mpglBindTexture(GL_TEXTURE_2D, 0); ++ glDisable(GL_TEXTURE_2D); ++ return 0; ++} ++ ++static void render_background(void) ++{ ++ /* Original code from Mirco Muller (MacSlow): ++ */ ++ GLfloat fStartX = 0.0f; ++ GLfloat fStartY = 0.0f; ++ GLfloat fWidth = (GLfloat)vo_dwidth; ++ GLfloat fHeight = (GLfloat)vo_dheight; ++ ++ glBegin(GL_QUADS); ++ { ++ /* top third, darker grey to white */ ++ glColor3f(0.85f, 0.85f, 0.85f); ++ glVertex3f(fStartX, fStartY, 0.0f); ++ glColor3f(0.85f, 0.85f, 0.85f); ++ glVertex3f(fStartX + fWidth, fStartY, 0.0f); ++ glColor3f(1.0f, 1.0f, 1.0f); ++ glVertex3f(fStartX + fWidth, fStartY + fHeight / 3.0f, 0.0f); ++ glColor3f(1.0f, 1.0f, 1.0f); ++ glVertex3f(fStartX, fStartY + fHeight / 3.0f, 0.0f); ++ ++ /* middle third, just plain white */ ++ glColor3f(1.0f, 1.0f, 1.0f); ++ glVertex3f(fStartX, fStartY + fHeight / 3.0f, 0.0f); ++ glVertex3f(fStartX + fWidth, fStartY + fHeight / 3.0f, 0.0f); ++ glVertex3f(fStartX + fWidth, fStartY + 2.0f * fHeight / 3.0f, 0.0f); ++ glVertex3f(fStartX, fStartY + 2.0f * fHeight / 3.0f, 0.0f); ++ ++ /* bottom third, white to lighter grey */ ++ glColor3f(1.0f, 1.0f, 1.0f); ++ glVertex3f(fStartX, fStartY + 2.0f * fHeight / 3.0f, 0.0f); ++ glColor3f(1.0f, 1.0f, 1.0f); ++ glVertex3f(fStartX + fWidth, fStartY + 2.0f * fHeight / 3.0f, 0.0f); ++ glColor3f(0.62f, 0.66f, 0.69f); ++ glVertex3f(fStartX + fWidth, fStartY + fHeight, 0.0f); ++ glColor3f(0.62f, 0.66f, 0.69f); ++ glVertex3f(fStartX, fStartY + fHeight, 0.0f); ++ } ++ glEnd(); ++} ++ ++static void render_frame(void) ++{ ++ struct vo_rect * const r = &g_output_rect; ++ ++ if (glx_bind_texture() < 0) ++ return; ++ glColor4f(1.0f, 1.0f, 1.0f, 1.0f); ++ glBegin(GL_QUADS); ++ { ++ glTexCoord2f(0.0f, 0.0f); glVertex2i(r->left, r->top); ++ glTexCoord2f(0.0f, 1.0f); glVertex2i(r->left, r->bottom); ++ glTexCoord2f(1.0f, 1.0f); glVertex2i(r->right, r->bottom); ++ glTexCoord2f(1.0f, 0.0f); glVertex2i(r->right, r->top); ++ } ++ glEnd(); ++ if (glx_unbind_texture() < 0) ++ return; ++} ++ ++static void render_reflection(void) ++{ ++ struct vo_rect * const r = &g_output_rect; ++ const unsigned int rh = g_output_rect.height / 5; ++ GLfloat ry = 1.0f - (GLfloat)rh / (GLfloat)r->height; ++ ++ if (glx_bind_texture() < 0) ++ return; ++ glBegin(GL_QUADS); ++ { ++ glColor4f(1.0f, 1.0f, 1.0f, 1.0f); ++ glTexCoord2f(0.0f, 1.0f); glVertex2i(r->left, r->top); ++ glTexCoord2f(1.0f, 1.0f); glVertex2i(r->right, r->top); ++ ++ glColor4f(1.0f, 1.0f, 1.0f, 0.0f); ++ glTexCoord2f(1.0f, ry); glVertex2i(r->right, r->top + rh); ++ glTexCoord2f(0.0f, ry); glVertex2i(r->left, r->top + rh); ++ } ++ glEnd(); ++ if (glx_unbind_texture() < 0) ++ return; ++} ++ ++static void flip_page_glx(void) ++{ ++ glClear(GL_COLOR_BUFFER_BIT); ++ ++ if (gl_reflect) { ++ render_background(); ++ ++ glPushMatrix(); ++ glRotatef(20.0f, 0.0f, 1.0f, 0.0f); ++ glTranslatef(50.0f, 0.0f, 0.0f); ++ } ++ ++ render_frame(); ++ ++ if (gl_reflect) { ++ glPushMatrix(); ++ glTranslatef(0.0, (GLfloat)g_output_rect.height + 5.0f, 0.0f); ++ render_reflection(); ++ glPopMatrix(); ++ glPopMatrix(); ++ } ++ ++ if (cpu_stats) { ++ gl_draw_rectangle(0, 0, vo_dwidth, 32, 0x000000ff); ++ glColor3f(1.0f, 1.0f, 1.0f); ++ glRasterPos2i(16, 20); ++ gl_printf("MPlayer: %.1f%% of CPU @ %u MHz", cpu_usage, cpu_frequency); ++ } ++ ++ if (gl_finish) ++ mpglFinish(); ++ gl_context.swapGlBuffers(&gl_context); ++ ++ if (vo_fs) /* avoid flickering borders in fullscreen mode */ ++ glClear(GL_COLOR_BUFFER_BIT); ++} ++#endif ++ ++#if CONFIG_XRENDER ++static void put_surface_xrender(struct vaapi_surface *surface) ++{ ++ VAStatus status; ++ int i; ++ ++ for (i = 0; i <= !!(g_deint > 1); i++) { ++ status = vaPutSurface(va_context->display, ++ surface->id, ++ g_image_pixmap, ++ 0, 0, g_image_width, g_image_height, ++ 0, 0, g_output_rect.width, g_output_rect.height, ++ NULL, 0, ++ get_field_flags(i) | get_colorspace_flags()); ++ if (!check_status(status, "vaPutSurface()")) ++ return; ++ XRenderComposite(mDisplay, ++ PictOpSrc, xr_video_picture, 0, xr_window_picture, ++ 0, 0, ++ 0, 0, ++ g_output_rect.left, g_output_rect.top, ++ g_output_rect.width, g_output_rect.height); ++ } ++} ++#endif ++ ++static void put_surface(struct vaapi_surface *surface) ++{ ++ if (!surface || surface->id == VA_INVALID_SURFACE) ++ return; ++ ++#if CONFIG_GL ++ if (gl_enabled) ++ put_surface_glx(surface); ++ else ++#endif ++#if CONFIG_XRENDER ++ if (xr_enabled) ++ put_surface_xrender(surface); ++ else ++#endif ++ put_surface_x11(surface); ++} ++ ++static int draw_slice(uint8_t * image[], int stride[], ++ int w, int h, int x, int y) ++{ ++ struct vaapi_surface * const surface = va_free_surfaces[g_output_surface]; ++ VAImage * const va_image = &surface->image; ++ VAStatus status; ++ uint8_t *image_data = NULL; ++ uint8_t *dst[3] = { 0, }; ++ unsigned int dst_stride[3]; ++ ++ mp_msg(MSGT_VO, MSGL_DBG2, "[vo_vaapi] draw_slice(): location (%d,%d), size %dx%d\n", x, y, w, h); ++ ++ status = vaMapBuffer(va_context->display, va_image->buf, ++ (void *)&image_data); ++ if (!check_status(status, "vaMapBuffer()")) ++ return VO_FALSE; ++ ++ dst_stride[0] = va_image->pitches[0]; ++ dst[0] = image_data + va_image->offsets[0] + y * dst_stride[0] + x; ++ ++ memcpy_pic(dst[0], image[0], w, h, dst_stride[0], stride[0]); ++ ++ x /= 2; ++ y /= 2; ++ w /= 2; ++ h /= 2; ++ ++ if (g_image_format == IMGFMT_YV12) { ++ /* MPlayer's YV12 is actually I420, so swap U/V components */ ++ dst_stride[1] = va_image->pitches[2]; ++ dst[1] = image_data + va_image->offsets[2] + y * dst_stride[1] + x; ++ dst_stride[2] = va_image->pitches[1]; ++ dst[2] = image_data + va_image->offsets[1] + y * dst_stride[2] + x; ++ } ++ else { ++ if (image[1]) { ++ dst_stride[1] = va_image->pitches[1]; ++ dst[1] = image_data + va_image->offsets[1] + y * dst_stride[1] + x; ++ } ++ if (image[2]) { ++ dst_stride[2] = va_image->pitches[2]; ++ dst[2] = image_data + va_image->offsets[2] + y * dst_stride[2] + x; ++ } ++ } ++ ++ if (image[1]) /* RGBA only has a single plane */ ++ memcpy_pic(dst[1], image[1], w, h, dst_stride[1], stride[1]); ++ ++ if (image[2]) /* NV12 only has two planes */ ++ memcpy_pic(dst[2], image[2], w, h, dst_stride[2], stride[2]); ++ ++ status = vaUnmapBuffer(va_context->display, surface->image.buf); ++ if (!check_status(status, "vaUnmapBuffer()")) ++ return VO_FALSE; ++ ++ return VO_TRUE; ++} ++ ++static int draw_frame(uint8_t * src[]) ++{ ++ mp_msg(MSGT_VO,MSGL_INFO, MSGTR_LIBVO_X11_DrawFrameCalled); ++ ++ return -1; ++} ++ ++static void draw_osd(void) ++{ ++ VAStatus status; ++ const int osd_width = va_osd_image.width; ++ const int osd_height = va_osd_image.height; ++ ++ ensure_osd(); ++ if (va_osd_image.image_id == VA_INVALID_ID) ++ return; ++ ++ if (!va_osd_draw_alpha) ++ return; ++ ++ if (!vo_update_osd(osd_width, osd_height)) ++ return; ++ ++ if (!vo_osd_check_range_update(0, 0, osd_width, osd_height)) { ++ disable_osd(); ++ return; ++ } ++ ++ status = vaMapBuffer(va_context->display, va_osd_image.buf, ++ (void *)&va_osd_image_data); ++ if (!check_status(status, "vaMapBuffer()")) ++ return; ++ ++ memset(va_osd_image_data, 0, va_osd_image.data_size); ++ ++ vo_draw_text(osd_width, osd_height, va_osd_draw_alpha); ++ ++ status = vaUnmapBuffer(va_context->display, va_osd_image.buf); ++ if (!check_status(status, "vaUnmapBuffer()")) ++ return; ++ va_osd_image_data = NULL; ++ ++ enable_osd(); ++} ++ ++static void draw_eosd(EOSD_ImageList *imgs) ++{ ++ ASS_Image *img = imgs->imgs; ++ ASS_Image *i; ++ VAStatus status; ++ ++ if (!va_eosd_draw_alpha) ++ return; ++ ++ // Nothing changed, no need to redraw ++ if (imgs->changed == 0) ++ return; ++ ++ // There's nothing to render! ++ if (!img) { ++ disable_eosd(); ++ return; ++ } ++ ++ if (imgs->changed == 1) ++ goto eosd_skip_upload; ++ ++ status = vaMapBuffer(va_context->display, va_eosd_image.buf, ++ (void *)&va_eosd_image_data); ++ if (!check_status(status, "vaMapBuffer()")) ++ return; ++ ++ memset(va_eosd_image_data, 0, va_eosd_image.data_size); ++ ++ for (i = img; i; i = i->next) ++ va_eosd_draw_alpha(i->bitmap, i->w, i->h, i->stride, ++ i->dst_x, i->dst_y, i->color); ++ ++ status = vaUnmapBuffer(va_context->display, va_eosd_image.buf); ++ if (!check_status(status, "vaUnmapBuffer()")) ++ return; ++ va_eosd_image_data = NULL; ++ ++eosd_skip_upload: ++ enable_eosd(); ++} ++ ++static void flip_page(void) ++{ ++ struct vaapi_surface *surface; ++ ++ mp_msg(MSGT_VO, MSGL_DBG2, "[vo_vaapi] flip_page()\n"); ++ ++ surface = g_output_surfaces[g_output_surface]; ++ if (!surface) ++ return; ++ ++ put_surface(surface); ++ g_output_surface = (g_output_surface + 1) % MAX_OUTPUT_SURFACES; ++ g_is_visible = 1; ++ ++#if CONFIG_GL ++ if (gl_enabled) ++ flip_page_glx(); ++#endif ++} ++ ++static struct vaapi_surface *get_surface(mp_image_t *mpi) ++{ ++ struct vaapi_surface *surface; ++ ++ if (mpi->type == MP_IMGTYPE_NUMBERED && is_direct_mapping()) { ++ assert(mpi->number < va_num_surfaces); ++ surface = va_free_surfaces[mpi->number]; ++ return surface; ++ } ++ ++ /* Push current surface to a free slot */ ++ if (mpi->priv) { ++ assert(!va_free_surfaces[va_free_surfaces_tail_index]); ++ va_free_surfaces[va_free_surfaces_tail_index] = mpi->priv; ++ va_free_surfaces_tail_index = (va_free_surfaces_tail_index + 1) % va_num_surfaces; ++ } ++ ++ /* Pop the least recently used free surface */ ++ assert(va_free_surfaces[va_free_surfaces_head_index]); ++ surface = va_free_surfaces[va_free_surfaces_head_index]; ++ va_free_surfaces[va_free_surfaces_head_index] = NULL; ++ va_free_surfaces_head_index = (va_free_surfaces_head_index + 1) % va_num_surfaces; ++ return surface; ++} ++ ++static uint32_t get_image(mp_image_t *mpi) ++{ ++ struct vaapi_surface *surface; ++ ++ if (mpi->type != MP_IMGTYPE_NUMBERED) ++ return VO_FALSE; ++ ++ if (!IMGFMT_IS_VAAPI(g_image_format)) ++ return VO_FALSE; ++ ++ surface = get_surface(mpi); ++ if (!surface) ++ return VO_FALSE; ++ ++ mpi->flags |= MP_IMGFLAG_DIRECT; ++ mpi->stride[0] = mpi->stride[1] = mpi->stride[2] = mpi->stride[3] = 0; ++ mpi->planes[0] = mpi->planes[1] = mpi->planes[2] = mpi->planes[3] = NULL; ++ mpi->planes[0] = (char *)surface; ++ mpi->planes[3] = (char *)(uintptr_t)surface->id; ++ mpi->num_planes = 1; ++ mpi->priv = surface; ++ ++ mp_msg(MSGT_VO, MSGL_DBG2, "[vo_vaapi] get_image(): surface 0x%08x\n", surface->id); ++ ++ return VO_TRUE; ++} ++ ++static int put_image(mp_image_t *mpi, struct vaapi_surface *surface) ++{ ++ VAStatus status; ++ ++ if ((mpi->flags & (MP_IMGFLAG_PLANAR|MP_IMGFLAG_YUV)) != (MP_IMGFLAG_PLANAR|MP_IMGFLAG_YUV)) ++ return VO_FALSE; ++ ++ if (!(mpi->flags & MP_IMGFLAG_DRAW_CALLBACK)) { ++ if (!draw_slice(mpi->planes, mpi->stride, mpi->w, mpi->h, 0, 0)) ++ return VO_FALSE; ++ } ++ ++ if (!surface->is_bound) { ++ status = vaPutImage2(va_context->display, ++ surface->id, ++ surface->image.image_id, ++ mpi->x, mpi->y, mpi->w, mpi->h, ++ mpi->x, mpi->y, mpi->w, mpi->h); ++ if (!check_status(status, "vaPutImage()")) ++ return VO_FALSE; ++ } ++ ++ return VO_TRUE; ++} ++ ++static uint32_t draw_image(mp_image_t *mpi) ++{ ++ struct vaapi_surface *surface = (struct vaapi_surface *)mpi->priv; ++ ++ g_image_fields = mpi->fields; ++ ++ if (!IMGFMT_IS_VAAPI(mpi->imgfmt)) { ++ /* XXX: no direct rendering in non-accelerated mode */ ++ surface = va_free_surfaces[g_output_surface]; ++ if (!put_image(mpi, surface)) ++ return VO_FALSE; ++ } ++ ++ mp_msg(MSGT_VO, MSGL_DBG2, "[vo_vaapi] draw_image(): surface 0x%08x\n", surface->id); ++ ++ g_output_surfaces[g_output_surface] = surface; ++ ++ if (cpu_stats) { ++ static uint64_t ticks; ++ if ((ticks++ % 30) == 0) { ++ cpu_frequency = get_cpu_frequency(); ++ cpu_usage = get_cpu_usage(CPU_USAGE_QUANTUM); ++ } ++ } ++ return VO_TRUE; ++} ++ ++static void check_events(void) ++{ ++ int events = vo_x11_check_events(mDisplay); ++ ++ if (events & VO_EVENT_RESIZE) ++ resize(); ++ ++ if ((events & (VO_EVENT_EXPOSE|VO_EVENT_RESIZE)) && g_is_paused) { ++ /* Redraw the last visible buffer */ ++ if (g_is_visible) { ++ struct vaapi_surface *surface = g_output_surfaces[g_output_surface]; ++ if (surface) ++ put_surface(surface); ++ } ++ } ++} ++ ++static VADisplayAttribute *get_display_attribute(const char *name) ++{ ++ VADisplayAttribute *attr; ++ if (!strcasecmp(name, "brightness")) ++ attr = &va_equalizer.brightness; ++ else if (!strcasecmp(name, "contrast")) ++ attr = &va_equalizer.contrast; ++ else if (!strcasecmp(name, "saturation")) ++ attr = &va_equalizer.saturation; ++ else if (!strcasecmp(name, "hue")) ++ attr = &va_equalizer.hue; ++ else ++ attr = NULL; ++ return attr; ++} ++ ++static int get_equalizer(const char *name, int *value) ++{ ++ VADisplayAttribute * const attr = get_display_attribute(name); ++ int r; ++ ++ if (!attr || !(attr->flags & VA_DISPLAY_ATTRIB_GETTABLE)) ++ return VO_NOTIMPL; ++ ++ /* normalize to -100 .. 100 range */ ++ r = attr->max_value - attr->min_value; ++ if (r == 0) ++ return VO_NOTIMPL; ++ *value = ((attr->value - attr->min_value) * 200) / r - 100; ++ return VO_TRUE; ++} ++ ++static int set_equalizer(const char *name, int value) ++{ ++ VADisplayAttribute * const attr = get_display_attribute(name); ++ VAStatus status; ++ int r; ++ ++ if (!attr || !(attr->flags & VA_DISPLAY_ATTRIB_SETTABLE)) ++ return VO_NOTIMPL; ++ ++ /* normalize to attribute value range */ ++ r = attr->max_value - attr->min_value; ++ if (r == 0) ++ return VO_NOTIMPL; ++ attr->value = ((value + 100) * r) / 200 + attr->min_value; ++ ++ status = vaSetDisplayAttributes(va_context->display, attr, 1); ++ if (!check_status(status, "vaSetDisplayAttributes()")) ++ return VO_FALSE; ++ return VO_TRUE; ++} ++ ++static int control(uint32_t request, void *data, ...) ++{ ++ switch (request) { ++ case VOCTRL_GET_DEINTERLACE: ++ *(int*)data = g_deint; ++ return VO_TRUE; ++ case VOCTRL_SET_DEINTERLACE: ++ g_deint = *(int*)data; ++ if (g_deint) ++ g_deint = g_deint_type; ++ return VO_TRUE; ++ case VOCTRL_PAUSE: ++ return (g_is_paused = 1); ++ case VOCTRL_RESUME: ++ return (g_is_paused = 0); ++ case VOCTRL_QUERY_FORMAT: ++ return query_format(*((uint32_t *)data)); ++ case VOCTRL_GET_IMAGE: ++ return get_image(data); ++ case VOCTRL_DRAW_IMAGE: ++ return draw_image(data); ++ case VOCTRL_GUISUPPORT: ++ return VO_TRUE; ++ case VOCTRL_BORDER: ++ vo_x11_border(); ++ resize(); ++ return VO_TRUE; ++ case VOCTRL_FULLSCREEN: ++ vo_x11_fullscreen(); ++ resize(); ++ return VO_TRUE; ++ case VOCTRL_SET_EQUALIZER: { ++ va_list ap; ++ int value; ++ ++ va_start(ap, data); ++ value = va_arg(ap, int); ++ ++ va_end(ap); ++ return set_equalizer(data, value); ++ } ++ case VOCTRL_GET_EQUALIZER: { ++ va_list ap; ++ int *value; ++ ++ va_start(ap, data); ++ value = va_arg(ap, int *); ++ ++ va_end(ap); ++ return get_equalizer(data, value); ++ } ++ case VOCTRL_ONTOP: ++ vo_x11_ontop(); ++ return VO_TRUE; ++ case VOCTRL_UPDATE_SCREENINFO: ++ update_xinerama_info(); ++ return VO_TRUE; ++ case VOCTRL_GET_PANSCAN: ++ return VO_TRUE; ++ case VOCTRL_SET_PANSCAN: ++ resize(); ++ return VO_TRUE; ++ case VOCTRL_GET_HWACCEL_CONTEXT: ++ *((void **)data) = va_context; ++ return VO_TRUE; ++ case VOCTRL_DRAW_EOSD: ++ if (!data) ++ return VO_FALSE; ++ draw_eosd(data); ++ return VO_TRUE; ++ case VOCTRL_GET_EOSD_RES: { ++ struct mp_eosd_settings *r = data; ++ r->mt = r->mb = r->ml = r->mr = 0; ++ r->srcw = g_image_width; ++ r->srch = g_image_height; ++ r->w = g_image_width; ++ r->h = g_image_height; ++ return VO_TRUE; ++ } ++ } ++ return VO_NOTIMPL; ++} diff --git a/media-video/mplayer/files/vaapi-take2/02-mplayer-vaapi-gma500-workaround.patch b/media-video/mplayer/files/vaapi-take2/02-mplayer-vaapi-gma500-workaround.patch new file mode 100644 index 0000000..7fba614 --- /dev/null +++ b/media-video/mplayer/files/vaapi-take2/02-mplayer-vaapi-gma500-workaround.patch @@ -0,0 +1,97 @@ +commit 7d70d28f190e37cfa3a9a827877ddd6bb81408d3 +Author: Gwenole Beauchesne +Date: Mon Dec 28 08:52:56 2009 +0000 + + Add GMA500 workaround for H.264 DPB. This is disabled by default. Enable with GMA500_WORKAROUND=yes environment variable. + +diff --git a/libavcodec/vaapi_h264.c b/libavcodec/vaapi_h264.c +index 9f440c0..0139d64 100644 +--- a/ffmpeg/libavcodec/vaapi_h264.c ++++ b/ffmpeg/libavcodec/vaapi_h264.c +@@ -28,6 +28,60 @@ + * structures for H.264 decoding. + */ + ++/** Parses ENV environment variable expecting "yes" | "no" values. */ ++static int getenv_yesno(const char *env, int *pval) ++{ ++ int val; ++ const char *env_str; ++ ++ env_str = getenv(env); ++ if (!env_str) ++ return -1; ++ ++ if (strcmp(env_str, "1") == 0 || strcmp(env_str, "yes") == 0) ++ val = 1; ++ else if (strcmp(env_str, "0") == 0 || strcmp(env_str, "no") == 0) ++ val = 0; ++ else ++ return -1; ++ ++ if (pval) ++ *pval = val; ++ return 0; ++} ++ ++/** ++ * Use old GMA500 workaround for DPB. It requires other pictures than ++ * those marked as "used for reference". ++ */ ++static int get_use_gma500_workaround(struct vaapi_context *vactx) ++{ ++ int gma500_workaround_env; ++ const char *vendor_string; ++ ++ if (getenv_yesno("GMA500_WORKAROUND", &gma500_workaround_env) < 0) ++ return 0; ++ if (!gma500_workaround_env) ++ return 0; ++ ++ vendor_string = vaQueryVendorString(vactx->display); ++ if (vendor_string && strstr(vendor_string, "Intel")) { ++ if (strstr(vendor_string, "GMA500")) ++ return 1; ++ if (strstr(vendor_string, "Embedded Graphics Driver")) ++ return 1; ++ } ++ return 0; ++} ++ ++static inline int use_gma500_workaround(struct vaapi_context *vactx) ++{ ++ static int gma500_workaround = -1; ++ if (gma500_workaround < 0) ++ gma500_workaround = get_use_gma500_workaround(vactx); ++ return gma500_workaround; ++} ++ + /** + * Initializes an empty VA API picture. + * +@@ -123,6 +177,7 @@ static int fill_vaapi_ReferenceFrames(VAPictureParameterBufferH264 *pic_param, + { + DPB dpb; + int i; ++ unsigned int list; + + dpb.size = 0; + dpb.max_size = FF_ARRAY_ELEMS(pic_param->ReferenceFrames); +@@ -130,6 +185,17 @@ static int fill_vaapi_ReferenceFrames(VAPictureParameterBufferH264 *pic_param, + for (i = 0; i < dpb.max_size; i++) + init_vaapi_pic(&dpb.va_pics[i]); + ++ if (use_gma500_workaround(h->s.avctx->hwaccel_context)) { ++ /* XXX: this is really wrong */ ++ for (list = 0; list < h->list_count; list++) ++ for (i = 0; i < (int)h->ref_count[list]; i++) { ++ Picture * const pic = &h->ref_list[list][i]; ++ if (pic->reference && dpb_add(&dpb, pic) < 0) ++ return -1; ++ } ++ return 0; ++ } ++ + for (i = 0; i < h->short_ref_count; i++) { + Picture * const pic = h->short_ref[i]; + if (pic && pic->reference && dpb_add(&dpb, pic) < 0) diff --git a/media-video/mplayer/files/vaapi-take2/03-mplayer-vaapi-0.29.patch b/media-video/mplayer/files/vaapi-take2/03-mplayer-vaapi-0.29.patch new file mode 100644 index 0000000..93f72d2 --- /dev/null +++ b/media-video/mplayer/files/vaapi-take2/03-mplayer-vaapi-0.29.patch @@ -0,0 +1,675 @@ +commit 5fbfa3b77f6b3f55cc61df16533324ebcf8e0b70 +Author: Gwenole Beauchesne +Date: Fri Feb 12 11:03:00 2010 +0000 + + Add compatibility with original VA-API 0.29. + +diff --git a/configure b/configure +index 8011680..f7ce215 100755 +--- a/configure ++++ b/configure +@@ -6167,20 +6167,35 @@ fi #if os2 + echocheck "VA-API" + if test "$_vaapi" = yes -o "$_vaapi" = auto; then + _vaapi=no ++ _vaapi_old=no + cat > $TMPC < + int main(void) { (void) vaGetDisplay(0); return 0; } + EOF +- cc_check -lva-x11 && _vaapi=yes ++ cc_check -lva-x11 && _vaapi=yes || { ++ cat > $TMPC < ++int main(void) { (void) vaGetDisplay(0); return 0; } ++EOF ++ cc_check -lva && _vaapi=yes _vaapi_old=yes ++ } + fi + + if test "$_vaapi" = yes ; then + def_vaapi='#define CONFIG_VAAPI 1' +- libs_mencoder="$libs_mencoder -lva" +- libs_mplayer="$libs_mplayer -lva-x11 -lva" ++ if test "$_vaapi_old" = no ; then ++ def_vaapi_old='#define CONFIG_VAAPI_OLD 0' ++ libs_mencoder="$libs_mencoder -lva" ++ libs_mplayer="$libs_mplayer -lva-x11 -lva" ++ else ++ def_vaapi_old='#define CONFIG_VAAPI_OLD 1' ++ _mencoder="no" ++ libs_mplayer="$libs_mplayer -lva" ++ fi + vomodules="vaapi $vomodules" + else + def_vaapi='#define CONFIG_VAAPI 0' ++ def_vaapi_old='#define CONFIG_VAAPI_OLD 0' + novomodules="vaapi $novomodules" + _libavhwaccels=`echo $_libavhwaccels | sed -e "s/\(MPEG[124]\|H26[34]\|WMV3\|VC1\)_VAAPI_HWACCEL//g"` + fi +@@ -8862,6 +8877,7 @@ CONFIG_MLIB = $_mlib + CONFIG_MUXERS = $_mencoder + CONFIG_POSTPROC = yes + CONFIG_VAAPI = $_vaapi ++CONFIG_VAAPI_OLD= $_vaapi_old + CONFIG_VDPAU = $_vdpau + CONFIG_XVMC = $_xvmc + CONFIG_ZLIB = $_zlib +@@ -9241,6 +9257,7 @@ $def_tdfxvid + $def_tga + $def_v4l2 + $def_vaapi ++$def_vaapi_old + $def_vaapi_glx + $def_vdpau + $def_vesa +diff --git a/libavcodec/vaapi_compat.h b/libavcodec/vaapi_compat.h +new file mode 100644 +index 0000000..f463118 +--- /dev/null ++++ b/ffmpeg/libavcodec/vaapi_compat.h +@@ -0,0 +1,92 @@ ++/* ++ * Video Acceleration API (video decoding) ++ * HW decode acceleration for MPEG-2, MPEG-4, H.264 and VC-1 ++ * ++ * Copyright (C) 2008-2009 Splitted-Desktop Systems ++ * ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg 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.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg 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 FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#ifndef AVCODEC_VAAPI_COMPAT_H ++#define AVCODEC_VAAPI_COMPAT_H ++ ++/* Compatibility glue with original VA-API 0.29 */ ++#if CONFIG_VAAPI_OLD ++typedef struct _VASliceParameterBufferBase { ++ unsigned int slice_data_size; ++ unsigned int slice_data_offset; ++ unsigned int slice_data_flag; ++} VASliceParameterBufferBase; ++#endif ++ ++#ifndef VA_CHECK_VERSION ++#define VA_MAJOR_VERSION 0 ++#define VA_MINOR_VERSION 29 ++#define VA_CHECK_VERSION(major,minor,micro) \ ++ (VA_MAJOR_VERSION > (major) || \ ++ (VA_MAJOR_VERSION == (major) && VA_MINOR_VERSION > (minor)) || \ ++ (VA_MAJOR_VERSION == (major) && VA_MINOR_VERSION == (minor) && VA_MICRO_VERSION >= (micro))) ++#endif ++ ++#ifndef VA_FOURCC ++#define VA_FOURCC(ch0, ch1, ch2, ch3) \ ++ ((uint32_t)(uint8_t)(ch0) | \ ++ ((uint32_t)(uint8_t)(ch1) << 8) | \ ++ ((uint32_t)(uint8_t)(ch2) << 16) | \ ++ ((uint32_t)(uint8_t)(ch3) << 24 )) ++#endif ++ ++#ifndef VA_INVALID_ID ++#define VA_INVALID_ID 0xffffffff ++#endif ++#ifndef VA_INVALID_SURFACE ++#define VA_INVALID_SURFACE VA_INVALID_ID ++#endif ++ ++/* Compatibility glue with VA-API >= 0.31 */ ++#if VA_CHECK_VERSION(0,31,0) ++#define vaSyncSurface(dpy, context, surface) (vaSyncSurface)((dpy), (surface)) ++#define vaPutImage2 vaPutImage ++#define vaAssociateSubpicture2 vaAssociateSubpicture ++#endif ++ ++/* Used in codec implementation to set up the right bit-fields */ ++#if CONFIG_VAAPI_OLD ++# define BFV(a, b) a ++# define BFM(a, b, c) c ++# define BFMP(p, a, b, c) p##_##c ++# define NEW(x) /* nothing */ ++#else ++# define BFV(a, b) a.b ++# define BFM(a, b, c) a.b.c ++# define BFMP(p, a, b, c) a.b.c ++# define NEW(x) x ++#endif ++ ++#if CONFIG_VAAPI_OLD ++# define V_raw_coding raw_coding_flag ++# define M_raw_coding raw_coding ++# define V_bitplane_present bitplane_present_flag ++# define M_bitplane_present bitplane_present ++#else ++# define V_raw_coding raw_coding ++# define M_raw_coding raw_coding ++# define V_bitplane_present bitplane_present ++# define M_bitplane_present bitplane_present ++#endif ++ ++#endif /* AVCODEC_VAAPI_COMPAT_H */ +diff --git a/ffmpeg/libavcodec/vaapi_h264.c b/ffmpeg/libavcodec/vaapi_h264.c +index b61a9ca..cab6e41 100644 +--- a/ffmpeg/libavcodec/vaapi_h264.c ++++ b/ffmpeg/libavcodec/vaapi_h264.c +@@ -123,8 +123,8 @@ static void fill_vaapi_pic(VAPictureH264 *va_pic, + if (pic_structure == 0) + pic_structure = pic->reference; + +- va_pic->picture_id = ff_vaapi_get_surface_id(pic); +- va_pic->frame_idx = pic->long_ref ? pic->pic_id : pic->frame_num; ++ va_pic->picture_id = ff_vaapi_get_surface_id(pic); ++ NEW(va_pic->frame_idx = pic->long_ref ? pic->pic_id : pic->frame_num); + + va_pic->flags = 0; + if (pic_structure != PICT_FRAME) +@@ -317,42 +317,42 @@ static int start_frame(AVCodecContext *avctx, + fill_vaapi_pic(&pic_param->CurrPic, s->current_picture_ptr, s->picture_structure); + if (fill_vaapi_ReferenceFrames(pic_param, h) < 0) + return -1; +- pic_param->picture_width_in_mbs_minus1 = s->mb_width - 1; +- pic_param->picture_height_in_mbs_minus1 = s->mb_height - 1; +- pic_param->bit_depth_luma_minus8 = h->sps.bit_depth_luma - 8; +- pic_param->bit_depth_chroma_minus8 = h->sps.bit_depth_chroma - 8; +- pic_param->num_ref_frames = h->sps.ref_frame_count; +- pic_param->seq_fields.value = 0; /* reset all bits */ +- pic_param->seq_fields.bits.chroma_format_idc = h->sps.chroma_format_idc; +- pic_param->seq_fields.bits.residual_colour_transform_flag = h->sps.residual_color_transform_flag; /* XXX: only for 4:4:4 high profile? */ +- pic_param->seq_fields.bits.gaps_in_frame_num_value_allowed_flag = h->sps.gaps_in_frame_num_allowed_flag; +- pic_param->seq_fields.bits.frame_mbs_only_flag = h->sps.frame_mbs_only_flag; +- pic_param->seq_fields.bits.mb_adaptive_frame_field_flag = h->sps.mb_aff; +- pic_param->seq_fields.bits.direct_8x8_inference_flag = h->sps.direct_8x8_inference_flag; +- pic_param->seq_fields.bits.MinLumaBiPredSize8x8 = h->sps.level_idc >= 31; /* A.3.3.2 */ +- pic_param->seq_fields.bits.log2_max_frame_num_minus4 = h->sps.log2_max_frame_num - 4; +- pic_param->seq_fields.bits.pic_order_cnt_type = h->sps.poc_type; +- pic_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 = h->sps.log2_max_poc_lsb - 4; +- pic_param->seq_fields.bits.delta_pic_order_always_zero_flag = h->sps.delta_pic_order_always_zero_flag; +- pic_param->num_slice_groups_minus1 = h->pps.slice_group_count - 1; +- pic_param->slice_group_map_type = h->pps.mb_slice_group_map_type; +- pic_param->slice_group_change_rate_minus1 = 0; /* XXX: unimplemented in FFmpeg */ +- pic_param->pic_init_qp_minus26 = h->pps.init_qp - 26; +- pic_param->pic_init_qs_minus26 = h->pps.init_qs - 26; +- pic_param->chroma_qp_index_offset = h->pps.chroma_qp_index_offset[0]; +- pic_param->second_chroma_qp_index_offset = h->pps.chroma_qp_index_offset[1]; +- pic_param->pic_fields.value = 0; /* reset all bits */ +- pic_param->pic_fields.bits.entropy_coding_mode_flag = h->pps.cabac; +- pic_param->pic_fields.bits.weighted_pred_flag = h->pps.weighted_pred; +- pic_param->pic_fields.bits.weighted_bipred_idc = h->pps.weighted_bipred_idc; +- pic_param->pic_fields.bits.transform_8x8_mode_flag = h->pps.transform_8x8_mode; +- pic_param->pic_fields.bits.field_pic_flag = s->picture_structure != PICT_FRAME; +- pic_param->pic_fields.bits.constrained_intra_pred_flag = h->pps.constrained_intra_pred; +- pic_param->pic_fields.bits.pic_order_present_flag = h->pps.pic_order_present; +- pic_param->pic_fields.bits.deblocking_filter_control_present_flag = h->pps.deblocking_filter_parameters_present; +- pic_param->pic_fields.bits.redundant_pic_cnt_present_flag = h->pps.redundant_pic_cnt_present; +- pic_param->pic_fields.bits.reference_pic_flag = h->nal_ref_idc != 0; +- pic_param->frame_num = h->frame_num; ++ pic_param->picture_width_in_mbs_minus1 = s->mb_width - 1; ++ pic_param->picture_height_in_mbs_minus1 = s->mb_height - 1; ++ pic_param->bit_depth_luma_minus8 = h->sps.bit_depth_luma - 8; ++ pic_param->bit_depth_chroma_minus8 = h->sps.bit_depth_chroma - 8; ++ pic_param->num_ref_frames = h->sps.ref_frame_count; ++ pic_param->BFV(seq_fields,value) = 0; /* reset all bits */ ++ pic_param->BFM(seq_fields,bits,chroma_format_idc) = h->sps.chroma_format_idc; ++ pic_param->BFM(seq_fields,bits,residual_colour_transform_flag) = h->sps.residual_color_transform_flag; /* XXX: only for 4:4:4 high profile? */ ++ NEW(pic_param->BFM(seq_fields,bits,gaps_in_frame_num_value_allowed_flag) = h->sps.gaps_in_frame_num_allowed_flag); ++ pic_param->BFM(seq_fields,bits,frame_mbs_only_flag) = h->sps.frame_mbs_only_flag; ++ pic_param->BFM(seq_fields,bits,mb_adaptive_frame_field_flag) = h->sps.mb_aff; ++ pic_param->BFM(seq_fields,bits,direct_8x8_inference_flag) = h->sps.direct_8x8_inference_flag; ++ pic_param->BFM(seq_fields,bits,MinLumaBiPredSize8x8) = h->sps.level_idc >= 31; /* A.3.3.2 */ ++ NEW(pic_param->BFM(seq_fields,bits,log2_max_frame_num_minus4) = h->sps.log2_max_frame_num - 4); ++ NEW(pic_param->BFM(seq_fields,bits,pic_order_cnt_type) = h->sps.poc_type); ++ NEW(pic_param->BFM(seq_fields,bits,log2_max_pic_order_cnt_lsb_minus4) = h->sps.log2_max_poc_lsb - 4); ++ NEW(pic_param->BFM(seq_fields,bits,delta_pic_order_always_zero_flag) = h->sps.delta_pic_order_always_zero_flag); ++ pic_param->num_slice_groups_minus1 = h->pps.slice_group_count - 1; ++ pic_param->slice_group_map_type = h->pps.mb_slice_group_map_type; ++ NEW(pic_param->slice_group_change_rate_minus1 = 0); /* XXX: unimplemented in FFmpeg */ ++ pic_param->pic_init_qp_minus26 = h->pps.init_qp - 26; ++ NEW(pic_param->pic_init_qs_minus26 = h->pps.init_qs - 26); ++ pic_param->chroma_qp_index_offset = h->pps.chroma_qp_index_offset[0]; ++ pic_param->second_chroma_qp_index_offset = h->pps.chroma_qp_index_offset[1]; ++ pic_param->BFV(pic_fields,value) = 0; /* reset all bits */ ++ pic_param->BFM(pic_fields,bits,entropy_coding_mode_flag) = h->pps.cabac; ++ pic_param->BFM(pic_fields,bits,weighted_pred_flag) = h->pps.weighted_pred; ++ pic_param->BFM(pic_fields,bits,weighted_bipred_idc) = h->pps.weighted_bipred_idc; ++ pic_param->BFM(pic_fields,bits,transform_8x8_mode_flag) = h->pps.transform_8x8_mode; ++ pic_param->BFM(pic_fields,bits,field_pic_flag) = s->picture_structure != PICT_FRAME; ++ pic_param->BFM(pic_fields,bits,constrained_intra_pred_flag) = h->pps.constrained_intra_pred; ++ NEW(pic_param->BFM(pic_fields,bits,pic_order_present_flag) = h->pps.pic_order_present); ++ NEW(pic_param->BFM(pic_fields,bits,deblocking_filter_control_present_flag) = h->pps.deblocking_filter_parameters_present); ++ NEW(pic_param->BFM(pic_fields,bits,redundant_pic_cnt_present_flag) = h->pps.redundant_pic_cnt_present); ++ NEW(pic_param->BFM(pic_fields,bits,reference_pic_flag) = h->nal_ref_idc != 0); ++ pic_param->frame_num = h->frame_num; + + /* Fill in VAIQMatrixBufferH264. */ + iq_matrix = ff_vaapi_alloc_iq_matrix(vactx, sizeof(VAIQMatrixBufferH264)); +diff --git a/ffmpeg/libavcodec/vaapi_internal.h b/ffmpeg/libavcodec/vaapi_internal.h +index 2c0fdf9..ff83b96 100644 +--- a/ffmpeg/libavcodec/vaapi_internal.h ++++ b/ffmpeg/libavcodec/vaapi_internal.h +@@ -24,8 +24,14 @@ + #ifndef AVCODEC_VAAPI_INTERNAL_H + #define AVCODEC_VAAPI_INTERNAL_H + ++#include "config.h" ++#if CONFIG_VAAPI_OLD ++#include ++#else + #include ++#endif + #include "vaapi.h" ++#include "vaapi_compat.h" + #include "avcodec.h" + #include "mpegvideo.h" + +diff --git a/ffmpeg/libavcodec/vaapi_mpeg2.c b/ffmpeg/libavcodec/vaapi_mpeg2.c +index 2e870dc..637546a 100644 +--- a/ffmpeg/libavcodec/vaapi_mpeg2.c ++++ b/ffmpeg/libavcodec/vaapi_mpeg2.c +@@ -52,24 +52,24 @@ static int vaapi_mpeg2_start_frame(AVCodecContext *avctx, av_unused const uint8_ + pic_param = ff_vaapi_alloc_pic_param(vactx, sizeof(VAPictureParameterBufferMPEG2)); + if (!pic_param) + return -1; +- pic_param->horizontal_size = s->width; +- pic_param->vertical_size = s->height; +- pic_param->forward_reference_picture = VA_INVALID_ID; +- pic_param->backward_reference_picture = VA_INVALID_ID; +- pic_param->picture_coding_type = s->pict_type; +- pic_param->f_code = mpeg2_get_f_code(s); +- pic_param->picture_coding_extension.value = 0; /* reset all bits */ +- pic_param->picture_coding_extension.bits.intra_dc_precision = s->intra_dc_precision; +- pic_param->picture_coding_extension.bits.picture_structure = s->picture_structure; +- pic_param->picture_coding_extension.bits.top_field_first = s->top_field_first; +- pic_param->picture_coding_extension.bits.frame_pred_frame_dct = s->frame_pred_frame_dct; +- pic_param->picture_coding_extension.bits.concealment_motion_vectors = s->concealment_motion_vectors; +- pic_param->picture_coding_extension.bits.q_scale_type = s->q_scale_type; +- pic_param->picture_coding_extension.bits.intra_vlc_format = s->intra_vlc_format; +- pic_param->picture_coding_extension.bits.alternate_scan = s->alternate_scan; +- pic_param->picture_coding_extension.bits.repeat_first_field = s->repeat_first_field; +- pic_param->picture_coding_extension.bits.progressive_frame = s->progressive_frame; +- pic_param->picture_coding_extension.bits.is_first_field = mpeg2_get_is_frame_start(s); ++ pic_param->horizontal_size = s->width; ++ pic_param->vertical_size = s->height; ++ pic_param->forward_reference_picture = VA_INVALID_ID; ++ pic_param->backward_reference_picture = VA_INVALID_ID; ++ pic_param->picture_coding_type = s->pict_type; ++ pic_param->f_code = mpeg2_get_f_code(s); ++ pic_param->BFV(picture_coding_extension,value) = 0; /* reset all bits */ ++ pic_param->BFM(picture_coding_extension,bits,intra_dc_precision) = s->intra_dc_precision; ++ pic_param->BFM(picture_coding_extension,bits,picture_structure) = s->picture_structure; ++ pic_param->BFM(picture_coding_extension,bits,top_field_first) = s->top_field_first; ++ pic_param->BFM(picture_coding_extension,bits,frame_pred_frame_dct) = s->frame_pred_frame_dct; ++ pic_param->BFM(picture_coding_extension,bits,concealment_motion_vectors) = s->concealment_motion_vectors; ++ pic_param->BFM(picture_coding_extension,bits,q_scale_type) = s->q_scale_type; ++ pic_param->BFM(picture_coding_extension,bits,intra_vlc_format) = s->intra_vlc_format; ++ pic_param->BFM(picture_coding_extension,bits,alternate_scan) = s->alternate_scan; ++ pic_param->BFM(picture_coding_extension,bits,repeat_first_field) = s->repeat_first_field; ++ pic_param->BFM(picture_coding_extension,bits,progressive_frame) = s->progressive_frame; ++ pic_param->BFM(picture_coding_extension,bits,is_first_field) = mpeg2_get_is_frame_start(s); + + switch (s->pict_type) { + case FF_B_TYPE: +@@ -131,7 +131,7 @@ static int vaapi_mpeg2_decode_slice(AVCodecContext *avctx, const uint8_t *buffer + if (!slice_param) + return -1; + slice_param->macroblock_offset = macroblock_offset; +- slice_param->slice_horizontal_position = s->mb_x; ++ NEW(slice_param->slice_horizontal_position = s->mb_x); + slice_param->slice_vertical_position = s->mb_y; + slice_param->quantiser_scale_code = quantiser_scale_code; + slice_param->intra_slice_flag = intra_slice_flag; +diff --git a/libavcodec/vaapi_mpeg4.c b/libavcodec/vaapi_mpeg4.c +index 466ce2f..ea306a4 100644 +--- a/ffmpeg/libavcodec/vaapi_mpeg4.c ++++ b/ffmpeg/libavcodec/vaapi_mpeg4.c +@@ -54,42 +54,42 @@ static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_ + pic_param = ff_vaapi_alloc_pic_param(vactx, sizeof(VAPictureParameterBufferMPEG4)); + if (!pic_param) + return -1; +- pic_param->vop_width = s->width; +- pic_param->vop_height = s->height; +- pic_param->forward_reference_picture = VA_INVALID_ID; +- pic_param->backward_reference_picture = VA_INVALID_ID; +- pic_param->vol_fields.value = 0; /* reset all bits */ +- pic_param->vol_fields.bits.short_video_header = avctx->codec->id == CODEC_ID_H263; +- pic_param->vol_fields.bits.chroma_format = CHROMA_420; +- pic_param->vol_fields.bits.interlaced = !s->progressive_sequence; +- pic_param->vol_fields.bits.obmc_disable = 1; +- pic_param->vol_fields.bits.sprite_enable = s->vol_sprite_usage; +- pic_param->vol_fields.bits.sprite_warping_accuracy = s->sprite_warping_accuracy; +- pic_param->vol_fields.bits.quant_type = s->mpeg_quant; +- pic_param->vol_fields.bits.quarter_sample = s->quarter_sample; +- pic_param->vol_fields.bits.data_partitioned = s->data_partitioning; +- pic_param->vol_fields.bits.reversible_vlc = s->rvlc; +- pic_param->vol_fields.bits.resync_marker_disable = !s->resync_marker; +- pic_param->no_of_sprite_warping_points = s->num_sprite_warping_points; ++ pic_param->vop_width = s->width; ++ pic_param->vop_height = s->height; ++ pic_param->forward_reference_picture = VA_INVALID_ID; ++ pic_param->backward_reference_picture = VA_INVALID_ID; ++ pic_param->BFV(vol_fields,value) = 0; /* reset all bits */ ++ pic_param->BFM(vol_fields,bits,short_video_header) = avctx->codec->id == CODEC_ID_H263; ++ pic_param->BFM(vol_fields,bits,chroma_format) = CHROMA_420; ++ pic_param->BFM(vol_fields,bits,interlaced) = !s->progressive_sequence; ++ pic_param->BFM(vol_fields,bits,obmc_disable) = 1; ++ pic_param->BFM(vol_fields,bits,sprite_enable) = s->vol_sprite_usage; ++ pic_param->BFM(vol_fields,bits,sprite_warping_accuracy) = s->sprite_warping_accuracy; ++ pic_param->BFM(vol_fields,bits,quant_type) = s->mpeg_quant; ++ pic_param->BFM(vol_fields,bits,quarter_sample) = s->quarter_sample; ++ pic_param->BFM(vol_fields,bits,data_partitioned) = s->data_partitioning; ++ pic_param->BFM(vol_fields,bits,reversible_vlc) = s->rvlc; ++ NEW(pic_param->BFM(vol_fields,bits,resync_marker_disable) = !s->resync_marker); ++ pic_param->no_of_sprite_warping_points = s->num_sprite_warping_points; + for (i = 0; i < s->num_sprite_warping_points && i < 3; i++) { +- pic_param->sprite_trajectory_du[i] = s->sprite_traj[i][0]; +- pic_param->sprite_trajectory_dv[i] = s->sprite_traj[i][1]; ++ pic_param->sprite_trajectory_du[i] = s->sprite_traj[i][0]; ++ pic_param->sprite_trajectory_dv[i] = s->sprite_traj[i][1]; + } +- pic_param->quant_precision = s->quant_precision; +- pic_param->vop_fields.value = 0; /* reset all bits */ +- pic_param->vop_fields.bits.vop_coding_type = s->pict_type - FF_I_TYPE; +- pic_param->vop_fields.bits.backward_reference_vop_coding_type = s->pict_type == FF_B_TYPE ? s->next_picture.pict_type - FF_I_TYPE : 0; +- pic_param->vop_fields.bits.vop_rounding_type = s->no_rounding; +- pic_param->vop_fields.bits.intra_dc_vlc_thr = mpeg4_get_intra_dc_vlc_thr(s); +- pic_param->vop_fields.bits.top_field_first = s->top_field_first; +- pic_param->vop_fields.bits.alternate_vertical_scan_flag = s->alternate_scan; +- pic_param->vop_fcode_forward = s->f_code; +- pic_param->vop_fcode_backward = s->b_code; +- pic_param->vop_time_increment_resolution = avctx->time_base.den; +- pic_param->num_macroblocks_in_gob = s->mb_width * ff_h263_get_gob_height(s); +- pic_param->num_gobs_in_vop = (s->mb_width * s->mb_height) / pic_param->num_macroblocks_in_gob; +- pic_param->TRB = s->pb_time; +- pic_param->TRD = s->pp_time; ++ pic_param->quant_precision = s->quant_precision; ++ pic_param->BFV(vop_fields,value) = 0; /* reset all bits */ ++ pic_param->BFM(vop_fields,bits,vop_coding_type) = s->pict_type - FF_I_TYPE; ++ pic_param->BFM(vop_fields,bits,backward_reference_vop_coding_type) = s->pict_type == FF_B_TYPE ? s->next_picture.pict_type - FF_I_TYPE : 0; ++ pic_param->BFM(vop_fields,bits,vop_rounding_type) = s->no_rounding; ++ pic_param->BFM(vop_fields,bits,intra_dc_vlc_thr) = mpeg4_get_intra_dc_vlc_thr(s); ++ pic_param->BFM(vop_fields,bits,top_field_first) = s->top_field_first; ++ pic_param->BFM(vop_fields,bits,alternate_vertical_scan_flag) = s->alternate_scan; ++ pic_param->vop_fcode_forward = s->f_code; ++ pic_param->vop_fcode_backward = s->b_code; ++ NEW(pic_param->vop_time_increment_resolution = avctx->time_base.den); ++ pic_param->num_macroblocks_in_gob = s->mb_width * ff_h263_get_gob_height(s); ++ pic_param->num_gobs_in_vop = (s->mb_width * s->mb_height) / pic_param->num_macroblocks_in_gob; ++ pic_param->TRB = s->pb_time; ++ pic_param->TRD = s->pp_time; + + if (s->pict_type == FF_B_TYPE) + pic_param->backward_reference_picture = ff_vaapi_get_surface_id(&s->next_picture); +@@ -98,7 +98,7 @@ static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_ + + /* Fill in VAIQMatrixBufferMPEG4 */ + /* Only the first inverse quantisation method uses the weighthing matrices */ +- if (pic_param->vol_fields.bits.quant_type) { ++ if (pic_param->BFM(vol_fields,bits,quant_type)) { + iq_matrix = ff_vaapi_alloc_iq_matrix(vactx, sizeof(VAIQMatrixBufferMPEG4)); + if (!iq_matrix) + return -1; +diff --git a/libavcodec/vaapi_vc1.c b/libavcodec/vaapi_vc1.c +index 992e1da..8264dd9 100644 +--- a/ffmpeg/libavcodec/vaapi_vc1.c ++++ b/ffmpeg/libavcodec/vaapi_vc1.c +@@ -146,100 +146,100 @@ static int vaapi_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_t + pic_param = ff_vaapi_alloc_pic_param(vactx, sizeof(VAPictureParameterBufferVC1)); + if (!pic_param) + return -1; +- pic_param->forward_reference_picture = VA_INVALID_ID; +- pic_param->backward_reference_picture = VA_INVALID_ID; +- pic_param->inloop_decoded_picture = VA_INVALID_ID; +- pic_param->sequence_fields.value = 0; /* reset all bits */ +- pic_param->sequence_fields.bits.pulldown = v->broadcast; +- pic_param->sequence_fields.bits.interlace = v->interlace; +- pic_param->sequence_fields.bits.tfcntrflag = v->tfcntrflag; +- pic_param->sequence_fields.bits.finterpflag = v->finterpflag; +- pic_param->sequence_fields.bits.psf = v->psf; +- pic_param->sequence_fields.bits.multires = v->multires; +- pic_param->sequence_fields.bits.overlap = v->overlap; +- pic_param->sequence_fields.bits.syncmarker = s->resync_marker; +- pic_param->sequence_fields.bits.rangered = v->rangered; +- pic_param->sequence_fields.bits.max_b_frames = s->avctx->max_b_frames; +- pic_param->coded_width = s->avctx->coded_width; +- pic_param->coded_height = s->avctx->coded_height; +- pic_param->entrypoint_fields.value = 0; /* reset all bits */ +- pic_param->entrypoint_fields.bits.broken_link = v->broken_link; +- pic_param->entrypoint_fields.bits.closed_entry = v->closed_entry; +- pic_param->entrypoint_fields.bits.panscan_flag = v->panscanflag; +- pic_param->entrypoint_fields.bits.loopfilter = s->loop_filter; +- pic_param->conditional_overlap_flag = v->condover; +- pic_param->fast_uvmc_flag = v->fastuvmc; +- pic_param->range_mapping_fields.value = 0; /* reset all bits */ +- pic_param->range_mapping_fields.bits.luma_flag = v->range_mapy_flag; +- pic_param->range_mapping_fields.bits.luma = v->range_mapy; +- pic_param->range_mapping_fields.bits.chroma_flag = v->range_mapuv_flag; +- pic_param->range_mapping_fields.bits.chroma = v->range_mapuv; +- pic_param->b_picture_fraction = v->bfraction_lut_index; +- pic_param->cbp_table = v->cbpcy_vlc ? v->cbpcy_vlc - ff_vc1_cbpcy_p_vlc : 0; +- pic_param->mb_mode_table = 0; /* XXX: interlaced frame */ +- pic_param->range_reduction_frame = v->rangeredfrm; +- pic_param->rounding_control = v->rnd; +- pic_param->post_processing = v->postproc; +- pic_param->picture_resolution_index = v->respic; +- pic_param->luma_scale = v->lumscale; +- pic_param->luma_shift = v->lumshift; +- pic_param->picture_fields.value = 0; /* reset all bits */ +- pic_param->picture_fields.bits.picture_type = vc1_get_PTYPE(v); +- pic_param->picture_fields.bits.frame_coding_mode = v->fcm; +- pic_param->picture_fields.bits.top_field_first = v->tff; +- pic_param->picture_fields.bits.is_first_field = v->fcm == 0; /* XXX: interlaced frame */ +- pic_param->picture_fields.bits.intensity_compensation = v->mv_mode == MV_PMODE_INTENSITY_COMP; +- pic_param->raw_coding.value = 0; /* reset all bits */ +- pic_param->raw_coding.flags.mv_type_mb = v->mv_type_is_raw; +- pic_param->raw_coding.flags.direct_mb = v->dmb_is_raw; +- pic_param->raw_coding.flags.skip_mb = v->skip_is_raw; +- pic_param->raw_coding.flags.field_tx = 0; /* XXX: interlaced frame */ +- pic_param->raw_coding.flags.forward_mb = 0; /* XXX: interlaced frame */ +- pic_param->raw_coding.flags.ac_pred = v->acpred_is_raw; +- pic_param->raw_coding.flags.overflags = v->overflg_is_raw; +- pic_param->bitplane_present.value = 0; /* reset all bits */ +- pic_param->bitplane_present.flags.bp_mv_type_mb = vc1_has_MVTYPEMB_bitplane(v); +- pic_param->bitplane_present.flags.bp_direct_mb = vc1_has_DIRECTMB_bitplane(v); +- pic_param->bitplane_present.flags.bp_skip_mb = vc1_has_SKIPMB_bitplane(v); +- pic_param->bitplane_present.flags.bp_field_tx = 0; /* XXX: interlaced frame */ +- pic_param->bitplane_present.flags.bp_forward_mb = 0; /* XXX: interlaced frame */ +- pic_param->bitplane_present.flags.bp_ac_pred = vc1_has_ACPRED_bitplane(v); +- pic_param->bitplane_present.flags.bp_overflags = vc1_has_OVERFLAGS_bitplane(v); +- pic_param->reference_fields.value = 0; /* reset all bits */ +- pic_param->reference_fields.bits.reference_distance_flag = v->refdist_flag; +- pic_param->reference_fields.bits.reference_distance = 0; /* XXX: interlaced frame */ +- pic_param->reference_fields.bits.num_reference_pictures = 0; /* XXX: interlaced frame */ +- pic_param->reference_fields.bits.reference_field_pic_indicator = 0; /* XXX: interlaced frame */ +- pic_param->mv_fields.value = 0; /* reset all bits */ +- pic_param->mv_fields.bits.mv_mode = vc1_get_MVMODE(v); +- pic_param->mv_fields.bits.mv_mode2 = vc1_get_MVMODE2(v); +- pic_param->mv_fields.bits.mv_table = s->mv_table_index; +- pic_param->mv_fields.bits.two_mv_block_pattern_table = 0; /* XXX: interlaced frame */ +- pic_param->mv_fields.bits.four_mv_switch = 0; /* XXX: interlaced frame */ +- pic_param->mv_fields.bits.four_mv_block_pattern_table = 0; /* XXX: interlaced frame */ +- pic_param->mv_fields.bits.extended_mv_flag = v->extended_mv; +- pic_param->mv_fields.bits.extended_mv_range = v->mvrange; +- pic_param->mv_fields.bits.extended_dmv_flag = v->extended_dmv; +- pic_param->mv_fields.bits.extended_dmv_range = 0; /* XXX: interlaced frame */ +- pic_param->pic_quantizer_fields.value = 0; /* reset all bits */ +- pic_param->pic_quantizer_fields.bits.dquant = v->dquant; +- pic_param->pic_quantizer_fields.bits.quantizer = v->quantizer_mode; +- pic_param->pic_quantizer_fields.bits.half_qp = v->halfpq; +- pic_param->pic_quantizer_fields.bits.pic_quantizer_scale = v->pq; +- pic_param->pic_quantizer_fields.bits.pic_quantizer_type = v->pquantizer; +- pic_param->pic_quantizer_fields.bits.dq_frame = v->dquantfrm; +- pic_param->pic_quantizer_fields.bits.dq_profile = v->dqprofile; +- pic_param->pic_quantizer_fields.bits.dq_sb_edge = v->dqprofile == DQPROFILE_SINGLE_EDGE ? v->dqsbedge : 0; +- pic_param->pic_quantizer_fields.bits.dq_db_edge = v->dqprofile == DQPROFILE_DOUBLE_EDGES ? v->dqsbedge : 0; +- pic_param->pic_quantizer_fields.bits.dq_binary_level = v->dqbilevel; +- pic_param->pic_quantizer_fields.bits.alt_pic_quantizer = v->altpq; +- pic_param->transform_fields.value = 0; /* reset all bits */ +- pic_param->transform_fields.bits.variable_sized_transform_flag = v->vstransform; +- pic_param->transform_fields.bits.mb_level_transform_type_flag = v->ttmbf; +- pic_param->transform_fields.bits.frame_level_transform_type = v->ttfrm; +- pic_param->transform_fields.bits.transform_ac_codingset_idx1 = v->c_ac_table_index; +- pic_param->transform_fields.bits.transform_ac_codingset_idx2 = v->y_ac_table_index; +- pic_param->transform_fields.bits.intra_transform_dc_table = v->s.dc_table_index; ++ pic_param->forward_reference_picture = VA_INVALID_ID; ++ pic_param->backward_reference_picture = VA_INVALID_ID; ++ pic_param->inloop_decoded_picture = VA_INVALID_ID; ++ pic_param->BFV(sequence_fields,value) = 0; /* reset all bits */ ++ NEW(pic_param->BFM(sequence_fields,bits,pulldown) = v->broadcast); ++ pic_param->BFM(sequence_fields,bits,interlace) = v->interlace; ++ NEW(pic_param->BFM(sequence_fields,bits,tfcntrflag) = v->tfcntrflag); ++ NEW(pic_param->BFM(sequence_fields,bits,finterpflag) = v->finterpflag); ++ NEW(pic_param->BFM(sequence_fields,bits,psf) = v->psf); ++ NEW(pic_param->BFM(sequence_fields,bits,multires) = v->multires); ++ pic_param->BFM(sequence_fields,bits,overlap) = v->overlap; ++ pic_param->BFM(sequence_fields,bits,syncmarker) = s->resync_marker; ++ NEW(pic_param->BFM(sequence_fields,bits,rangered) = v->rangered); ++ NEW(pic_param->BFM(sequence_fields,bits,max_b_frames) = s->avctx->max_b_frames); ++ pic_param->coded_width = s->avctx->coded_width; ++ pic_param->coded_height = s->avctx->coded_height; ++ NEW(pic_param->BFV(entrypoint_fields,value) = 0); /* reset all bits */ ++ pic_param->BFM(entrypoint_fields,bits,broken_link) = v->broken_link; ++ pic_param->BFM(entrypoint_fields,bits,closed_entry) = v->closed_entry; ++ NEW(pic_param->BFM(entrypoint_fields,bits,panscan_flag) = v->panscanflag); ++ pic_param->BFM(entrypoint_fields,bits,loopfilter) = s->loop_filter; ++ pic_param->conditional_overlap_flag = v->condover; ++ pic_param->fast_uvmc_flag = v->fastuvmc; ++ pic_param->BFV(range_mapping_fields,value) = 0; /* reset all bits */ ++ pic_param->BFMP(range_mapping,range_mapping_fields,bits,luma_flag) = v->range_mapy_flag; ++ pic_param->BFMP(range_mapping,range_mapping_fields,bits,luma) = v->range_mapy; ++ pic_param->BFMP(range_mapping,range_mapping_fields,bits,chroma_flag) = v->range_mapuv_flag; ++ pic_param->BFMP(range_mapping,range_mapping_fields,bits,chroma) = v->range_mapuv; ++ pic_param->b_picture_fraction = v->bfraction_lut_index; ++ pic_param->cbp_table = v->cbpcy_vlc ? v->cbpcy_vlc - ff_vc1_cbpcy_p_vlc : 0; ++ pic_param->mb_mode_table = 0; /* XXX: interlaced frame */ ++ pic_param->range_reduction_frame = v->rangeredfrm; ++ pic_param->rounding_control = v->rnd; ++ pic_param->post_processing = v->postproc; ++ pic_param->picture_resolution_index = v->respic; ++ pic_param->luma_scale = v->lumscale; ++ pic_param->luma_shift = v->lumshift; ++ pic_param->BFV(picture_fields,value) = 0; /* reset all bits */ ++ pic_param->BFM(picture_fields,bits,picture_type) = vc1_get_PTYPE(v); ++ pic_param->BFM(picture_fields,bits,frame_coding_mode) = v->fcm; ++ pic_param->BFM(picture_fields,bits,top_field_first) = v->tff; ++ pic_param->BFM(picture_fields,bits,is_first_field) = v->fcm == 0; /* XXX: interlaced frame */ ++ pic_param->BFM(picture_fields,bits,intensity_compensation) = v->mv_mode == MV_PMODE_INTENSITY_COMP; ++ pic_param->BFV(V_raw_coding,value) = 0; /* reset all bits */ ++ pic_param->BFM(M_raw_coding,flags,mv_type_mb) = v->mv_type_is_raw; ++ pic_param->BFM(M_raw_coding,flags,direct_mb) = v->dmb_is_raw; ++ pic_param->BFM(M_raw_coding,flags,skip_mb) = v->skip_is_raw; ++ pic_param->BFM(M_raw_coding,flags,field_tx) = 0; /* XXX: interlaced frame */ ++ pic_param->BFM(M_raw_coding,flags,forward_mb) = 0; /* XXX: interlaced frame */ ++ pic_param->BFM(M_raw_coding,flags,ac_pred) = v->acpred_is_raw; ++ pic_param->BFM(M_raw_coding,flags,overflags) = v->overflg_is_raw; ++ pic_param->BFV(V_bitplane_present,value) = 0; /* reset all bits */ ++ pic_param->BFM(M_bitplane_present,flags,bp_mv_type_mb) = vc1_has_MVTYPEMB_bitplane(v); ++ pic_param->BFM(M_bitplane_present,flags,bp_direct_mb) = vc1_has_DIRECTMB_bitplane(v); ++ pic_param->BFM(M_bitplane_present,flags,bp_skip_mb) = vc1_has_SKIPMB_bitplane(v); ++ pic_param->BFM(M_bitplane_present,flags,bp_field_tx) = 0; /* XXX: interlaced frame */ ++ pic_param->BFM(M_bitplane_present,flags,bp_forward_mb) = 0; /* XXX: interlaced frame */ ++ pic_param->BFM(M_bitplane_present,flags,bp_ac_pred) = vc1_has_ACPRED_bitplane(v); ++ pic_param->BFM(M_bitplane_present,flags,bp_overflags) = vc1_has_OVERFLAGS_bitplane(v); ++ pic_param->BFV(reference_fields,value) = 0; /* reset all bits */ ++ pic_param->BFM(reference_fields,bits,reference_distance_flag) = v->refdist_flag; ++ pic_param->BFM(reference_fields,bits,reference_distance) = 0; /* XXX: interlaced frame */ ++ pic_param->BFM(reference_fields,bits,num_reference_pictures) = 0; /* XXX: interlaced frame */ ++ pic_param->BFM(reference_fields,bits,reference_field_pic_indicator) = 0; /* XXX: interlaced frame */ ++ pic_param->BFV(mv_fields,value) = 0; /* reset all bits */ ++ pic_param->BFM(mv_fields,bits,mv_mode) = vc1_get_MVMODE(v); ++ pic_param->BFM(mv_fields,bits,mv_mode2) = vc1_get_MVMODE2(v); ++ pic_param->BFM(mv_fields,bits,mv_table) = s->mv_table_index; ++ pic_param->BFM(mv_fields,bits,two_mv_block_pattern_table) = 0; /* XXX: interlaced frame */ ++ pic_param->BFM(mv_fields,bits,four_mv_switch) = 0; /* XXX: interlaced frame */ ++ pic_param->BFM(mv_fields,bits,four_mv_block_pattern_table) = 0; /* XXX: interlaced frame */ ++ pic_param->BFM(mv_fields,bits,extended_mv_flag) = v->extended_mv; ++ pic_param->BFM(mv_fields,bits,extended_mv_range) = v->mvrange; ++ pic_param->BFM(mv_fields,bits,extended_dmv_flag) = v->extended_dmv; ++ pic_param->BFM(mv_fields,bits,extended_dmv_range) = 0; /* XXX: interlaced frame */ ++ pic_param->BFV(pic_quantizer_fields,value) = 0; /* reset all bits */ ++ pic_param->BFM(pic_quantizer_fields,bits,dquant) = v->dquant; ++ pic_param->BFM(pic_quantizer_fields,bits,quantizer) = v->quantizer_mode; ++ pic_param->BFM(pic_quantizer_fields,bits,half_qp) = v->halfpq; ++ pic_param->BFM(pic_quantizer_fields,bits,pic_quantizer_scale) = v->pq; ++ pic_param->BFM(pic_quantizer_fields,bits,pic_quantizer_type) = v->pquantizer; ++ pic_param->BFM(pic_quantizer_fields,bits,dq_frame) = v->dquantfrm; ++ pic_param->BFM(pic_quantizer_fields,bits,dq_profile) = v->dqprofile; ++ pic_param->BFM(pic_quantizer_fields,bits,dq_sb_edge) = v->dqprofile == DQPROFILE_SINGLE_EDGE ? v->dqsbedge : 0; ++ pic_param->BFM(pic_quantizer_fields,bits,dq_db_edge) = v->dqprofile == DQPROFILE_DOUBLE_EDGES ? v->dqsbedge : 0; ++ pic_param->BFM(pic_quantizer_fields,bits,dq_binary_level) = v->dqbilevel; ++ pic_param->BFM(pic_quantizer_fields,bits,alt_pic_quantizer) = v->altpq; ++ pic_param->BFV(transform_fields,value) = 0; /* reset all bits */ ++ pic_param->BFM(transform_fields,bits,variable_sized_transform_flag) = v->vstransform; ++ pic_param->BFM(transform_fields,bits,mb_level_transform_type_flag) = v->ttmbf; ++ pic_param->BFM(transform_fields,bits,frame_level_transform_type) = v->ttfrm; ++ pic_param->BFM(transform_fields,bits,transform_ac_codingset_idx1) = v->c_ac_table_index; ++ pic_param->BFM(transform_fields,bits,transform_ac_codingset_idx2) = v->y_ac_table_index; ++ pic_param->BFM(transform_fields,bits,intra_transform_dc_table) = v->s.dc_table_index; + + switch (s->pict_type) { + case FF_B_TYPE: +@@ -250,29 +250,29 @@ static int vaapi_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_t + break; + } + +- if (pic_param->bitplane_present.value) { ++ if (pic_param->BFV(V_bitplane_present,value)) { + uint8_t *bitplane; + const uint8_t *ff_bp[3]; + int x, y, n; + + switch (s->pict_type) { + case FF_P_TYPE: +- ff_bp[0] = pic_param->bitplane_present.flags.bp_direct_mb ? v->direct_mb_plane : NULL; +- ff_bp[1] = pic_param->bitplane_present.flags.bp_skip_mb ? s->mbskip_table : NULL; +- ff_bp[2] = pic_param->bitplane_present.flags.bp_mv_type_mb ? v->mv_type_mb_plane : NULL; ++ ff_bp[0] = pic_param->BFM(M_bitplane_present,flags,bp_direct_mb) ? v->direct_mb_plane : NULL; ++ ff_bp[1] = pic_param->BFM(M_bitplane_present,flags,bp_skip_mb) ? s->mbskip_table : NULL; ++ ff_bp[2] = pic_param->BFM(M_bitplane_present,flags,bp_mv_type_mb) ? v->mv_type_mb_plane : NULL; + break; + case FF_B_TYPE: + if (!v->bi_type) { +- ff_bp[0] = pic_param->bitplane_present.flags.bp_direct_mb ? v->direct_mb_plane : NULL; +- ff_bp[1] = pic_param->bitplane_present.flags.bp_skip_mb ? s->mbskip_table : NULL; ++ ff_bp[0] = pic_param->BFM(M_bitplane_present,flags,bp_direct_mb) ? v->direct_mb_plane : NULL; ++ ff_bp[1] = pic_param->BFM(M_bitplane_present,flags,bp_skip_mb) ? s->mbskip_table : NULL; + ff_bp[2] = NULL; /* XXX: interlaced frame (FORWARD plane) */ + break; + } + /* fall-through (BI-type) */ + case FF_I_TYPE: + ff_bp[0] = NULL; /* XXX: interlaced frame (FIELDTX plane) */ +- ff_bp[1] = pic_param->bitplane_present.flags.bp_ac_pred ? v->acpred_plane : NULL; +- ff_bp[2] = pic_param->bitplane_present.flags.bp_overflags ? v->over_flags_plane : NULL; ++ ff_bp[1] = pic_param->BFM(M_bitplane_present,flags,bp_ac_pred) ? v->acpred_plane : NULL; ++ ff_bp[2] = pic_param->BFM(M_bitplane_present,flags,bp_overflags) ? v->over_flags_plane : NULL; + break; + default: + ff_bp[0] = NULL; +diff --git a/libvo/vo_vaapi.c b/libvo/vo_vaapi.c +index 5f75b09..bbc95ff 100644 +--- a/libvo/vo_vaapi.c ++++ b/libvo/vo_vaapi.c +@@ -45,7 +45,11 @@ + #include + #include + #include ++#if CONFIG_VAAPI_OLD ++#include ++#else + #include ++#endif + #if CONFIG_VAAPI_GLX + #include + #endif diff --git a/media-video/mplayer/files/vaapi-take2/04-mplayer-vdpau.patch b/media-video/mplayer/files/vaapi-take2/04-mplayer-vdpau.patch new file mode 100644 index 0000000..ac69b66 --- /dev/null +++ b/media-video/mplayer/files/vaapi-take2/04-mplayer-vdpau.patch @@ -0,0 +1,1243 @@ +diff --git a/configure b/configure +index 89a0a9a..c325521 100755 +--- a/configure ++++ b/configure +@@ -586,7 +586,7 @@ libavparsers=$libavparsers_all + libavbsfs_all=$(sed -n 's/^[^#]*BSF.*(.*, *\(.*\)).*/\1_bsf/p' ffmpeg/libavcodec/allcodecs.c | tr '[a-z]' '[A-Z]') + libavbsfs=$libavbsfs_all + libavhwaccels_all=$(sed -n 's/^[^#]*HWACCEL.*(.*, *\(.*\)).*/\1_hwaccel/p' ffmpeg/libavcodec/allcodecs.c | tr '[a-z]' '[A-Z]') +-libavhwaccels=$(for h in $libavhwaccels_all; do case $h in (*_VAAPI_HWACCEL) echo $h;; esac; done) ++libavhwaccels=$(for h in $libavhwaccels_all; do case $h in (*_VAAPI_HWACCEL|*_VDPAU_HWACCEL) echo $h;; esac; done) + libavdemuxers_all=$(sed -n 's/^[^#]*DEMUX.*(.*, *\(.*\)).*/\1_demuxer/p' ffmpeg/libavformat/allformats.c | tr '[a-z]' '[A-Z]') + libavdemuxers=$(echo $libavdemuxers_all | sed -e 's/ LIB[A-Z0-9_]*_DEMUXER//g' -e s/REDIR_DEMUXER// -e s/AVISYNTH_DEMUXER//) + libavmuxers_all=$(sed -n 's/^[^#]*_MUX.*(.*, *\(.*\)).*/\1_muxer/p' ffmpeg/libavformat/allformats.c | tr '[a-z]' '[A-Z]') +@@ -4593,7 +4593,7 @@ if test "$_vdpau" = yes ; then + else + def_vdpau='#define CONFIG_VDPAU 0' + novomodules="vdpau $novomodules" +- libavdecoders=$(echo $libavdecoders | sed -e "s/\(MPEG\|MPEG[124]\|H26[34]\|WMV3\|VC1\)_VDPAU_DECODER//g") ++ libavhwaccels=$(echo $libavhwaccels | sed -e "s/\(MPEG[124]\|H26[34]\|WMV3\|VC1\)_VDPAU_HWACCEL//g") + fi + echores "$_vdpau" + +diff --git a/etc/codecs.conf b/etc/codecs.conf +index 8eece64..2db98e4 100644 +--- a/etc/codecs.conf ++++ b/etc/codecs.conf +@@ -176,6 +176,7 @@ + fourcc m1v1 + driver ffmpeg + dll "mpeg1video" ++ out VDPAU_MPEG1 + out YV12,I420,IYUV + + videocodec ffmpeg2 +@@ -213,6 +214,7 @@ + driver ffmpeg + dll "mpeg2video" + out VAAPI_MPEG2 ++ out VDPAU_MPEG2 + out YV12,I420,IYUV + out 422P,444P + +@@ -253,6 +255,7 @@ + fourcc slif ; SoftLab MPEG-2 I-frames Codec + driver ffmpeg + dll "mpegvideo" ++ out VDPAU_MPEG1,VDPAU_MPEG2 + out YV12,I420,IYUV + out 422P,444P + +@@ -332,41 +335,6 @@ + out IDCT_MPEG2 + out MOCO_MPEG2 + +-videocodec ffmpeg12vdpau +- info "FFmpeg MPEG-1/2 (VDPAU)" +- status working +- format 0x10000001 ; MPEG-1 +- format 0x10000002 ; MPEG-2 +- fourcc mpg1,mpg2,MPG2 +- fourcc PIM1 ; Pinnacle hardware-MPEG-1 +- fourcc PIM2 ; Pinnacle hardware-MPEG-2 +- fourcc "DVR " +- fourcc hdv2 +- fourcc MPEG +- fourcc hdv1 +- fourcc hdv3 ; HDV 1080i50 +- fourcc hdv5 ; HDV 720p25 +- fourcc mx5p ; MPEG IMX 625/50 (50 Mb/s) +- fourcc hdv6,hdv7,hdv8 +- fourcc xdv1,xdv2,xdv3 +- fourcc xdv4,xdv5,xdv6 +- fourcc xdv7,xdv8,xdv9 +- fourcc xdva,xdvb,xdvc +- fourcc xdvd,xdve,xdvf +- fourcc xd5a,xd5b,xd5c +- fourcc xd5d,xd5e,xd5f +- fourcc xd59,xd54 +- fourcc mx5n,mx4n,mx4p +- fourcc mx3n,mx3p +- fourcc AVmp +- fourcc mp2v,mpgv +- fourcc LMP2 ; Lead mpeg2 in avi +- fourcc m2v1,m1v1 +- driver ffmpeg +- dll "mpegvideo_vdpau" +- out VDPAU_MPEG1 +- out VDPAU_MPEG2 +- + videocodec mpegpes + info "MPEG-PES output (.mpg or DXR3/IVTV/DVB/V4L2 card)" + comment "for hardware decoding" +@@ -943,6 +911,7 @@ + driver ffmpeg + dll wmv3 + out VAAPI_WMV3 ++ out VDPAU_WMV3 + out YV12,I420,IYUV + + videocodec ffwmvp +@@ -954,14 +923,6 @@ + dll wmv3 + out YV12,I420,IYUV + +-videocodec ffwmv3vdpau +- info "FFmpeg WMV3/WMV9 (VDPAU)" +- status buggy +- fourcc WMV3,wmv3 +- driver ffmpeg +- dll wmv3_vdpau +- out VDPAU_WMV3 +- + videocodec ffvc1 + info "FFmpeg WVC1" + status buggy +@@ -970,16 +931,8 @@ + driver ffmpeg + dll vc1 + out VAAPI_VC1 +- out YV12,I420,IYUV +- +-videocodec ffvc1vdpau +- info "FFmpeg WVC1 (VDPAU)" +- status buggy +- fourcc WVC1,wvc1,WMVA +- fourcc vc-1,VC-1 +- driver ffmpeg +- dll vc1_vdpau + out VDPAU_VC1 ++ out YV12,I420,IYUV + + videocodec ffh264 + info "FFmpeg H.264" +@@ -993,19 +946,8 @@ + driver ffmpeg + dll h264 + out VAAPI_H264 +- out YV12,I420,IYUV +- +-videocodec ffh264vdpau +- info "FFmpeg H.264 (VDPAU)" +- status working +- fourcc H264,h264 +- fourcc X264,x264 +- fourcc avc1,AVC1 +- fourcc davc,DAVC +- format 0x10000005 +- driver ffmpeg +- dll h264_vdpau + out VDPAU_H264 ++ out YV12,I420,IYUV + + videocodec coreavcwindows + info "CoreAVC H.264 for x86 - http://corecodec.org/" +@@ -1063,40 +1005,8 @@ + driver ffmpeg + dll mpeg4 ;opendivx + out VAAPI_MPEG4 +- out YV12,I420,IYUV +- +-videocodec ffodivxvdpau +- info "FFmpeg MPEG-4,DIVX-4/5 (VDPAU)" +- status working +- fourcc FMP4,fmp4 +- fourcc DIVX,divx +- fourcc DIV1,div1 divx +- fourcc MP4S,mp4s ; ISO MPEG-4 Video V1 +- fourcc M4S2,m4s2 +- fourcc xvid,XVID,XviD,XVIX +- fourcc DX50,dx50,BLZ0 DX50 +- fourcc mp4v,MP4V +- format 0x4 +- fourcc UMP4 +- fourcc RMP4 +- fourcc 3IV2,3iv2 ; 3ivx Delta 4 +- fourcc DXGM +- fourcc SEDG ; diskless camcorder Samsung Miniket VP-M110 +- fourcc SMP4,smp4 ; Samsung SMP4 video codec +- fourcc VIDM ; vidm 4.01 codec +- format 0x10000004 ; mpeg 4 es +- fourcc m4cc,M4CC +- fourcc hdx4,HDX4 +- fourcc FVFW,fvfw +- fourcc FFDS +- fourcc DCOD,MVXM,EM4A,PM4V +- fourcc M4T3,DMK2,DIGI,INMC +- fourcc EPHV,SN40,WAWV +- fourcc uldx,ULDX,VSPX +- fourcc SIPP ; Samsung SHR-6040 +- driver ffmpeg +- dll mpeg4_vdpau + out VDPAU_MPEG4 ++ out YV12,I420,IYUV + + videocodec ffwv1f + info "WV1F MPEG-4" +diff --git a/fmt-conversion.c b/fmt-conversion.c +index bd32ce8..8994caa 100644 +--- a/fmt-conversion.c ++++ b/fmt-conversion.c +@@ -91,12 +91,6 @@ static const struct { + + {IMGFMT_XVMC_MOCO_MPEG2, PIX_FMT_XVMC_MPEG2_MC}, + {IMGFMT_XVMC_IDCT_MPEG2, PIX_FMT_XVMC_MPEG2_IDCT}, +- {IMGFMT_VDPAU_MPEG1, PIX_FMT_VDPAU_MPEG1}, +- {IMGFMT_VDPAU_MPEG2, PIX_FMT_VDPAU_MPEG2}, +- {IMGFMT_VDPAU_H264, PIX_FMT_VDPAU_H264}, +- {IMGFMT_VDPAU_WMV3, PIX_FMT_VDPAU_WMV3}, +- {IMGFMT_VDPAU_VC1, PIX_FMT_VDPAU_VC1}, +- {IMGFMT_VDPAU_MPEG4, PIX_FMT_VDPAU_MPEG4}, + + /* VA-API formats */ + {IMGFMT_VAAPI_MPEG2, PIX_FMT_VAAPI_VLD, CODEC_ID_MPEG2VIDEO}, +@@ -108,6 +102,14 @@ static const struct { + {IMGFMT_VAAPI_WMV3, PIX_FMT_VAAPI_VLD, CODEC_ID_WMV3}, + {IMGFMT_VAAPI_VC1, PIX_FMT_VAAPI_VLD, CODEC_ID_VC1}, + ++ /* VDPAU formats */ ++ {IMGFMT_VDPAU_MPEG1, PIX_FMT_VDPAU, CODEC_ID_MPEG1VIDEO}, ++ {IMGFMT_VDPAU_MPEG2, PIX_FMT_VDPAU, CODEC_ID_MPEG2VIDEO}, ++ {IMGFMT_VDPAU_MPEG4, PIX_FMT_VDPAU, CODEC_ID_MPEG4}, ++ {IMGFMT_VDPAU_H264, PIX_FMT_VDPAU, CODEC_ID_H264}, ++ {IMGFMT_VDPAU_WMV3, PIX_FMT_VDPAU, CODEC_ID_WMV3}, ++ {IMGFMT_VDPAU_VC1, PIX_FMT_VDPAU, CODEC_ID_VC1}, ++ + {0, PIX_FMT_NONE} + }; + +diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c +index f17d03a..185541e 100644 +--- a/ffmpeg/libavcodec/allcodecs.c ++++ b/ffmpeg/libavcodec/allcodecs.c +@@ -65,6 +65,13 @@ void avcodec_register_all(void) + REGISTER_HWACCEL (WMV3_DXVA2, wmv3_dxva2); + REGISTER_HWACCEL (WMV3_VAAPI, wmv3_vaapi); + ++ REGISTER_HWACCEL (H264_VDPAU, h264_vdpau); ++ REGISTER_HWACCEL (MPEG1_VDPAU, mpeg1_vdpau); ++ REGISTER_HWACCEL (MPEG2_VDPAU, mpeg2_vdpau); ++ REGISTER_HWACCEL (MPEG4_VDPAU, mpeg4_vdpau); ++ REGISTER_HWACCEL (VC1_VDPAU, vc1_vdpau); ++ REGISTER_HWACCEL (WMV3_VDPAU, wmv3_vdpau); ++ + /* video codecs */ + REGISTER_DECODER (AASC, aasc); + REGISTER_DECODER (AMV, amv); +@@ -113,7 +120,6 @@ void avcodec_register_all(void) + REGISTER_DECODER (H263I, h263i); + REGISTER_ENCODER (H263P, h263p); + REGISTER_DECODER (H264, h264); +- REGISTER_DECODER (H264_VDPAU, h264_vdpau); + REGISTER_ENCDEC (HUFFYUV, huffyuv); + REGISTER_DECODER (IDCIN, idcin); + REGISTER_DECODER (IFF_BYTERUN1, iff_byterun1); +@@ -137,10 +143,7 @@ void avcodec_register_all(void) + REGISTER_ENCDEC (MPEG1VIDEO, mpeg1video); + REGISTER_ENCDEC (MPEG2VIDEO, mpeg2video); + REGISTER_ENCDEC (MPEG4, mpeg4); +- REGISTER_DECODER (MPEG4_VDPAU, mpeg4_vdpau); + REGISTER_DECODER (MPEGVIDEO, mpegvideo); +- REGISTER_DECODER (MPEG_VDPAU, mpeg_vdpau); +- REGISTER_DECODER (MPEG1_VDPAU, mpeg1_vdpau); + REGISTER_ENCDEC (MSMPEG4V1, msmpeg4v1); + REGISTER_ENCDEC (MSMPEG4V2, msmpeg4v2); + REGISTER_ENCDEC (MSMPEG4V3, msmpeg4v3); +@@ -192,7 +195,6 @@ void avcodec_register_all(void) + REGISTER_DECODER (V210X, v210x); + REGISTER_DECODER (VB, vb); + REGISTER_DECODER (VC1, vc1); +- REGISTER_DECODER (VC1_VDPAU, vc1_vdpau); + REGISTER_DECODER (VCR1, vcr1); + REGISTER_DECODER (VMDVIDEO, vmdvideo); + REGISTER_DECODER (VMNC, vmnc); +@@ -206,7 +208,6 @@ void avcodec_register_all(void) + REGISTER_ENCDEC (WMV1, wmv1); + REGISTER_ENCDEC (WMV2, wmv2); + REGISTER_DECODER (WMV3, wmv3); +- REGISTER_DECODER (WMV3_VDPAU, wmv3_vdpau); + REGISTER_DECODER (WNV1, wnv1); + REGISTER_DECODER (XAN_WC3, xan_wc3); + REGISTER_DECODER (XL, xl); +diff --git a/libavcodec/avcodec.h b/libavcodec/avcodec.h +index 48666f9..7635cf8 100644 +--- a/ffmpeg/libavcodec/avcodec.h ++++ b/ffmpeg/libavcodec/avcodec.h +@@ -643,10 +643,6 @@ typedef struct RcOverride{ + */ + #define CODEC_CAP_SMALL_LAST_FRAME 0x0040 + /** +- * Codec can export data for HW decoding (VDPAU). +- */ +-#define CODEC_CAP_HWACCEL_VDPAU 0x0080 +-/** + * Codec can output multiple frames per AVPacket + * Normally demuxers return one frame at a time, demuxers which do not do + * are connected to a parser to split what they return into proper frames. +diff --git a/libavcodec/error_resilience.c b/libavcodec/error_resilience.c +index dc015b9..a36f7ac 100644 +--- a/ffmpeg/libavcodec/error_resilience.c ++++ b/ffmpeg/libavcodec/error_resilience.c +@@ -759,7 +759,6 @@ void ff_er_frame_end(MpegEncContext *s){ + + if(!s->error_recognition || s->error_count==0 || s->avctx->lowres || + s->avctx->hwaccel || +- s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU || + s->picture_structure != PICT_FRAME || // we dont support ER of field pictures yet, though it should not crash if enabled + s->error_count==3*s->mb_width*(s->avctx->skip_top + s->avctx->skip_bottom)) return; + +diff --git a/libavcodec/h263dec.c b/libavcodec/h263dec.c +index d9d6f7e..f7a21ed 100644 +--- a/ffmpeg/libavcodec/h263dec.c ++++ b/ffmpeg/libavcodec/h263dec.c +@@ -33,7 +33,6 @@ + #include "h263_parser.h" + #include "mpeg4video_parser.h" + #include "msmpeg4.h" +-#include "vdpau_internal.h" + #include "flv.h" + #include "mpeg4video.h" + +@@ -619,11 +618,6 @@ retry: + if(MPV_frame_start(s, avctx) < 0) + return -1; + +- if (CONFIG_MPEG4_VDPAU_DECODER && (s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)) { +- ff_vdpau_mpeg4_decode_picture(s, s->gb.buffer, s->gb.buffer_end - s->gb.buffer); +- goto frame_end; +- } +- + if (avctx->hwaccel) { + if (avctx->hwaccel->start_frame(avctx, s->gb.buffer, s->gb.buffer_end - s->gb.buffer) < 0) + return -1; +diff --git a/libavcodec/h264.c b/libavcodec/h264.c +index d1662fc..72e00b6 100644 +--- a/ffmpeg/libavcodec/h264.c ++++ b/ffmpeg/libavcodec/h264.c +@@ -36,7 +36,6 @@ + #include "golomb.h" + #include "mathops.h" + #include "rectangle.h" +-#include "vdpau_internal.h" + #include "libavutil/avassert.h" + + #include "cabac.h" +@@ -1650,9 +1649,6 @@ static void field_end(H264Context *h){ + s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264; + s->current_picture_ptr->pict_type= s->pict_type; + +- if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) +- ff_vdpau_h264_set_reference_frames(s); +- + if(!s->dropable) { + ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index); + h->prev_poc_msb= h->poc_msb; +@@ -1666,9 +1662,6 @@ static void field_end(H264Context *h){ + av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode picture\n"); + } + +- if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) +- ff_vdpau_h264_picture_complete(s); +- + /* + * FIXME: Error handling code does not seem to support interlaced + * when slices span multiple rows +@@ -2710,8 +2703,6 @@ static void execute_decode_slices(H264Context *h, int context_count){ + + if (s->avctx->hwaccel) + return; +- if(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) +- return; + if(context_count == 1) { + decode_slice(avctx, &h); + } else { +@@ -2847,8 +2838,6 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){ + if (h->current_slice == 1) { + if (s->avctx->hwaccel && s->avctx->hwaccel->start_frame(s->avctx, NULL, 0) < 0) + return -1; +- if(CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) +- ff_vdpau_h264_picture_start(s); + } + + s->current_picture_ptr->key_frame |= +@@ -2863,11 +2852,6 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){ + if (avctx->hwaccel->decode_slice(avctx, &buf[buf_index - consumed], consumed) < 0) + return -1; + }else +- if(CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU){ +- static const uint8_t start_code[] = {0x00, 0x00, 0x01}; +- ff_vdpau_add_data_chunk(s, start_code, sizeof(start_code)); +- ff_vdpau_add_data_chunk(s, &buf[buf_index - consumed], consumed ); +- }else + context_count++; + } + break; +@@ -3396,20 +3380,3 @@ AVCodec h264_decoder = { + .flush= flush_dpb, + .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"), + }; +- +-#if CONFIG_H264_VDPAU_DECODER +-AVCodec h264_vdpau_decoder = { +- "h264_vdpau", +- AVMEDIA_TYPE_VIDEO, +- CODEC_ID_H264, +- sizeof(H264Context), +- ff_h264_decode_init, +- NULL, +- ff_h264_decode_end, +- decode_frame, +- CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU, +- .flush= flush_dpb, +- .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"), +- .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_H264, PIX_FMT_NONE}, +-}; +-#endif +diff --git a/libavcodec/mpeg12.c b/libavcodec/mpeg12.c +index 0af24ad..8a2e93c 100644 +--- a/ffmpeg/libavcodec/mpeg12.c ++++ b/ffmpeg/libavcodec/mpeg12.c +@@ -35,7 +35,6 @@ + #include "mpeg12data.h" + #include "mpeg12decdata.h" + #include "bytestream.h" +-#include "vdpau_internal.h" + #include "xvmc_internal.h" + + //#undef NDEBUG +@@ -1226,12 +1225,7 @@ static enum PixelFormat mpeg_get_pixelformat(AVCodecContext *avctx){ + + if(avctx->xvmc_acceleration) + return avctx->get_format(avctx,pixfmt_xvmc_mpg2_420); +- else if(avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU){ +- if(avctx->codec_id == CODEC_ID_MPEG1VIDEO) +- return PIX_FMT_VDPAU_MPEG1; +- else +- return PIX_FMT_VDPAU_MPEG2; +- }else{ ++ else{ + if(s->chroma_format < 2) + return avctx->get_format(avctx,ff_hwaccel_pixfmt_list_420); + else if(s->chroma_format == 2) +@@ -1324,9 +1318,7 @@ static int mpeg_decode_postinit(AVCodecContext *avctx){ + avctx->pix_fmt = mpeg_get_pixelformat(avctx); + avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt); + //until then pix_fmt may be changed right after codec init +- if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT || +- avctx->hwaccel || +- s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU ) ++ if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT || avctx->hwaccel ) + if( avctx->idct_algo == FF_IDCT_AUTO ) + avctx->idct_algo = FF_IDCT_SIMPLE; + +@@ -2065,8 +2057,7 @@ static int vcr2_init_sequence(AVCodecContext *avctx) + avctx->pix_fmt = mpeg_get_pixelformat(avctx); + avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt); + +- if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT || avctx->hwaccel || +- s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU ) ++ if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT || avctx->hwaccel ) + if( avctx->idct_algo == FF_IDCT_AUTO ) + avctx->idct_algo = FF_IDCT_SIMPLE; + +@@ -2297,9 +2288,6 @@ static int decode_chunks(AVCodecContext *avctx, + s2->error_count += s2->thread_context[i]->error_count; + } + +- if (CONFIG_MPEG_VDPAU_DECODER && avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) +- ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count); +- + if (slice_end(avctx, picture)) { + if(s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice + *data_size = sizeof(AVPicture); +@@ -2446,11 +2434,6 @@ static int decode_chunks(AVCodecContext *avctx, + return -1; + } + +- if (avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) { +- s->slice_count++; +- break; +- } +- + if(avctx->thread_count > 1){ + int threshold= (s2->mb_height*s->slice_count + avctx->thread_count/2) / avctx->thread_count; + if(threshold <= mb_y){ +@@ -2578,36 +2561,3 @@ AVCodec mpeg_xvmc_decoder = { + }; + + #endif +- +-#if CONFIG_MPEG_VDPAU_DECODER +-AVCodec mpeg_vdpau_decoder = { +- "mpegvideo_vdpau", +- AVMEDIA_TYPE_VIDEO, +- CODEC_ID_MPEG2VIDEO, +- sizeof(Mpeg1Context), +- mpeg_decode_init, +- NULL, +- mpeg_decode_end, +- mpeg_decode_frame, +- CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY, +- .flush= flush, +- .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"), +-}; +-#endif +- +-#if CONFIG_MPEG1_VDPAU_DECODER +-AVCodec mpeg1_vdpau_decoder = { +- "mpeg1video_vdpau", +- AVMEDIA_TYPE_VIDEO, +- CODEC_ID_MPEG1VIDEO, +- sizeof(Mpeg1Context), +- mpeg_decode_init, +- NULL, +- mpeg_decode_end, +- mpeg_decode_frame, +- CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY, +- .flush= flush, +- .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"), +-}; +-#endif +- +diff --git a/libavcodec/mpeg4videodec.c b/libavcodec/mpeg4videodec.c +index b339f78..1928d03 100644 +--- a/ffmpeg/libavcodec/mpeg4videodec.c ++++ b/ffmpeg/libavcodec/mpeg4videodec.c +@@ -2249,20 +2249,3 @@ AVCodec mpeg4_decoder = { + .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"), + .pix_fmts= ff_hwaccel_pixfmt_list_420, + }; +- +- +-#if CONFIG_MPEG4_VDPAU_DECODER +-AVCodec mpeg4_vdpau_decoder = { +- "mpeg4_vdpau", +- AVMEDIA_TYPE_VIDEO, +- CODEC_ID_MPEG4, +- sizeof(MpegEncContext), +- decode_init, +- NULL, +- ff_h263_decode_end, +- ff_h263_decode_frame, +- CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU, +- .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 (VDPAU)"), +- .pix_fmts= (const enum PixelFormat[]){PIX_FMT_VDPAU_MPEG4, PIX_FMT_NONE}, +-}; +-#endif +diff --git a/libavcodec/mpegvideo.c b/libavcodec/mpegvideo.c +index 684bdfe..1bd9d5c 100644 +--- a/ffmpeg/libavcodec/mpegvideo.c ++++ b/ffmpeg/libavcodec/mpegvideo.c +@@ -116,6 +116,7 @@ const enum PixelFormat ff_pixfmt_list_420[] = { + const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = { + PIX_FMT_DXVA2_VLD, + PIX_FMT_VAAPI_VLD, ++ PIX_FMT_VDPAU, + PIX_FMT_YUV420P, + PIX_FMT_NONE + }; +@@ -1056,7 +1057,6 @@ void MPV_frame_end(MpegEncContext *s) + if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){ + ff_xvmc_field_end(s); + }else if(!s->avctx->hwaccel +- && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) + && s->unrestricted_mv + && s->current_picture.reference + && !s->intra_only +diff --git a/libavcodec/vc1dec.c b/libavcodec/vc1dec.c +index 8c9cbcd..dbf2ded 100644 +--- a/ffmpeg/libavcodec/vc1dec.c ++++ b/ffmpeg/libavcodec/vc1dec.c +@@ -37,7 +37,6 @@ + #include "unary.h" + #include "simple_idct.h" + #include "mathops.h" +-#include "vdpau_internal.h" + + #undef NDEBUG + #include +@@ -3167,13 +3166,6 @@ static int vc1_decode_frame(AVCodecContext *avctx, + s->current_picture_ptr= &s->picture[i]; + } + +- if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU){ +- if (v->profile < PROFILE_ADVANCED) +- avctx->pix_fmt = PIX_FMT_VDPAU_WMV3; +- else +- avctx->pix_fmt = PIX_FMT_VDPAU_VC1; +- } +- + //for advanced profile we may need to parse and unescape data + if (avctx->codec_id == CODEC_ID_VC1) { + int buf_size2 = 0; +@@ -3190,8 +3182,7 @@ static int vc1_decode_frame(AVCodecContext *avctx, + if(size <= 0) continue; + switch(AV_RB32(start)){ + case VC1_CODE_FRAME: +- if (avctx->hwaccel || +- s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) ++ if (avctx->hwaccel) + buf_start = start; + buf_size2 = vc1_unescape_buffer(start + 4, size, buf2); + break; +@@ -3278,10 +3269,7 @@ static int vc1_decode_frame(AVCodecContext *avctx, + s->me.qpel_put= s->dsp.put_qpel_pixels_tab; + s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab; + +- if ((CONFIG_VC1_VDPAU_DECODER) +- &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) +- ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start); +- else if (avctx->hwaccel) { ++ if (avctx->hwaccel) { + if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0) + return -1; + if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0) +@@ -3371,37 +3359,3 @@ AVCodec wmv3_decoder = { + .pix_fmts = ff_hwaccel_pixfmt_list_420 + }; + #endif +- +-#if CONFIG_WMV3_VDPAU_DECODER +-AVCodec wmv3_vdpau_decoder = { +- "wmv3_vdpau", +- AVMEDIA_TYPE_VIDEO, +- CODEC_ID_WMV3, +- sizeof(VC1Context), +- vc1_decode_init, +- NULL, +- vc1_decode_end, +- vc1_decode_frame, +- CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU, +- NULL, +- .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"), +- .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE} +-}; +-#endif +- +-#if CONFIG_VC1_VDPAU_DECODER +-AVCodec vc1_vdpau_decoder = { +- "vc1_vdpau", +- AVMEDIA_TYPE_VIDEO, +- CODEC_ID_VC1, +- sizeof(VC1Context), +- vc1_decode_init, +- NULL, +- vc1_decode_end, +- vc1_decode_frame, +- CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU, +- NULL, +- .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"), +- .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_VC1, PIX_FMT_NONE} +-}; +-#endif +diff --git a/libavcodec/vdpau.c b/libavcodec/vdpau.c +index bd721e8..09ca45e 100644 +--- a/ffmpeg/libavcodec/vdpau.c ++++ b/ffmpeg/libavcodec/vdpau.c +@@ -30,7 +30,6 @@ + #include + + #include "vdpau.h" +-#include "vdpau_internal.h" + + /** + * \addtogroup VDPAU_Decoding +@@ -38,15 +37,57 @@ + * @{ + */ + +-void ff_vdpau_h264_set_reference_frames(MpegEncContext *s) ++static void vdpau_h264_fill_field_order_cnt(int32_t field_order_cnt[2], Picture *pic, int pic_structure) + { +- H264Context *h = s->avctx->priv_data; ++ int i; ++ for (i = 0; i < 2; i++) { ++ const int poc = pic->field_poc[i]; ++ field_order_cnt[i] = poc != INT_MAX ? poc : 0; ++ } ++} ++ ++static void vdpau_h264_init_picture(VdpReferenceFrameH264 *rf) ++{ ++ rf->surface = VDP_INVALID_HANDLE; ++ rf->is_long_term = 0; ++ rf->top_is_reference = 0; ++ rf->bottom_is_reference = 0; ++ rf->field_order_cnt[0] = 0; ++ rf->field_order_cnt[1] = 0; ++ rf->frame_idx = 0; ++} ++ ++static void vdpau_h264_fill_picture(VdpReferenceFrameH264 *rf, Picture *pic, int pic_structure) ++{ ++ struct vdpau_render_state *render; ++ ++ assert(rf); ++ assert(pic); ++ ++ if (pic_structure == 0) ++ pic_structure = pic->reference; ++ ++ render = (struct vdpau_render_state *)pic->data[3]; ++ assert(render); ++ ++ rf->surface = render->surface; ++ rf->is_long_term = pic->reference && pic->long_ref; ++ rf->top_is_reference = (pic_structure & PICT_TOP_FIELD) != 0; ++ rf->bottom_is_reference = (pic_structure & PICT_BOTTOM_FIELD) != 0; ++ rf->frame_idx = pic->long_ref ? pic->pic_id : pic->frame_num; ++ ++ vdpau_h264_fill_field_order_cnt(rf->field_order_cnt, pic, pic_structure); ++} ++ ++static void vdpau_h264_set_reference_frames(H264Context *h) ++{ ++ MpegEncContext * const s = &h->s; + struct vdpau_render_state *render, *render_ref; + VdpReferenceFrameH264 *rf, *rf2; + Picture *pic; + int i, list, pic_frame_idx; + +- render = (struct vdpau_render_state *)s->current_picture_ptr->data[0]; ++ render = (struct vdpau_render_state *)s->current_picture_ptr->data[3]; + assert(render); + + rf = &render->info.h264.referenceFrames[0]; +@@ -62,7 +103,7 @@ void ff_vdpau_h264_set_reference_frames(MpegEncContext *s) + continue; + pic_frame_idx = pic->long_ref ? pic->pic_id : pic->frame_num; + +- render_ref = (struct vdpau_render_state *)pic->data[0]; ++ render_ref = (struct vdpau_render_state *)pic->data[3]; + assert(render_ref); + + rf2 = &render->info.h264.referenceFrames[0]; +@@ -84,81 +125,93 @@ void ff_vdpau_h264_set_reference_frames(MpegEncContext *s) + if (rf >= &render->info.h264.referenceFrames[H264_RF_COUNT]) + continue; + +- rf->surface = render_ref->surface; +- rf->is_long_term = pic->long_ref; +- rf->top_is_reference = (pic->reference & PICT_TOP_FIELD) ? VDP_TRUE : VDP_FALSE; +- rf->bottom_is_reference = (pic->reference & PICT_BOTTOM_FIELD) ? VDP_TRUE : VDP_FALSE; +- rf->field_order_cnt[0] = pic->field_poc[0]; +- rf->field_order_cnt[1] = pic->field_poc[1]; +- rf->frame_idx = pic_frame_idx; ++ vdpau_h264_fill_picture(rf, pic, pic->reference); + + ++rf; + } + } + +- for (; rf < &render->info.h264.referenceFrames[H264_RF_COUNT]; ++rf) { +- rf->surface = VDP_INVALID_HANDLE; +- rf->is_long_term = 0; +- rf->top_is_reference = 0; +- rf->bottom_is_reference = 0; +- rf->field_order_cnt[0] = 0; +- rf->field_order_cnt[1] = 0; +- rf->frame_idx = 0; +- } ++ for (; rf < &render->info.h264.referenceFrames[H264_RF_COUNT]; ++rf) ++ vdpau_h264_init_picture(rf); + } + +-void ff_vdpau_add_data_chunk(MpegEncContext *s, +- const uint8_t *buf, int buf_size) ++static int vdpau_ensure_bitstream_buffers(struct vdpau_render_state *render) + { +- struct vdpau_render_state *render; +- +- render = (struct vdpau_render_state *)s->current_picture_ptr->data[0]; +- assert(render); +- + render->bitstream_buffers= av_fast_realloc( + render->bitstream_buffers, + &render->bitstream_buffers_allocated, + sizeof(*render->bitstream_buffers)*(render->bitstream_buffers_used + 1) + ); + +- render->bitstream_buffers[render->bitstream_buffers_used].struct_version = VDP_BITSTREAM_BUFFER_VERSION; +- render->bitstream_buffers[render->bitstream_buffers_used].bitstream = buf; +- render->bitstream_buffers[render->bitstream_buffers_used].bitstream_bytes = buf_size; +- render->bitstream_buffers_used++; ++ if (!render->bitstream_buffers) ++ return -1; ++ ++ return 0; + } + +-void ff_vdpau_h264_picture_start(MpegEncContext *s) ++static int vdpau_common_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size) + { +- H264Context *h = s->avctx->priv_data; ++ MpegEncContext * const s = avctx->priv_data; + struct vdpau_render_state *render; +- int i; + +- render = (struct vdpau_render_state *)s->current_picture_ptr->data[0]; ++ render = (struct vdpau_render_state *)s->current_picture_ptr->data[3]; + assert(render); + +- for (i = 0; i < 2; ++i) { +- int foc = s->current_picture_ptr->field_poc[i]; +- if (foc == INT_MAX) +- foc = 0; +- render->info.h264.field_order_cnt[i] = foc; ++ render->bitstream_buffers_used = 0; ++ return 0; ++} ++ ++static int vdpau_common_end_frame(AVCodecContext *avctx) ++{ ++ MpegEncContext * const s = avctx->priv_data; ++ struct vdpau_render_state *render; ++ ++ render = (struct vdpau_render_state *)s->current_picture_ptr->data[3]; ++ assert(render); ++ ++ if (render->bitstream_buffers_used) { ++ ff_draw_horiz_band(s, 0, s->avctx->height); ++ render->bitstream_buffers_used = 0; + } ++ return 0; ++} + +- render->info.h264.frame_num = h->frame_num; ++static int vdpau_common_decode_slice(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size) ++{ ++ MpegEncContext * const s = avctx->priv_data; ++ struct vdpau_render_state *render; ++ ++ render = (struct vdpau_render_state *)s->current_picture_ptr->data[3]; ++ assert(render); ++ ++ if (vdpau_ensure_bitstream_buffers(render) < 0) ++ return -1; ++ ++ render->bitstream_buffers[render->bitstream_buffers_used].struct_version = VDP_BITSTREAM_BUFFER_VERSION; ++ render->bitstream_buffers[render->bitstream_buffers_used].bitstream = buf; ++ render->bitstream_buffers[render->bitstream_buffers_used].bitstream_bytes = buf_size; ++ render->bitstream_buffers_used++; ++ return 0; + } + +-void ff_vdpau_h264_picture_complete(MpegEncContext *s) ++static int vdpau_h264_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size) + { +- H264Context *h = s->avctx->priv_data; ++ H264Context * const h = avctx->priv_data; ++ MpegEncContext * const s = &h->s; + struct vdpau_render_state *render; + +- render = (struct vdpau_render_state *)s->current_picture_ptr->data[0]; ++ render = (struct vdpau_render_state *)s->current_picture_ptr->data[3]; + assert(render); + +- render->info.h264.slice_count = h->slice_num; +- if (render->info.h264.slice_count < 1) +- return; ++ vdpau_h264_set_reference_frames(h); + +- render->info.h264.is_reference = (s->current_picture_ptr->reference & 3) ? VDP_TRUE : VDP_FALSE; ++ vdpau_h264_fill_field_order_cnt(render->info.h264.field_order_cnt, ++ s->current_picture_ptr, ++ s->picture_structure); ++ ++ /* fill VdpPictureInfoH264 struct */ ++ render->info.h264.is_reference = h->nal_ref_idc != 0; ++ render->info.h264.frame_num = h->frame_num; + render->info.h264.field_pic_flag = s->picture_structure != PICT_FRAME; + render->info.h264.bottom_field_flag = s->picture_structure == PICT_BOTTOM_FIELD; + render->info.h264.num_ref_frames = h->sps.ref_frame_count; +@@ -185,19 +238,44 @@ void ff_vdpau_h264_picture_complete(MpegEncContext *s) + memcpy(render->info.h264.scaling_lists_4x4, h->pps.scaling_matrix4, sizeof(render->info.h264.scaling_lists_4x4)); + memcpy(render->info.h264.scaling_lists_8x8, h->pps.scaling_matrix8, sizeof(render->info.h264.scaling_lists_8x8)); + +- ff_draw_horiz_band(s, 0, s->avctx->height); +- render->bitstream_buffers_used = 0; ++ render->info.h264.slice_count = 0; ++ ++ return vdpau_common_start_frame(avctx, buffer, size); + } + +-void ff_vdpau_mpeg_picture_complete(MpegEncContext *s, const uint8_t *buf, +- int buf_size, int slice_count) ++static int vdpau_h264_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size) + { ++ MpegEncContext * const s = avctx->priv_data; ++ struct vdpau_render_state *render; ++ static const uint8_t start_code_prefix_one_3byte[3] = { 0x00, 0x00, 0x01 }; ++ ++ render = (struct vdpau_render_state *)s->current_picture_ptr->data[3]; ++ assert(render); ++ ++ if (vdpau_ensure_bitstream_buffers(render) < 0) ++ return -1; ++ ++ render->bitstream_buffers[render->bitstream_buffers_used].struct_version = VDP_BITSTREAM_BUFFER_VERSION; ++ render->bitstream_buffers[render->bitstream_buffers_used].bitstream = start_code_prefix_one_3byte; ++ render->bitstream_buffers[render->bitstream_buffers_used].bitstream_bytes = sizeof(start_code_prefix_one_3byte); ++ render->bitstream_buffers_used++; ++ ++ if (vdpau_common_decode_slice(avctx, buffer, size) < 0) ++ return -1; ++ ++ ++render->info.h264.slice_count; ++ return 0; ++} ++ ++static int vdpau_mpeg2_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size) ++{ ++ MpegEncContext * const s = avctx->priv_data; + struct vdpau_render_state *render, *last, *next; + int i; + +- if (!s->current_picture_ptr) return; ++ if (!s->current_picture_ptr) return 0; + +- render = (struct vdpau_render_state *)s->current_picture_ptr->data[0]; ++ render = (struct vdpau_render_state *)s->current_picture_ptr->data[3]; + assert(render); + + /* fill VdpPictureInfoMPEG1Or2 struct */ +@@ -226,36 +304,47 @@ void ff_vdpau_mpeg_picture_complete(MpegEncContext *s, const uint8_t *buf, + + switch(s->pict_type){ + case FF_B_TYPE: +- next = (struct vdpau_render_state *)s->next_picture.data[0]; ++ next = (struct vdpau_render_state *)s->next_picture.data[3]; + assert(next); + render->info.mpeg.backward_reference = next->surface; + // no return here, going to set forward prediction + case FF_P_TYPE: +- last = (struct vdpau_render_state *)s->last_picture.data[0]; ++ last = (struct vdpau_render_state *)s->last_picture.data[3]; + if (!last) // FIXME: Does this test make sense? + last = render; // predict second field from the first + render->info.mpeg.forward_reference = last->surface; + } + +- ff_vdpau_add_data_chunk(s, buf, buf_size); ++ render->info.mpeg.slice_count = 0; + +- render->info.mpeg.slice_count = slice_count; ++ return vdpau_common_start_frame(avctx, buffer, size); ++} + +- if (slice_count) +- ff_draw_horiz_band(s, 0, s->avctx->height); +- render->bitstream_buffers_used = 0; ++static int vdpau_mpeg2_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size) ++{ ++ MpegEncContext * const s = avctx->priv_data; ++ struct vdpau_render_state *render; ++ ++ render = (struct vdpau_render_state *)s->current_picture_ptr->data[3]; ++ assert(render); ++ ++ if (vdpau_common_decode_slice(avctx, buffer, size) < 0) ++ return -1; ++ ++ ++render->info.mpeg.slice_count; ++ return 0; + } + +-void ff_vdpau_vc1_decode_picture(MpegEncContext *s, const uint8_t *buf, +- int buf_size) ++static int vdpau_vc1_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size) + { +- VC1Context *v = s->avctx->priv_data; ++ VC1Context * const v = avctx->priv_data; ++ MpegEncContext * const s = &v->s; + struct vdpau_render_state *render, *last, *next; + +- render = (struct vdpau_render_state *)s->current_picture.data[0]; ++ render = (struct vdpau_render_state *)s->current_picture_ptr->data[3]; + assert(render); + +- /* fill LvPictureInfoVC1 struct */ ++ /* fill VdpPictureInfoVC1 struct */ + render->info.vc1.frame_coding_mode = v->fcm; + render->info.vc1.postprocflag = v->postprocflag; + render->info.vc1.pulldown = v->broadcast; +@@ -296,34 +385,47 @@ void ff_vdpau_vc1_decode_picture(MpegEncContext *s, const uint8_t *buf, + + switch(s->pict_type){ + case FF_B_TYPE: +- next = (struct vdpau_render_state *)s->next_picture.data[0]; ++ next = (struct vdpau_render_state *)s->next_picture.data[3]; + assert(next); + render->info.vc1.backward_reference = next->surface; + // no break here, going to set forward prediction + case FF_P_TYPE: +- last = (struct vdpau_render_state *)s->last_picture.data[0]; ++ last = (struct vdpau_render_state *)s->last_picture.data[3]; + if (!last) // FIXME: Does this test make sense? + last = render; // predict second field from the first + render->info.vc1.forward_reference = last->surface; + } + +- ff_vdpau_add_data_chunk(s, buf, buf_size); ++ render->info.vc1.slice_count = 0; + +- render->info.vc1.slice_count = 1; ++ return vdpau_common_start_frame(avctx, buffer, size); ++} + +- ff_draw_horiz_band(s, 0, s->avctx->height); +- render->bitstream_buffers_used = 0; ++static int vdpau_vc1_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size) ++{ ++ VC1Context * const v = avctx->priv_data; ++ MpegEncContext * const s = &v->s; ++ struct vdpau_render_state *render; ++ ++ render = (struct vdpau_render_state *)s->current_picture_ptr->data[3]; ++ assert(render); ++ ++ if (vdpau_common_decode_slice(avctx, buffer, size) < 0) ++ return -1; ++ ++ ++render->info.vc1.slice_count; ++ return 0; + } + +-void ff_vdpau_mpeg4_decode_picture(MpegEncContext *s, const uint8_t *buf, +- int buf_size) ++static int vdpau_mpeg4_decode_picture(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size) + { ++ MpegEncContext * const s = avctx->priv_data; + struct vdpau_render_state *render, *last, *next; + int i; + +- if (!s->current_picture_ptr) return; ++ if (!s->current_picture_ptr) return 0; + +- render = (struct vdpau_render_state *)s->current_picture_ptr->data[0]; ++ render = (struct vdpau_render_state *)s->current_picture_ptr->data[3]; + assert(render); + + /* fill VdpPictureInfoMPEG4Part2 struct */ +@@ -352,21 +454,122 @@ void ff_vdpau_mpeg4_decode_picture(MpegEncContext *s, const uint8_t *buf, + + switch (s->pict_type) { + case FF_B_TYPE: +- next = (struct vdpau_render_state *)s->next_picture.data[0]; ++ next = (struct vdpau_render_state *)s->next_picture.data[3]; + assert(next); + render->info.mpeg4.backward_reference = next->surface; + render->info.mpeg4.vop_coding_type = 2; + // no break here, going to set forward prediction + case FF_P_TYPE: +- last = (struct vdpau_render_state *)s->last_picture.data[0]; ++ last = (struct vdpau_render_state *)s->last_picture.data[3]; + assert(last); + render->info.mpeg4.forward_reference = last->surface; + } + +- ff_vdpau_add_data_chunk(s, buf, buf_size); ++ if (vdpau_common_start_frame(avctx, buffer, size) < 0) ++ return -1; + +- ff_draw_horiz_band(s, 0, s->avctx->height); +- render->bitstream_buffers_used = 0; ++ if (vdpau_common_decode_slice(avctx, buffer, size) < 0) ++ return -1; ++ ++ return vdpau_common_end_frame(avctx); ++} ++ ++static int vdpau_mpeg4_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size) ++{ ++ /* The `buffer' can be modified beyond this point so we pass the ++ * whole picture now to the decoder and let user-applications catch ++ * up immediately */ ++ return vdpau_mpeg4_decode_picture(avctx, buffer, size); + } + ++static int vdpau_mpeg4_decode_slice(av_unused AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size) ++{ ++ /* SKIP: everything is done in vdpau_mpeg4_start_frame() */ ++ return 0; ++} ++ ++static int vdpau_mpeg4_end_frame(av_unused AVCodecContext *avctx) ++{ ++ /* SKIP: everything is done in vdpau_mpeg4_start_frame() */ ++ return 0; ++} ++ ++#if CONFIG_MPEG1_VDPAU_HWACCEL ++AVHWAccel mpeg1_vdpau_hwaccel = { ++ .name = "mpeg1_vdpau", ++ .type = CODEC_TYPE_VIDEO, ++ .id = CODEC_ID_MPEG1VIDEO, ++ .pix_fmt = PIX_FMT_VDPAU, ++ .capabilities = 0, ++ .start_frame = vdpau_mpeg2_start_frame, ++ .end_frame = vdpau_common_end_frame, ++ .decode_slice = vdpau_mpeg2_decode_slice, ++}; ++#endif ++ ++#if CONFIG_MPEG2_VDPAU_HWACCEL ++AVHWAccel mpeg2_vdpau_hwaccel = { ++ .name = "mpeg2_vdpau", ++ .type = CODEC_TYPE_VIDEO, ++ .id = CODEC_ID_MPEG2VIDEO, ++ .pix_fmt = PIX_FMT_VDPAU, ++ .capabilities = 0, ++ .start_frame = vdpau_mpeg2_start_frame, ++ .end_frame = vdpau_common_end_frame, ++ .decode_slice = vdpau_mpeg2_decode_slice, ++}; ++#endif ++ ++#if CONFIG_H264_VDPAU_HWACCEL ++AVHWAccel h264_vdpau_hwaccel = { ++ .name = "h264_vdpau", ++ .type = CODEC_TYPE_VIDEO, ++ .id = CODEC_ID_H264, ++ .pix_fmt = PIX_FMT_VDPAU, ++ .capabilities = 0, ++ .start_frame = vdpau_h264_start_frame, ++ .end_frame = vdpau_common_end_frame, ++ .decode_slice = vdpau_h264_decode_slice, ++}; ++#endif ++ ++#if CONFIG_WMV3_VDPAU_HWACCEL ++AVHWAccel wmv3_vdpau_hwaccel = { ++ .name = "wmv3_vdpau", ++ .type = CODEC_TYPE_VIDEO, ++ .id = CODEC_ID_WMV3, ++ .pix_fmt = PIX_FMT_VDPAU, ++ .capabilities = 0, ++ .start_frame = vdpau_vc1_start_frame, ++ .end_frame = vdpau_common_end_frame, ++ .decode_slice = vdpau_vc1_decode_slice, ++}; ++#endif ++ ++#if CONFIG_VC1_VDPAU_HWACCEL ++AVHWAccel vc1_vdpau_hwaccel = { ++ .name = "vc1_vdpau", ++ .type = CODEC_TYPE_VIDEO, ++ .id = CODEC_ID_VC1, ++ .pix_fmt = PIX_FMT_VDPAU, ++ .capabilities = 0, ++ .start_frame = vdpau_vc1_start_frame, ++ .end_frame = vdpau_common_end_frame, ++ .decode_slice = vdpau_vc1_decode_slice, ++}; ++#endif ++ ++#if CONFIG_MPEG4_VDPAU_HWACCEL ++AVHWAccel mpeg4_vdpau_hwaccel = { ++ .name = "mpeg4_vdpau", ++ .type = CODEC_TYPE_VIDEO, ++ .id = CODEC_ID_MPEG4, ++ .pix_fmt = PIX_FMT_VDPAU, ++ .capabilities = 0, ++ .start_frame = vdpau_mpeg4_start_frame, ++ .end_frame = vdpau_mpeg4_end_frame, ++ .decode_slice = vdpau_mpeg4_decode_slice, ++}; ++#endif ++ + /* @}*/ +diff --git a/ffmpeg/ffmpeg/libavutil/pixdesc.c b/ffmpeg/ffmpeg/libavutil/pixdesc.c +index e2bc649..1c2b773 100644 +--- a/ffmpeg/libavutil/pixdesc.c ++++ b/ffmpeg/libavutil/pixdesc.c +@@ -787,7 +787,13 @@ const AVPixFmtDescriptor av_pix_fmt_descriptors[PIX_FMT_NB] = { + .comp = { + {0,1,1,0,7}, /* Y */ + {0,1,2,0,7}, /* A */ +- }, ++ } ++ }, ++ [PIX_FMT_VDPAU] = { ++ .name = "vdpau", ++ .log2_chroma_w = 1, ++ .log2_chroma_h = 1, ++ .flags = PIX_FMT_HWACCEL, + }, + }; + +diff --git a/ffmpeg/libavutil/pixfmt.h b/ffmpeg/libavutil/pixfmt.h +index 8ec91c8..2386a81 100644 +--- a/ffmpeg/libavutil/pixfmt.h ++++ b/ffmpeg/libavutil/pixfmt.h +@@ -133,6 +133,7 @@ enum PixelFormat { + PIX_FMT_BGR444BE, ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), big-endian, most significant bits to 1 + PIX_FMT_BGR444LE, ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), little-endian, most significant bits to 1 + PIX_FMT_Y400A, ///< 8bit gray, 8bit alpha ++ PIX_FMT_VDPAU, ///< HW decoding with VDPAU, Picture.data[3] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + 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 + }; + +diff --git a/libmpcodecs/vd_ffmpeg.c b/libmpcodecs/vd_ffmpeg.c +index 5b003fa..150e82c 100644 +--- a/libmpcodecs/vd_ffmpeg.c ++++ b/libmpcodecs/vd_ffmpeg.c +@@ -294,7 +294,7 @@ static int init(sh_video_t *sh){ + } + #endif /* CONFIG_VAAPI */ + #if CONFIG_VDPAU +- if(lavc_codec->capabilities & CODEC_CAP_HWACCEL_VDPAU){ ++ if(get_video_hwaccel() == HWACCEL_VDPAU){ + avctx->get_format = get_format; + } + #endif /* CONFIG_VDPAU */ +diff --git a/libvo/vo_vdpau.c b/libvo/vo_vdpau.c +index 490644d..31c8064 100644 +--- a/libvo/vo_vdpau.c ++++ b/libvo/vo_vdpau.c +@@ -971,7 +971,7 @@ static int draw_slice(uint8_t *image[], int stride[], int w, int h, + int x, int y) + { + VdpStatus vdp_st; +- struct vdpau_render_state *rndr = (struct vdpau_render_state *)image[0]; ++ struct vdpau_render_state *rndr = (struct vdpau_render_state *)image[3]; + int max_refs = image_format == IMGFMT_VDPAU_H264 ? rndr->info.h264.num_ref_frames : 2; + + if (handle_preemption() < 0) +@@ -1074,10 +1074,10 @@ static uint32_t get_image(mp_image_t *mpi) + return VO_FALSE; + } + mpi->flags |= MP_IMGFLAG_DIRECT; +- mpi->stride[0] = mpi->stride[1] = mpi->stride[2] = 0; +- mpi->planes[0] = mpi->planes[1] = mpi->planes[2] = NULL; ++ mpi->stride[0] = mpi->stride[1] = mpi->stride[2] = mpi->stride[3] = 0; ++ mpi->planes[0] = mpi->planes[1] = mpi->planes[2] = mpi->planes[3] = NULL; + // hack to get around a check and to avoid a special-case in vd_ffmpeg.c +- mpi->planes[0] = (void *)rndr; ++ mpi->planes[0] = mpi->planes[3] = (void *)rndr; + mpi->num_planes = 1; + mpi->priv = rndr; + return VO_TRUE; +--- etc/codecs.conf.orig 2010-12-16 20:12:54.150000023 +0100 ++++ etc/codecs.conf 2010-12-16 20:28:00.636000024 +0100 + diff --git a/media-video/mplayer/mplayer-1.0_rc4_p20101114-r50.ebuild b/media-video/mplayer/mplayer-1.0_rc4_p20101114-r50.ebuild new file mode 100644 index 0000000..6dce326 --- /dev/null +++ b/media-video/mplayer/mplayer-1.0_rc4_p20101114-r50.ebuild @@ -0,0 +1,740 @@ +# Copyright 1999-2010 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: /var/cvsroot/gentoo-x86/media-video/mplayer/mplayer-1.0_rc4_p20101114.ebuild,v 1.1 2010/11/14 15:13:00 polynomial-c Exp $ + +EAPI=3 + +ESVN_REPO_URI="svn://svn.mplayerhq.hu/mplayer/trunk" +[[ ${PV} = *9999* ]] && SVN_ECLASS="subversion" || SVN_ECLASS="" + +inherit toolchain-funcs eutils flag-o-matic multilib base ${SVN_ECLASS} + +# BUMP ME PLZ, NO COOKIES OTHERWISE +[[ ${PV} != *9999* ]] && MPLAYER_REVISION=SVN-r32624 + +IUSE="3dnow 3dnowext +a52 aalib +alsa altivec aqua +ass bidi bindist bl bluray +bs2b +cddb +cdio cdparanoia cpudetection custom-cpuopts debug dga +dirac +directfb doc +dts +dv dvb +dvd +dvdnav dxr3 +enca +encode esd +faac +faad fbcon +ftp gif ggi gsm +iconv ipv6 jack joystick jpeg jpeg2k kernel_linux ladspa +libcaca libmpeg2 lirc +live lzo mad md5sum +mmx mmxext mng +mp3 mpg123 nas ++network nut openal amr +opengl +osdmenu oss png pnm pulseaudio pvr +quicktime +radio +rar +real +rtc rtmp samba +shm +schroedinger sdl +speex sse sse2 ssse3 +tga +theora +tremor +truetype +toolame +twolame +unicode v4l v4l2 vaapi vdpau vidix ++vorbis vpx win32codecs +X +x264 xanim xinerama +xscreensaver +xv +xvid xvmc +zoran" +[[ ${PV} == *9999* ]] && IUSE+=" external-ffmpeg" + +VIDEO_CARDS="s3virge mga tdfx vesa" +for x in ${VIDEO_CARDS}; do + IUSE+=" video_cards_${x}" +done + +FONT_URI=" + mirror://mplayer/releases/fonts/font-arial-iso-8859-1.tar.bz2 + mirror://mplayer/releases/fonts/font-arial-iso-8859-2.tar.bz2 + mirror://mplayer/releases/fonts/font-arial-cp1250.tar.bz2 +" +if [[ ${PV} == *9999* ]]; then + RELEASE_URI="" +else + RELEASE_URI="mirror://gentoo/${P}.tar.xz" +fi +SRC_URI="${RELEASE_URI} + !truetype? ( ${FONT_URI} )" + +DESCRIPTION="Media Player for Linux" +HOMEPAGE="http://www.mplayerhq.hu/" + +FONT_RDEPS=" + virtual/ttf-fonts + media-libs/fontconfig + >=media-libs/freetype-2.2.1:2 +" +X_RDEPS=" + x11-libs/libXext + x11-libs/libXxf86vm +" +[[ ${PV} == *9999* ]] && RDEPEND+=" external-ffmpeg? ( media-video/ffmpeg )" +# Rar: althrought -gpl version is nice, it cant do most functions normal rars can +# nemesi? ( net-libs/libnemesi ) +RDEPEND+=" + sys-libs/ncurses + app-arch/bzip2 + sys-libs/zlib + !bindist? ( + x86? ( + win32codecs? ( media-libs/win32codecs ) + ) + ) + X? ( + ${X_RDEPS} + dga? ( x11-libs/libXxf86dga ) + ggi? ( + media-libs/libggi + media-libs/libggiwmh + ) + opengl? ( virtual/opengl ) + vdpau? ( || ( x11-libs/libvdpau >=x11-drivers/nvidia-drivers-180.51 ) ) + xinerama? ( x11-libs/libXinerama ) + xscreensaver? ( x11-libs/libXScrnSaver ) + xv? ( + x11-libs/libXv + xvmc? ( x11-libs/libXvMC ) + ) + ) + a52? ( media-libs/a52dec ) + aalib? ( media-libs/aalib ) + alsa? ( media-libs/alsa-lib ) + amr? ( !bindist? ( media-libs/opencore-amr ) ) + ass? ( ${FONT_RDEPS} >=media-libs/libass-0.9.10[enca?] ) + bidi? ( dev-libs/fribidi ) + bluray? ( media-libs/libbluray ) + bs2b? ( media-libs/libbs2b ) + cdio? ( dev-libs/libcdio ) + cdparanoia? ( !cdio? ( media-sound/cdparanoia ) ) + dirac? ( media-video/dirac ) + directfb? ( dev-libs/DirectFB ) + dts? ( media-libs/libdca ) + dv? ( media-libs/libdv ) + dvb? ( media-tv/linuxtv-dvb-headers ) + dvd? ( + >=media-libs/libdvdread-4.1.3 + dvdnav? ( >=media-libs/libdvdnav-4.1.3 ) + ) + encode? ( + !twolame? ( toolame? ( media-sound/toolame ) ) + twolame? ( media-sound/twolame ) + faac? ( !bindist? ( media-libs/faac ) ) + mp3? ( media-sound/lame ) + x264? ( >=media-libs/x264-0.0.20100423 ) + xvid? ( media-libs/xvid ) + ) + esd? ( media-sound/esound ) + enca? ( app-i18n/enca ) + faad? ( media-libs/faad2 ) + gif? ( media-libs/giflib ) + gsm? ( media-sound/gsm ) + iconv? ( virtual/libiconv ) + jack? ( media-sound/jack-audio-connection-kit ) + jpeg? ( virtual/jpeg ) + jpeg2k? ( media-libs/openjpeg ) + ladspa? ( media-libs/ladspa-sdk ) + libcaca? ( media-libs/libcaca ) + libmpeg2? ( media-libs/libmpeg2 ) + lirc? ( app-misc/lirc ) + live? ( media-plugins/live ) + lzo? ( >=dev-libs/lzo-2 ) + mad? ( media-libs/libmad ) + mng? ( media-libs/libmng ) + mpg123? ( media-sound/mpg123 ) + nas? ( media-libs/nas ) + nut? ( >=media-libs/libnut-661 ) + openal? ( media-libs/openal ) + png? ( media-libs/libpng ) + pnm? ( media-libs/netpbm ) + pulseaudio? ( media-sound/pulseaudio ) + rar? ( + || ( + app-arch/unrar + app-arch/rar + ) + ) + rtmp? ( media-video/rtmpdump ) + samba? ( net-fs/samba ) + schroedinger? ( media-libs/schroedinger ) + sdl? ( media-libs/libsdl ) + speex? ( media-libs/speex ) + theora? ( media-libs/libtheora[encode?] ) + truetype? ( ${FONT_RDEPS} ) + vaapi? ( x11-libs/libva ) + vorbis? ( media-libs/libvorbis ) + vpx? ( media-libs/libvpx ) + xanim? ( media-video/xanim ) +" + +X_DEPS=" + x11-proto/videoproto + x11-proto/xf86vidmodeproto +" +ASM_DEP="dev-lang/yasm" +DEPEND="${RDEPEND} + dev-util/pkgconfig + X? ( + ${X_DEPS} + dga? ( x11-proto/xf86dgaproto ) + dxr3? ( media-video/em8300-libraries ) + xinerama? ( x11-proto/xineramaproto ) + xscreensaver? ( x11-proto/scrnsaverproto ) + ) + amd64? ( ${ASM_DEP} ) + doc? ( + dev-libs/libxslt app-text/docbook-xml-dtd + app-text/docbook-xsl-stylesheets + ) + x86? ( ${ASM_DEP} ) + x86-fbsd? ( ${ASM_DEP} ) +" + +SLOT="0" +LICENSE="GPL-2" +if [[ ${PV} != *9999* ]]; then + KEYWORDS="~alpha ~amd64 ~arm ~hppa ~ia64 ~ppc ~ppc64 ~sparc ~x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris" +else + KEYWORDS="" +fi + +PATCHES=( "${FILESDIR}"/vaapi-take2/*.patch ) + +pkg_setup() { + if [[ ${PV} == *9999* ]]; then + elog + elog "This is a live ebuild which installs the latest from upstream's" + elog "subversion repository, and is unsupported by Gentoo." + elog "Everything but bugs in the ebuild itself will be ignored." + elog + fi + + if use cpudetection; then + ewarn + ewarn "You've enabled the cpudetection flag. This feature is" + ewarn "included mainly for people who want to use the same" + ewarn "binary on another system with a different CPU architecture." + ewarn "MPlayer will already detect your CPU settings by default at" + ewarn "buildtime; this flag is used for runtime detection." + ewarn "You won't need this turned on if you are only building" + ewarn "mplayer for this system. Also, if your compile fails, try" + ewarn "disabling this use flag." + fi + + if use custom-cpuopts; then + ewarn + ewarn "You are using the custom-cpuopts flag which will" + ewarn "specifically allow you to enable / disable certain" + ewarn "CPU optimizations." + ewarn + ewarn "Most desktop users won't need this functionality, but it" + ewarn "is included for corner cases like cross-compiling and" + ewarn "certain profiles. If unsure, disable this flag and MPlayer" + ewarn "will automatically detect and use your available CPU" + ewarn "optimizations." + ewarn + ewarn "Using this flag means your build is unsupported, so" + ewarn "please make sure your CPU optimization use flags (3dnow" + ewarn "3dnowext mmx mmxext sse sse2 ssse3) are properly set." + fi +} + +src_unpack() { + if [[ ${PV} = *9999* ]]; then + subversion_src_unpack + + cd "${WORKDIR}" + else + unpack ${A} + fi + + if ! use truetype; then + unpack font-arial-iso-8859-1.tar.bz2 \ + font-arial-iso-8859-2.tar.bz2 \ + font-arial-cp1250.tar.bz2 + fi +} + +src_prepare() { + if [[ ${PV} = *9999* ]]; then + # Set SVN version manually + subversion_wc_info + sed -i -e "s/UNKNOWN/${ESVN_WC_REVISION}/" "${S}/version.sh" || die + else + # Set version # + sed -i -e "s/UNKNOWN/${MPLAYER_REVISION}/" "${S}/version.sh" || die + fi + + # fix path to bash executable in configure scripts + sed -i -e "1c\#!${EPREFIX}/bin/bash" configure version.sh || die + + base_src_prepare +} + +src_configure() { + local myconf="" + local uses i + + # set LINGUAS + [[ -n $LINGUAS ]] && LINGUAS="${LINGUAS/da/dk}" + + # mplayer ebuild uses "use foo || --disable-foo" to forcibly disable + # compilation in almost every situation. The reason for this is + # because if --enable is used, it will force the build of that option, + # regardless of whether the dependency is available or not. + + ################### + #Optional features# + ################### + # disable svga since we don't want it + # disable arts since we don't have kde3 + # always disable internal ass + myconf+=" + --disable-svga --disable-svgalib_helper + --disable-ass-internal + --disable-arts + --disable-kai + $(use_enable network networking) + $(use_enable joystick) + " + uses="ass bl bluray enca ftp rtc" # nemesi <- not working with in-tree ebuild + myconf+=" --disable-nemesi" # nemesi automagic disable + for i in ${uses}; do + use ${i} || myconf+=" --disable-${i}" + done + use bidi || myconf+=" --disable-fribidi" + use ipv6 || myconf+=" --disable-inet6" + use nut || myconf+=" --disable-libnut" + use rar || myconf+=" --disable-unrarexec" + use samba || myconf+=" --disable-smb" + if ! use lirc; then + myconf+=" + --disable-lirc + --disable-lircc + --disable-apple-ir + " + fi + + # libcdio support: prefer libcdio over cdparanoia + # don't check for cddb w/cdio + if use cdio; then + myconf+=" --disable-cdparanoia" + else + myconf+=" --disable-libcdio" + use cdparanoia || myconf+=" --disable-cdparanoia" + use cddb || myconf+=" --disable-cddb" + fi + + ################################ + # DVD read, navigation support # + ################################ + # + # dvdread - accessing a DVD + # dvdnav - navigation of menus + # + # use external libdvdcss, dvdread and dvdnav + myconf+=" --disable-dvdread-internal --disable-libdvdcss-internal" + + if use dvd; then + use dvdnav || myconf+=" --disable-dvdnav" + else + myconf+=" + --disable-dvdnav + --disable-dvdread + " + fi + + ############# + # Subtitles # + ############# + # + # SRT/ASS/SSA (subtitles) requires freetype support + # freetype support requires iconv + # iconv optionally can use unicode + if ! use ass && ! use truetype; then + myconf+=" --disable-freetype" + if ! use iconv; then + myconf+=" + --disable-iconv + --charset=noconv + " + fi + fi + use iconv && use unicode && myconf+=" --charset=UTF-8" + + ##################################### + # DVB / Video4Linux / Radio support # + ##################################### + myconf+=" --disable-tv-bsdbt848" + # broken upstream, won't work with recent kernels + myconf+=" --disable-ivtv" + if { use dvb || use v4l || use v4l2 || use pvr || use radio; }; then + use dvb || myconf+=" --disable-dvb" + use pvr || myconf+=" --disable-pvr" + use v4l || myconf+=" --disable-tv-v4l1" + use v4l2 || myconf+=" --disable-tv-v4l2" + if use radio && { use dvb || use v4l || use v4l2; }; then + myconf+=" + --enable-radio + $(use_enable encode radio-capture) + " + else + myconf+=" + --disable-radio-v4l2 + --disable-radio-bsdbt848 + " + fi + else + myconf+=" + --disable-tv + --disable-tv-v4l1 + --disable-tv-v4l2 + --disable-radio + --disable-radio-v4l2 + --disable-radio-bsdbt848 + --disable-dvb + --disable-v4l2 + --disable-pvr" + fi + + ########## + # Codecs # + ########## + myconf+=" --disable-musepack" # Use internal musepack codecs for SV7 and SV8 support + myconf+=" --disable-faad-internal" # always use system media-libs/faad2 + myconf+=" --disable-libmpeg2-internal" # always use system media-libs/libmpeg2 + use dirac || myconf+=" --disable-libdirac-lavc" + use dts || myconf+=" --disable-libdca" + if ! use mp3; then + myconf+=" + --disable-mp3lame + --disable-mp3lame-lavc + --disable-mp3lib + " + fi + uses="a52 bs2b dv gsm lzo rtmp" + for i in ${uses}; do + use ${i} || myconf+=" --disable-lib${i}" + done + use schroedinger || myconf+=" --disable-libschroedinger-lavc" + # Disable opencore-amr with bindist + # https://bugs.gentoo.org/show_bug.cgi?id=299405#c6 + { use amr && use !bindist ; } || myconf+=" --disable-libopencore_amrnb --disable-libopencore_amrwb" + + uses="faad gif jpeg libmpeg2 live mad mng mpg123 png pnm speex tga theora xanim" + for i in ${uses}; do + use ${i} || myconf+=" --disable-${i}" + done + use jpeg2k || myconf+=" --disable-libopenjpeg" + if use vorbis || use tremor; then + use tremor || myconf+=" --disable-tremor-internal" + use vorbis || myconf+=" --disable-libvorbis" + else + myconf+=" + --disable-tremor-internal + --disable-tremor + --disable-libvorbis + " + fi + use vaapi && myconf+=" --enable-vaapi" + use vpx || myconf+=" --disable-libvpx-lavc" + # Encoding + uses="faac x264 xvid toolame twolame" + if use encode; then + for i in ${uses}; do + use ${i} || myconf+=" --disable-${i}" + done + use faac || myconf+=" --disable-faac-lavc" + if use bindist && use faac; then + ewarn "faac is nonfree and cannot be distributed; disabling faac support." + myconf+=" --disable-faac --disable-faac-lavc" + fi + else + myconf+=" --disable-mencoder" + myconf+=" --disable-faac-lavc" + for i in ${uses}; do + myconf+=" --disable-${i}" + use ${i} && elog "Useflag \"${i}\" require \"encode\" useflag enabled to work." + done + fi + + ################# + # Binary codecs # + ################# + # bug 213836 + if ! use x86 || ! use win32codecs; then + use quicktime || myconf+=" --disable-qtx" + fi + + ###################### + # RealPlayer support # + ###################### + # Realplayer support shows up in four places: + # - libavcodec (internal) + # - win32codecs + # - realcodecs (win32codecs libs) + # - realcodecs (realplayer libs) + + # internal + use real || myconf+=" --disable-real" + + # Real binary codec support only available on x86, amd64 + if use real; then + use x86 && myconf+=" --codecsdir=/opt/RealPlayer/codecs" + use amd64 && myconf+=" --codecsdir=/usr/$(get_libdir)/codecs" + elif ! use bindist; then + myconf+=" $(use_enable win32codecs win32dll)" + fi + + ################ + # Video Output # + ################ + uses="directfb md5sum sdl" + for i in ${uses}; do + use ${i} || myconf+=" --disable-${i}" + done + use aalib || myconf+=" --disable-aa" + use fbcon || myconf+=" --disable-fbdev" + use fbcon && use video_cards_s3virge && myconf+=" --enable-s3fb" + use libcaca || myconf+=" --disable-caca" + use zoran || myconf+=" --disable-zr" + + if ! use kernel_linux || ! use video_cards_mga; then + myconf+=" --disable-mga --disable-xmga" + fi + + if use video_cards_tdfx; then + myconf+=" + $(use_enable video_cards_tdfx tdfxvid) + $(use_enable fbcon tdfxfb) + " + else + myconf+=" + --disable-3dfx + --disable-tdfxvid + --disable-tdfxfb + " + fi + + # sun card, disable by default, see bug #258729 + myconf+=" --disable-xvr100" + + ################ + # Audio Output # + ################ + uses="alsa esd jack ladspa nas openal" + for i in ${uses}; do + use ${i} || myconf+=" --disable-${i}" + done + use pulseaudio || myconf+=" --disable-pulse" + if ! use radio; then + use oss || myconf+=" --disable-ossaudio" + fi + + #################### + # Advanced Options # + #################### + # Platform specific flags, hardcoded on amd64 (see below) + if use cpudetection; then + myconf+=" --enable-runtime-cpudetection" + fi + + # Turning off CPU optimizations usually will break the build. + # However, this use flag, if enabled, will allow users to completely + # specify which ones to use. If disabled, mplayer will automatically + # enable all CPU optimizations that the host build supports. + if use custom-cpuopts; then + uses="3dnow 3dnowext altivec mmx mmxext shm sse sse2 ssse3" + for i in ${uses}; do + myconf+=" $(use_enable ${i})" + done + fi + + use debug && myconf+=" --enable-debug=3" + + if use x86 && gcc-specs-pie; then + filter-flags -fPIC -fPIE + append-ldflags -nopie + fi + + is-flag -O? || append-flags -O2 + if use x86 || use x86-fbsd; then + use debug || append-flags -fomit-frame-pointer + fi + + # workaround bug, x86 just has too few registers, see c.f. + # http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=402950#44 + # and 32b osx, bug 329861 + [[ ${CHOST} == i?86-*solaris* || ${CHOST} == i?86-*darwin* ]] && append-flags -fomit-frame-pointer + + ########################### + # X enabled configuration # + ########################### + myconf+=" --disable-gui" + if use X; then + uses="dxr3 ggi xinerama" + for i in ${uses}; do + use ${i} || myconf+=" --disable-${i}" + done + use dga || myconf+=" --disable-dga1 --disable-dga2" + use opengl || myconf+=" --disable-gl" + use osdmenu && myconf+=" --enable-menu" + use vdpau || myconf+=" --disable-vdpau" + use video_cards_vesa || myconf+=" --disable-vesa" + use vidix || myconf+=" --disable-vidix --disable-vidix-pcidb" + use xscreensaver || myconf+=" --disable-xss" + + if use xv; then + if use xvmc; then + myconf+=" --enable-xvmc --with-xvmclib=XvMCW" + else + myconf+=" --disable-xvmc" + fi + else + myconf+=" + --disable-xv + --disable-xvmc + " + use xvmc && elog "Disabling xvmc because it requires \"xv\" useflag enabled." + fi + else + myconf+=" + --disable-dga1 + --disable-dga2 + --disable-dxr3 + --disable-ggi + --disable-gl + --disable-vdpau + --disable-vidix + --disable-vidix-pcidb + --disable-xinerama + --disable-xss + --disable-xv + --disable-xvmc + --disable-x11 + " + uses="dga dxr3 ggi opengl osdmenu vdpau vidix xinerama xscreensaver xv" + for i in ${uses}; do + use ${i} && elog "Useflag \"${i}\" require \"X\" useflag enabled to work." + done + fi + + ############################ + # OSX (aqua) configuration # + ############################ + if use aqua; then + myconf+=" + --enable-macosx-finder + --enable-macosx-bundle + " + fi + + ################### + # External FFmpeg # + ################### + if [[ ${PV} == *9999* ]]; then + use external-ffmpeg && myconf+=" --disable-ffmpeg_a" + fi + + myconf="--cc=$(tc-getCC) + --host-cc=$(tc-getBUILD_CC) + --prefix=${EPREFIX}/usr + --confdir=${EPREFIX}/etc/mplayer + --datadir=${EPREFIX}/usr/share/mplayer + --libdir=${EPREFIX}/usr/$(get_libdir) + ${myconf}" + + CFLAGS="${CFLAGS}" ./configure ${myconf} || die "configure died" +} + +src_compile() { + base_src_compile + # Build only user-requested docs if they're available. + if use doc ; then + # select available languages from $LINGUAS + LINGUAS=${LINGUAS/zh/zh_CN} + local ALLOWED_LINGUAS="cs de en es fr hu it pl ru zh_CN" + local BUILT_DOCS="" + for i in ${LINGUAS} ; do + hasq ${i} ${ALLOWED_LINGUAS} && BUILT_DOCS+=" ${i}" + done + if [[ -z $BUILT_DOCS ]]; then + emake -j1 -C DOCS/xml html-chunked || die "Failed to generate html docs" + else + for i in ${BUILT_DOCS}; do + emake -j1 -C DOCS/xml html-chunked-${i} || die "Failed to generate html docs for ${i}" + done + fi + fi +} + +src_install() { + local i + + emake prefix="${ED}/usr" \ + BINDIR="${ED}/usr/bin" \ + LIBDIR="${ED}/usr/$(get_libdir)" \ + CONFDIR="${ED}/etc/mplayer" \ + DATADIR="${ED}/usr/share/mplayer" \ + MANDIR="${ED}/usr/share/man" \ + INSTALLSTRIP="" \ + install || die "emake install failed" + + dodoc AUTHORS Changelog Copyright README etc/codecs.conf || die + + docinto tech/ + dodoc DOCS/tech/{*.txt,MAINTAINERS,mpsub.sub,playtree,TODO,wishlist} || die + docinto TOOLS/ + dodoc TOOLS/* || die + if use real; then + docinto tech/realcodecs/ + dodoc DOCS/tech/realcodecs/* || die + docinto TOOLS/realcodecs/ + dodoc TOOLS/realcodecs/* || die + fi + docinto tech/mirrors/ + dodoc DOCS/tech/mirrors/* || die + + if use doc; then + docinto html/ + dohtml -r "${S}"/DOCS/HTML/* || die + fi + + if ! use ass && ! use truetype; then + dodir /usr/share/mplayer/fonts + # Do this generic, as the mplayer people like to change the structure + # of their zips ... + for i in $(find "${WORKDIR}/" -type d -name 'font-arial-*'); do + cp -pPR "${i}" "${ED}/usr/share/mplayer/fonts" + done + # Fix the font symlink ... + rm -rf "${ED}/usr/share/mplayer/font" + dosym fonts/font-arial-14-iso-8859-1 /usr/share/mplayer/font + fi + + insinto /etc/mplayer + newins "${S}/etc/example.conf" mplayer.conf || die + doins "${S}/etc/input.conf" || die + if use osdmenu; then + doins "${S}/etc/menu.conf" || die + fi + + if use ass || use truetype; then + cat >> "${ED}/etc/mplayer/mplayer.conf" << _EOF_ +fontconfig=1 +subfont-osd-scale=4 +subfont-text-scale=3 +_EOF_ + fi + + # bug 256203 + if use rar; then + cat >> "${ED}/etc/mplayer/mplayer.conf" << _EOF_ +unrarexec=${EPREFIX}/usr/bin/unrar +_EOF_ + fi + + dosym ../../../etc/mplayer/mplayer.conf /usr/share/mplayer/mplayer.conf + newbin "${S}/TOOLS/midentify.sh" midentify || die +} + +pkg_preinst() { + [[ -d ${EROOT}/usr/share/mplayer/Skin/default ]] && \ + rm -rf "${EROOT}/usr/share/mplayer/Skin/default" +} + +pkg_postrm() { + # Cleanup stale symlinks + [ -L "${EROOT}/usr/share/mplayer/font" -a \ + ! -e "${EROOT}/usr/share/mplayer/font" ] && \ + rm -f "${EROOT}/usr/share/mplayer/font" + + [ -L "${EROOT}/usr/share/mplayer/subfont.ttf" -a \ + ! -e "${EROOT}/usr/share/mplayer/subfont.ttf" ] && \ + rm -f "${EROOT}/usr/share/mplayer/subfont.ttf" +} diff --git a/net-misc/mimms/Manifest b/net-misc/mimms/Manifest deleted file mode 100644 index 83f7ebf..0000000 --- a/net-misc/mimms/Manifest +++ /dev/null @@ -1,2 +0,0 @@ -DIST mimms-3.2.1.tar.bz2 18224 RMD160 669d5d80ae9bd318bf98c032197fa6980622182e SHA1 279eee76dd4032cd2c1dddf1d49292a952c57b80 SHA256 92cd3e1800d8bd637268274196f6baec0d95aa8e709714093dd96ba8893c2354 -EBUILD mimms-3.2.1.ebuild 560 RMD160 cc60c30e0eccb128a9b8029cdc0680eee0084bfa SHA1 dc55dde5b493c3b9895b0fd373938c20b40fd7e6 SHA256 8abb64c05636a2c6c1884a4d3838ed8b89d7e4496026209db5d134157927d4e8 diff --git a/net-misc/mimms/mimms-3.2.1.ebuild b/net-misc/mimms/mimms-3.2.1.ebuild deleted file mode 100644 index b54f45a..0000000 --- a/net-misc/mimms/mimms-3.2.1.ebuild +++ /dev/null @@ -1,25 +0,0 @@ -# Copyright 1999-2010 Gentoo Foundation -# Distributed under the terms of the GNU General Public License v2 -# $Header: $ - -EAPI="2" -SUPPORT_PYTHON_ABIS="1" - -NEED_PYTHON="2.5" -inherit distutils - -DESCRIPTION="mms stream downloader that uses libmms" -HOMEPAGE="http://savannah.nongnu.org/projects/mimms/" -SRC_URI="http://savannah.nongnu.org/download/${PN}/${P}.tar.bz2" - -LICENSE="GPL-3" -SLOT="0" -KEYWORDS="~amd64 ~x86" -IUSE="" - -DEPEND="media-libs/libmms