<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
<pkgmetadata>
  <herd>video</herd>
  <maintainer>
    <email>media-video@gentoo.org</email>
  </maintainer>
  <use>
    <flag name="3dnowext">
      Enable manually-optimised routines using the AMD 3DNow!Ex SIMD
      instruction set, present in modern AMD CPUs.  (Check for
      3dnowext in /proc/cpuinfo to know whether your CPU supports it).
    </flag>
    <flag name="aacplus">AAC+ encoding via <pkg>media-libs/libaacplus</pkg>.</flag>
    <flag name="amr">Enables Adaptive Multi-Rate Audio support</flag>
    <flag name="avx">Adds support for Advanced Vector Extensions instructions (Intel Sandy Bridge, AMD Bulldozer and later chips)</flag>
	<flag name="bindist">Enforces license compatibility constraints via REQUIRED_USE.</flag>
	<flag name="bluray">Enable playback of Blu-ray filesystems</flag>
    <flag name="cdio">Enables audio CD grabbing with <pkg>dev-libs/libcdio</pkg>.</flag>
	<flag name="celt">Adds Xiph CELT audio decoding support via <pkg>media-libs/celt</pkg></flag>
    <flag name="cpudetection">Enables runtime CPU detection (useful for bindist, compatibility on other CPUs)</flag>
    <flag name="dirac">Enable Dirac video support (an advanced royalty-free video compression format) via the reference library: dirac.</flag>
	<flag name="faac">Use external faac library for AAC encoding</flag>
	<flag name="fdk">Use external fdk-aac library for AAC encoding</flag>
	<flag name="flite">Adds a text-to-speech filter based on <pkg>app-accessibility/flite</pkg>.</flag>
	<flag name="frei0r">Enable frei0r wrapping in libavfilter</flag>
    <flag name="hardcoded-tables">Use pre-calculated tables rather than calculating them on the fly.</flag>
	<flag name="iec61883"> Support for FireWire DV/HDV input device using <pkg>media-libs/libiec61883</pkg>.</flag>
	<flag name="libsoxr">Enables audio resampling through <pkg>media-libs/soxr</pkg>.</flag>
	<flag name="libv4l">Uses <pkg>media-libs/libv4l</pkg> for video4linux instead of direct calls. Adds support for more devices via the userspace library.</flag>
    <flag name="mmxext">Enables mmx2 support</flag>
    <flag name="network">Enables network streaming support</flag>
	<flag name="openssl">Enables <pkg>dev-libs/openssl</pkg> support. Adds support for encrypted network protocols (TLS/HTTPS).</flag>
	<flag name="opus">Adds (decoding) support for the Opus codec via <pkg>media-libs/opus</pkg>.</flag>
    <flag name="pic">Force shared libraries to be built as PIC (this is slower)</flag>
    <flag name="rtmp">Enable Real Time Messaging Protocol using librtmp</flag>
    <flag name="schroedinger">Enable Dirac video support (an advanced royalty-free video compression format) via libschroedinger (high-speed implementation in C of the Dirac codec).</flag>
    <flag name="ssse3">Faster floating point optimization for SSSE3 capable chips (Intel Core 2 and later chips)</flag>
	<flag name="twolame">Enables MP2 encoding via <pkg>media-sound/twolame</pkg> as an alternative to the internal encoder.</flag>
	<flag name="vaapi">Enables VAAPI (Video Acceleration API) for hardware decoding</flag>
	<flag name="vis"> Adds support for SIMD optimizations for UltraSPARC processors.</flag>
	<flag name="vpx">Enables vp8 codec support using libvpx: Decoding vp8 does not require this to be enabled but libvpx can also be used for decoding; encoding vp8 requires this useflag to be enabled though.</flag>
  </use>
</pkgmetadata>
