DEFINED_PHASES=configure install prepare
DEPEND=x11-libs/libX11 dri? ( x11-libs/libXext ) !=x11-drivers/nvidia-drivers-180* !=x11-drivers/nvidia-drivers-185* !=x11-drivers/nvidia-drivers-190* virtual/pkgconfig doc? ( app-doc/doxygen media-gfx/graphviz virtual/latex-base ) dri? ( >=x11-proto/dri2proto-2.2 )
DESCRIPTION=VDPAU wrapper and trace libraries
EAPI=4
HOMEPAGE=http://www.freedesktop.org/wiki/Software/VDPAU
IUSE=doc dri
KEYWORDS=alpha amd64 x86 ~amd64-fbsd ~x86-fbsd
LICENSE=MIT
RDEPEND=x11-libs/libX11 dri? ( x11-libs/libXext ) !=x11-drivers/nvidia-drivers-180* !=x11-drivers/nvidia-drivers-185* !=x11-drivers/nvidia-drivers-190*
SLOT=0
SRC_URI=http://people.freedesktop.org/~aplattner/vdpau/libvdpau-0.5.tar.gz
_eclasses_=eutils	06133990e861be0fe60c2b428fd025d9	libtool	52d0e17251d04645ffaa61bfdd858944	multilib	3972ca401cf7dbb430df9995f5d8d580	toolchain-funcs	6198c04daba0e1307bd844df7d37f423
_md5_=3ed13ec266e4216c7b7159326d31c30d
