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	a108f00cccac414097bcbbbb5de01762	libtool	eba09ed440f2692f73024ff3621a1f4b	multilib	3bf24e6abb9b76d9f6c20600f0b716bf	toolchain-funcs	48b38a216afb92db6314d6c3187abea3
_md5_=3ed13ec266e4216c7b7159326d31c30d
