Merge commit '4e08c821106fc1d6d358864abf0d8488b12f38c6'
authorMichael Niedermayer <michaelni@gmx.at>
Thu, 19 Feb 2015 19:52:29 +0000 (20:52 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Thu, 19 Feb 2015 20:12:04 +0000 (21:12 +0100)
* commit '4e08c821106fc1d6d358864abf0d8488b12f38c6':
  lavc: add an Intel libmfx-based H.264 decoder

Conflicts:
configure
libavcodec/Makefile
libavcodec/allcodecs.c
libavcodec/version.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
Changelog
configure
libavcodec/Makefile
libavcodec/allcodecs.c
libavcodec/qsv.c
libavcodec/qsv.h
libavcodec/qsv_api.c
libavcodec/qsv_h264.c
libavcodec/qsv_internal.h
libavcodec/version.h

diff --cc Changelog
+++ b/Changelog
@@@ -2,351 -2,162 +2,352 @@@ Entries are sorted chronologically fro
  releases are sorted from youngest to oldest.
  
  version <next>:
 -- aliases and defaults for Ogg subtypes (opus, spx)
 -- HEVC/H.265 RTP payload format (draft v6) packetizer and depacketizer
 -- avplay now exits by default at the end of playback
 -- XCB-based screen-grabber
 -- creating DASH compatible fragmented MP4, MPEG-DASH segmenting muxer
 -- H.261 RTP payload format (RFC 4587) depacketizer and experimental packetizer
 +- nvenc encoder
 +- 10bit spp filter
 +- colorlevels filter
 +- RIFX format for *.wav files
  - RTP/mpegts muxer
 -- VP8 in Ogg demuxing
 +- non continuous cache protocol support
 +- tblend filter
 +- cropdetect support for non 8bpp, absolute (if limit >= 1) and relative (if limit < 1.0) threshold
 +- Camellia symmetric block cipher
  - OpenH264 encoder wrapper
 +- VOC seeking support
 +- Closed caption Decoder
 +- fspp, uspp, pp7 MPlayer postprocessing filters ported to native filters
 +- showpalette filter
 +- Twofish symmetric block cipher
  - Support DNx100 (960x720@8)
 +- eq2 filter ported from libmpcodecs as eq filter
 +- removed libmpcodecs
 +- Changed default DNxHD colour range in QuickTime .mov derivatives to mpeg range
 +- ported softpulldown filter from libmpcodecs as repeatfields filter
 +- dcshift filter
 +- RTP parser for loss tolerant payload format for MP3 audio (RFC 5219)
 +- RTP parser for AC3 payload format (RFC 4184)
 +- palettegen and paletteuse filters
 +- VP9 RTP payload format (draft 0) experimental depacketizer
 +- DV RTP payload format (RFC 6469) depacketizer
  - DXVA2-accelerated HEVC decoding
  - AAC ELD 480 decoding
+ - Intel QSV-accelerated H.264 decoding
  
 +version 2.5:
 +- HEVC/H.265 RTP payload format (draft v6) packetizer
 +- SUP/PGS subtitle demuxer
 +- ffprobe -show_pixel_formats option
 +- CAST128 symmetric block cipher, ECB mode
 +- STL subtitle demuxer and decoder
 +- libutvideo YUV 4:2:2 10bit support
 +- XCB-based screen-grabber
 +- UDP-Lite support (RFC 3828)
 +- xBR scaling filter
 +- AVFoundation screen capturing support
 +- ffserver supports codec private options
 +- creating DASH compatible fragmented MP4, MPEG-DASH segmenting muxer
 +- WebP muxer with animated WebP support
 +- zygoaudio decoding support
 +- APNG demuxer
 +- postproc visualization support
  
 -version 11:
 -- libx265 encoder
 +
 +version 2.4:
 +- Icecast protocol
 +- ported lenscorrection filter from frei0r filter
 +- large optimizations in dctdnoiz to make it usable
 +- ICY metadata are now requested by default with the HTTP protocol
 +- support for using metadata in stream specifiers in fftools
 +- LZMA compression support in TIFF decoder
 +- H.261 RTP payload format (RFC 4587) depacketizer and experimental packetizer
 +- HEVC/H.265 RTP payload format (draft v6) depacketizer
 +- added codecview filter to visualize information exported by some codecs
 +- Matroska 3D support thorugh side data
 +- HTML generation using texi2html is deprecated in favor of makeinfo/texi2any
 +- silenceremove filter
 +
 +
 +version 2.3:
 +- AC3 fixed-point decoding
  - shuffleplanes filter
 +- subfile protocol
 +- Phantom Cine demuxer
  - replaygain data export
 +- VP7 video decoder
  - Alias PIX image encoder and decoder
 -- BRender PIX image decoder
 -- Amazing Studio PAF playback support
 -- XBM decoder
 -- BMP standalone parser
 -- OpenEXR image decoder
 -- support encoding and decoding 4-channel SGI images
 +- Improvements to the BRender PIX image decoder
 +- Improvements to the XBM decoder
 +- QTKit input device
 +- improvements to OpenEXR image decoder
  - support decoding 16-bit RLE SGI images
 -- VP7 video decoder
 -- LucasArts SMUSH SANM video decoder
 -- LucasArts SMUSH VIMA audio decoder (ADPCM)
 -- LucasArts SMUSH demuxer
 -- MP2 encoding via TwoLAME
 -- asettb filter
 -- Silicon Graphics RLE 8-bit video decoder
 -- Silicon Graphics Motion Video Compressor 1 & 2 decoder
 -- Silicon Graphics Movie demuxer
 +- GDI screen grabbing for Windows
 +- alternative rendition support for HTTP Live Streaming
 +- AVFoundation input device
 +- Direct Stream Digital (DSD) decoder
 +- Magic Lantern Video (MLV) demuxer
  - On2 AVC (Audio for Video) decoder
 -- support for decoding through DXVA2 in avconv
 +- support for decoding through DXVA2 in ffmpeg
  - libbs2b-based stereo-to-binaural audio filter
 +- libx264 reference frames count limiting depending on level
  - native Opus decoder
  - display matrix export and rotation API
 -- drop avserver, it was unmaintained for years and largely broken
 -- Icecast protocol
 -- request Icecast metadata by default
 -- support for using metadata in stream specifiers in avtools
 -- Matroska 3D support
 +- WebVTT encoder
 +- showcqt multimedia filter
 +- zoompan filter
 +- signalstats filter
 +- hqx filter (hq2x, hq3x, hq4x)
 +- flanger filter
 +- Image format auto-detection
 +- LRC demuxer and muxer
 +- Samba protocol (via libsmbclient)
 +- WebM DASH Manifest muxer
 +- libfribidi support in drawtext
  
  
 -version 10:
 -- av_strnstr
 -- support ID3v2 tags in ASF files
 +version 2.2:
 +
 +- HNM version 4 demuxer and video decoder
 +- Live HDS muxer
 +- setsar/setdar filters now support variables in ratio expressions
 +- elbg filter
 +- string validation in ffprobe
 +- support for decoding through VDPAU in ffmpeg (the -hwaccel option)
 +- complete Voxware MetaSound decoder
 +- remove mp3_header_compress bitstream filter
 +- Windows resource files for shared libraries
 +- aeval filter
 +- stereoscopic 3d metadata handling
 +- WebP encoding via libwebp
 +- ATRAC3+ decoder
 +- VP8 in Ogg demuxing
 +- side & metadata support in NUT
 +- framepack filter
 +- XYZ12 rawvideo support in NUT
 +- Exif metadata support in WebP decoder
 +- OpenGL device
 +- Use metadata_header_padding to control padding in ID3 tags (currently used in
 +  MP3, AIFF, and OMA files), FLAC header, and the AVI "junk" block.
 +- Mirillis FIC video decoder
 +- Support DNx444
 +- libx265 encoder
 +- dejudder filter
 +- Autodetect VDA like all other hardware accelerations
 +- aliases and defaults for Ogg subtypes (opus, spx)
 +
 +
 +version 2.1:
 +
 +- aecho filter
 +- perspective filter ported from libmpcodecs
 +- ffprobe -show_programs option
 +- compand filter
 +- RTMP seek support
 +- when transcoding with ffmpeg (i.e. not streamcopying), -ss is now accurate
 +  even when used as an input option. Previous behavior can be restored with
 +  the -noaccurate_seek option.
 +- ffmpeg -t option can now be used for inputs, to limit the duration of
 +  data read from an input file
 +- incomplete Voxware MetaSound decoder
 +- read EXIF metadata from JPEG
 +- DVB teletext decoder
 +- phase filter ported from libmpcodecs
 +- w3fdif filter
 +- Opus support in Matroska
 +- FFV1 version 1.3 is stable and no longer experimental
 +- FFV1: YUVA(444,422,420) 9, 10 and 16 bit support
 +- changed DTS stream id in lavf mpeg ps muxer from 0x8a to 0x88, to be
 +  more consistent with other muxers.
 +- adelay filter
 +- pullup filter ported from libmpcodecs
 +- ffprobe -read_intervals option
 +- Lossless and alpha support for WebP decoder
 +- Error Resilient AAC syntax (ER AAC LC) decoding
 +- Low Delay AAC (ER AAC LD) decoding
 +- mux chapters in ASF files
 +- SFTP protocol (via libssh)
 +- libx264: add ability to encode in YUVJ422P and YUVJ444P
 +- Fraps: use BT.709 colorspace by default for yuv, as reference fraps decoder does
 +- make decoding alpha optional for prores, ffv1 and vp6 by setting
 +  the skip_alpha flag.
 +- ladspa wrapper filter
 +- native VP9 decoder
 +- dpx parser
 +- max_error_rate parameter in ffmpeg
 +- PulseAudio output device
 +- ReplayGain scanner
 +- Enhanced Low Delay AAC (ER AAC ELD) decoding (no LD SBR support)
 +- Linux framebuffer output device
 +- HEVC decoder
 +- raw HEVC, HEVC in MOV/MP4, HEVC in Matroska, HEVC in MPEG-TS demuxing
 +- mergeplanes filter
 +
 +
 +version 2.0:
 +
 +- curves filter
  - reference-counting for AVFrame and AVPacket data
 -- avconv now fails when input options are used for output file
 +- ffmpeg now fails when input options are used for output file
    or vice versa
 -- avconv options -filter_script and -filter_complex_script, which allow a
 +- support for Monkey's Audio versions from 3.93
 +- perms and aperms filters
 +- audio filtering support in ffplay
 +- 10% faster aac encoding on x86 and MIPS
 +- sine audio filter source
 +- WebP demuxing and decoding support
 +- ffmpeg options -filter_script and -filter_complex_script, which allow a
    filtergraph description to be read from a file
 +- OpenCL support
 +- audio phaser filter
 +- separatefields filter
 +- libquvi demuxer
  - uniform options syntax across all filters
 +- telecine filter
  - interlace filter
 -- JPEG 2000 decoder
 -- asetpts filter (same as setpts, but for audio)
 +- smptehdbars source
 +- inverse telecine filters (fieldmatch and decimate)
 +- colorbalance filter
 +- colorchannelmixer filter
 +- The matroska demuxer can now output proper verbatim ASS packets. It will
 +  become the default at the next libavformat major bump.
 +- decent native animated GIF encoding
 +- asetrate filter
 +- interleave filter
 +- timeline editing with filters
 +- vidstabdetect and vidstabtransform filters for video stabilization using
 +  the vid.stab library
 +- astats filter
  - trim and atrim filters
 -- avconv -t and -ss (output-only) options are now sample-accurate when
 +- ffmpeg -t and -ss (output-only) options are now sample-accurate when
    transcoding audio
  - Matroska muxer can now put the index at the beginning of the file.
 -- avconv -deinterlace option removed, the yadif filter should be used instead
 +- extractplanes filter
 +- avectorscope filter
 +- ADPCM DTK decoder
 +- ADP demuxer
 +- RSD demuxer
 +- RedSpark demuxer
 +- ADPCM IMA Radical decoder
 +- zmq filters
 +- DCT denoiser filter (dctdnoiz)
 +- Wavelet denoiser filter ported from libmpcodecs as owdenoise (formerly "ow")
  - Apple Intermediate Codec decoder
  - Escape 130 video decoder
 +- FTP protocol support
 +- V4L2 output device
 +- 3D LUT filter (lut3d)
 +- SMPTE 302M audio encoder
  - support for slice multithreading in libavfilter
 +- Hald CLUT support (generation and filtering)
  - VC-1 interlaced B-frame support
  - support for WavPack muxing (raw and in Matroska)
 +- XVideo output device
 +- vignette filter
 +- True Audio (TTA) encoder
  - Go2Webinar decoder
 +- mcdeint filter ported from libmpcodecs
 +- sab filter ported from libmpcodecs
 +- ffprobe -show_chapters option
  - WavPack encoding through libwavpack
 -- Added the -n parameter to avconv
 -- RTMP seek support
 -- when transcoding with avconv (i.e. not streamcopying), -ss is now accurate
 -  even when used as an input option. Previous behavior can be restored with
 -  the -noaccurate_seek option.
 -- avconv -t option can now be used for inputs, to limit the duration of
 -  data read from an input file
 -- Voxware MetaSound decoder
 -- WebP decoder
 -- Error Resilient AAC syntax (ER AAC LC) decoding
 -- Low Delay AAC (ER AAC LD) decoding
 -- mux chapters in ASF files
 -- Opus in Ogg demuxing
 -- Enhanced Low Delay AAC (ER AAC ELD) decoding (no LD SBR support)
 -- F4V muxer
 -- HNM version 4 demuxer and video decoder
 -- HEVC decoder
 -- raw HEVC, HEVC in MOV/MP4, HEVC in Matroska, HEVC in MPEG-TS demuxing
 -- remove avplay -vismv option, which has not worked for a long time
 -- Live HDS muxer
 -- setsar/setdar filters now support variables in ratio expressions
 -- dar variable in the scale filter now returns the actual DAR (i.e. a * sar)
 -- VP9 decoder
 -- support for decoding through VDPAU in avconv (the -hwaccel option)
 -- remove mp3_header_(de)compress bitstream filters
 -- stereoscopic 3d metadata handling
 -- png standalone parser
 -- WebP encoding via libwebp
 -- ATRAC3+ decoder
 -- framepack filter
 -- Mirillis FIC video decoder
 -- Support DNx444
 -- compand audio filter
 +- rotate filter
 +- spp filter ported from libmpcodecs
 +- libgme support
 +- psnr filter
  
  
 -version 9:
 -- av_basename and av_dirname
 -- adobe and limelight publisher authentication in RTMP
 +version 1.2:
 +
  - VDPAU hardware acceleration through normal hwaccel
  - SRTP support
 +- Error diffusion dither in Swscale
 +- Chained Ogg support
 +- Theora Midstream reconfiguration support
 +- EVRC decoder
 +- audio fade filter
 +- filtering audio with unknown channel layout
 +- allpass, bass, bandpass, bandreject, biquad, equalizer, highpass, lowpass
 +  and treble audio filter
 +- improved showspectrum filter, with multichannel support and sox-like colors
 +- histogram filter
 +- tee muxer
 +- il filter ported from libmpcodecs
 +- support ID3v2 tags in ASF files
 +- encrypted TTA stream decoding support
 +- RF64 support in WAV muxer
 +- noise filter ported from libmpcodecs
 +- Subtitles character encoding conversion
 +- blend filter
 +- stereo3d filter ported from libmpcodecs
 +
  
 +version 1.1:
  
 -version 9_beta3:
 -- ashowinfo audio filter
 +- stream disposition information printing in ffprobe
 +- filter for loudness analysis following EBU R128
 +- Opus encoder using libopus
 +- ffprobe -select_streams option
 +- Pinnacle TARGA CineWave YUV16 decoder
 +- TAK demuxer, decoder and parser
 +- DTS-HD demuxer
 +- remove -same_quant, it hasn't worked for years
 +- FFM2 support
 +- X-Face image encoder and decoder
  - 24-bit FLAC encoding
 -- audio volume filter
 -- deprecated the avconv -vol option. the volume filter is to be used instead.
  - multi-channel ALAC encoding up to 7.1
 -- TAK demuxer, parser, and decoder
 -- adaptive frame-level multithreading for H.264
 -
 -
 -version 9_beta2:
  - metadata (INFO tag) support in WAV muxer
 +- subtitles raw text decoder
  - support for building DLLs using MSVC
 -- remove avserver daemon mode
 +- LVF demuxer
 +- ffescape tool
 +- metadata (info chunk) support in CAF muxer
 +- field filter ported from libmpcodecs
 +- AVR demuxer
 +- geq filter ported from libmpcodecs
 +- remove ffserver daemon mode
 +- AST muxer/demuxer
 +- new expansion syntax for drawtext
 +- BRender PIX image decoder
 +- ffprobe -show_entries option
 +- ffprobe -sections option
 +- ADPCM IMA Dialogic decoder
 +- BRSTM demuxer
 +- animated GIF decoder and demuxer
 +- PVF demuxer
 +- subtitles filter
 +- IRCAM muxer/demuxer
 +- Paris Audio File demuxer
 +- Virtual concatenation demuxer
 +- VobSub demuxer
 +- JSON captions for TED talks decoding support
 +- SOX Resampler support in libswresample
 +- aselect filter
 +- SGI RLE 8-bit / Silicon Graphics RLE 8-bit video decoder
 +- Silicon Graphics Motion Video Compressor 1 & 2 decoder
 +- Silicon Graphics Movie demuxer
 +- apad filter
 +- Resolution & pixel format change support with multithreading for H.264
 +- documentation split into per-component manuals
 +- pp (postproc) filter ported from MPlayer
 +- NIST Sphere demuxer
 +- MPL2, VPlayer, MPlayer, AQTitle, PJS and SubViewer v1 subtitles demuxers and decoders
 +- Sony Wave64 muxer
 +- adobe and limelight publisher authentication in RTMP
 +- data: URI scheme
  - support building on the Plan 9 operating system
 -- ffv1: support version 1.3
 +- kerndeint filter ported from MPlayer
 +- histeq filter ported from VirtualDub
 +- Megalux Frame demuxer
 +- 012v decoder
 +- Improved AVC Intra decoding support
  
  
 -version 9_beta1:
 +version 1.0:
  
 -- XWD encoder and decoder
 -- Support for fragmentation in the mov/mp4 muxer
 -- ISMV (Smooth Streaming) muxer
 -- CDXL demuxer and decoder
 -- Apple ProRes encoder
 -- Sun Rasterfile Encoder
 -- remove libpostproc
 -- ID3v2 attached pictures reading and writing
 -- WMA Lossless decoder
 -- XBM encoder
 -- RealAudio Lossless decoder
 -- ZeroCodec decoder
 -- drop support for avconv without libavfilter
 -- add libavresample audio conversion library
 -- audio filters support in libavfilter and avconv
 -- add fps filter
 -- audio split filter
 -- audio mix filter
 -- avprobe output is now standard INI or JSON. The old format can still
 -  be used with -of old.
 +- INI and flat output in ffprobe
 +- Scene detection in libavfilter
  - Indeo Audio decoder
  - channelsplit audio filter
 +- setnsamples audio filter
 +- atempo filter
 +- ffprobe -show_data option
  - RTMPT protocol support
  - iLBC encoding/decoding via libilbc
  - Microsoft Screen 1 decoder
diff --cc configure
+++ b/configure
@@@ -212,17 -186,11 +212,18 @@@ External library support
                             and libraw1394 [no]
    --enable-libfaac         enable AAC encoding via libfaac [no]
    --enable-libfdk-aac      enable AAC de/encoding via libfdk-aac [no]
 -  --enable-libfreetype     enable libfreetype [no]
 +  --enable-libflite        enable flite (voice synthesis) support via libflite [no]
 +  --enable-libfreetype     enable libfreetype, needed for drawtext filter [no]
 +  --enable-libfribidi      enable libfribidi, improves drawtext filter [no]
 +  --enable-libgme          enable Game Music Emu via libgme [no]
    --enable-libgsm          enable GSM de/encoding via libgsm [no]
 +  --enable-libiec61883     enable iec61883 via libiec61883 [no]
    --enable-libilbc         enable iLBC de/encoding via libilbc [no]
+   --enable-libmfx          enable HW acceleration through libmfx
 +  --enable-libmodplug      enable ModPlug via libmodplug [no]
    --enable-libmp3lame      enable MP3 encoding via libmp3lame [no]
 +  --enable-libnut          enable NUT (de)muxing via libnut,
 +                           native (de)muxer exists [no]
    --enable-libopencore-amrnb enable AMR-NB de/encoding via libopencore-amrnb [no]
    --enable-libopencore-amrwb enable AMR-WB decoding via libopencore-amrwb [no]
    --enable-libopencv       enable video filtering via libopencv [no]
@@@ -1354,17 -1150,12 +1355,18 @@@ EXTERNAL_LIBRARY_LIST=
      libdc1394
      libfaac
      libfdk_aac
 +    libflite
      libfontconfig
      libfreetype
 +    libfribidi
 +    libgme
      libgsm
 +    libiec61883
      libilbc
+     libmfx
 +    libmodplug
      libmp3lame
 +    libnut
      libopencore_amrnb
      libopencore_amrwb
      libopencv
@@@ -1477,8 -1236,8 +1479,9 @@@ SUBSYSTEM_LIST=
      lsp
      lzo
      mdct
 +    pixelutils
      network
+     qsv
      rdft
  "
  
@@@ -2139,9 -1823,11 +2142,11 @@@ h263i_decoder_select="h263_decoder
  h263p_encoder_select="h263_encoder"
  h264_decoder_select="cabac golomb h264chroma h264dsp h264pred h264qpel startcode videodsp"
  h264_decoder_suggest="error_resilience"
+ h264_qsv_decoder_deps="libmfx"
+ h264_qsv_decoder_select="h264_mp4toannexb_bsf h264_parser qsv h264_qsv_hwaccel"
  hevc_decoder_select="bswapdsp cabac golomb videodsp"
 -huffyuv_decoder_select="bswapdsp huffyuvdsp"
 -huffyuv_encoder_select="bswapdsp huffman huffyuvencdsp"
 +huffyuv_decoder_select="bswapdsp huffyuvdsp llviddsp"
 +huffyuv_encoder_select="bswapdsp huffman huffyuvencdsp llviddsp"
  iac_decoder_select="imc_decoder"
  imc_decoder_select="bswapdsp fft mdct sinewin"
  indeo3_decoder_select="hpeldsp"
@@@ -4900,38 -4200,21 +4905,39 @@@ enabled libgsm            && { for gsm_
                                     check_lib "${gsm_hdr}" gsm_create -lgsm && break;
                                 done || die "ERROR: libgsm not found"; }
  enabled libilbc           && require libilbc ilbc.h WebRtcIlbcfix_InitDecode -lilbc
+ enabled libmfx            && require_pkg_config libmfx "mfx/mfxvideo.h" MFXInit
 +enabled libmodplug        && require_pkg_config libmodplug libmodplug/modplug.h ModPlug_Load
  enabled libmp3lame        && require "libmp3lame >= 3.98.3" lame/lame.h lame_set_VBR_quality -lmp3lame
 +enabled libnut            && require libnut libnut.h nut_demuxer_init -lnut
  enabled libopencore_amrnb && require libopencore_amrnb opencore-amrnb/interf_dec.h Decoder_Interface_init -lopencore-amrnb
  enabled libopencore_amrwb && require libopencore_amrwb opencore-amrwb/dec_if.h D_IF_init -lopencore-amrwb
 -enabled libopencv         && require_pkg_config opencv opencv/cv.h cvCreateImageHeader
 +enabled libopencv         && require_pkg_config opencv opencv/cxcore.h cvCreateImageHeader
  enabled libopenh264       && require_pkg_config openh264 wels/codec_api.h WelsGetCodecVersion
 -enabled libopenjpeg       && { { check_header openjpeg.h && check_lib2 openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC; } ||
 -                               { require_pkg_config libopenjpeg1 openjpeg.h opj_version -DOPJ_STATIC; } }
 +enabled libopenjpeg       && { check_lib openjpeg.h opj_version -lopenmj2 -DOPJ_STATIC ||
 +                               check_lib openjpeg-1.5/openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC ||
 +                               check_lib openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC ||
 +                               die "ERROR: libopenjpeg not found"; }
  enabled libopus           && require_pkg_config opus opus_multistream.h opus_multistream_decoder_create
 -enabled libpulse          && require_pkg_config libpulse-simple pulse/simple.h pa_simple_new
 +enabled libpulse          && require_pkg_config libpulse pulse/pulseaudio.h pa_context_new
 +enabled libquvi           && require_pkg_config libquvi quvi/quvi.h quvi_init
  enabled librtmp           && require_pkg_config librtmp librtmp/rtmp.h RTMP_Socket
  enabled libschroedinger   && require_pkg_config schroedinger-1.0 schroedinger/schro.h schro_init
 +enabled libshine          && require_pkg_config shine shine/layer3.h shine_encode_buffer
 +enabled libsmbclient      && { use_pkg_config smbclient libsmbclient.h smbc_init ||
 +                               require smbclient libsmbclient.h smbc_init -lsmbclient; }
 +enabled libsoxr           && require libsoxr soxr.h soxr_create -lsoxr
 +enabled libssh            && require_pkg_config libssh libssh/sftp.h sftp_init
  enabled libspeex          && require_pkg_config speex speex/speex.h speex_decoder_init -lspeex
 +enabled libstagefright_h264 && require_cpp libstagefright_h264 "binder/ProcessState.h media/stagefright/MetaData.h
 +    media/stagefright/MediaBufferGroup.h media/stagefright/MediaDebug.h media/stagefright/MediaDefs.h
 +    media/stagefright/OMXClient.h media/stagefright/OMXCodec.h" android::OMXClient -lstagefright -lmedia -lutils -lbinder -lgnustl_static
  enabled libtheora         && require libtheora theora/theoraenc.h th_info_init -ltheoraenc -ltheoradec -logg
 -enabled libtwolame        && require libtwolame twolame.h twolame_init -ltwolame
 +enabled libtwolame        && require libtwolame twolame.h twolame_init -ltwolame &&
 +                             { check_lib twolame.h twolame_encode_buffer_float32_interleaved -ltwolame ||
 +                               die "ERROR: libtwolame must be installed and version must be >= 0.3.10"; }
 +enabled libutvideo        && require_cpp utvideo "stdint.h stdlib.h utvideo/utvideo.h utvideo/Codec.h" 'CCodec*' -lutvideo -lstdc++
 +enabled libv4l2           && require_pkg_config libv4l2 libv4l2.h v4l2_ioctl
 +enabled libvidstab        && require_pkg_config "vidstab >= 0.98" vid.stab/libvidstab.h vsMotionDetectInit
  enabled libvo_aacenc      && require libvo_aacenc vo-aacenc/voAAC.h voGetAACEncAPI -lvo-aacenc
  enabled libvo_amrwbenc    && require libvo_amrwbenc vo-amrwbenc/enc_if.h E_IF_init -lvo-amrwbenc
  enabled libvorbis         && require libvorbis vorbis/vorbisenc.h vorbis_info_init -lvorbisenc -lvorbis -logg
@@@ -6,7 -4,7 +6,8 @@@ HEADERS = avcodec.
            avfft.h                                                       \
            dv_profile.h                                                  \
            dxva2.h                                                       \
 +          old_codec_ids.h                                               \
+           qsv.h                                                         \
            vaapi.h                                                       \
            vda.h                                                         \
            vdpau.h                                                       \
@@@ -28,9 -24,9 +29,10 @@@ OBJS = allcodecs.
         mathtables.o                                                     \
         options.o                                                        \
         parser.o                                                         \
+        qsv_api.o                                                        \
         raw.o                                                            \
 +       resample.o                                                       \
 +       resample2.o                                                      \
         utils.o                                                          \
         vorbis_parser.o                                                  \
         xiph.o                                                           \
@@@ -262,7 -221,7 +265,8 @@@ OBJS-$(CONFIG_H264_DECODER)            
                                            h264_direct.o h264_loopfilter.o  \
                                            h264_mb.o h264_picture.o h264_ps.o \
                                            h264_refs.o h264_sei.o h264_slice.o
 +OBJS-$(CONFIG_H264_VDA_DECODER)        += vda_h264_dec.o
+ OBJS-$(CONFIG_H264_QSV_DECODER)        += qsv_h264.o
  OBJS-$(CONFIG_HEVC_DECODER)            += hevc.o hevc_mvs.o hevc_ps.o hevc_sei.o \
                                            hevc_cabac.o hevc_refs.o hevcpred.o    \
                                            hevcdsp.o hevc_filter.o
@@@ -855,8 -715,8 +859,9 @@@ SKIPHEADERS                            
  
  SKIPHEADERS-$(CONFIG_DXVA2)            += dxva2.h dxva2_internal.h
  SKIPHEADERS-$(CONFIG_LIBSCHROEDINGER)  += libschroedinger.h
 -SKIPHEADERS-$(CONFIG_MPEG_XVMC_DECODER) += xvmc.h
 +SKIPHEADERS-$(CONFIG_LIBUTVIDEO)       += libutvideo.h
+ SKIPHEADERS-$(CONFIG_QSV)              += qsv_internal.h
 +SKIPHEADERS-$(CONFIG_XVMC)             += xvmc.h
  SKIPHEADERS-$(CONFIG_VAAPI)            += vaapi_internal.h
  SKIPHEADERS-$(CONFIG_VDA)              += vda.h vda_internal.h
  SKIPHEADERS-$(CONFIG_VDPAU)            += vdpau.h vdpau_internal.h
@@@ -167,11 -159,9 +168,12 @@@ void avcodec_register_all(void
      REGISTER_ENCDEC (H261,              h261);
      REGISTER_ENCDEC (H263,              h263);
      REGISTER_DECODER(H263I,             h263i);
 -    REGISTER_ENCODER(H263P,             h263p);
 +    REGISTER_ENCDEC (H263P,             h263p);
      REGISTER_DECODER(H264,              h264);
 +    REGISTER_DECODER(H264_CRYSTALHD,    h264_crystalhd);
+     REGISTER_DECODER(H264_QSV,          h264_qsv);
 +    REGISTER_DECODER(H264_VDA,          h264_vda);
 +    REGISTER_DECODER(H264_VDPAU,        h264_vdpau);
      REGISTER_DECODER(HEVC,              hevc);
      REGISTER_DECODER(HNM4_VIDEO,        hnm4_video);
      REGISTER_ENCDEC (HUFFYUV,           huffyuv);
index 0000000,3b2a75b..2070d99
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,362 +1,362 @@@
 - * This file is part of Libav.
+ /*
+  * Intel MediaSDK QSV codec-independent code
+  *
+  * copyright (c) 2013 Luca Barbato
+  * copyright (c) 2015 Anton Khirnov <anton@khirnov.net>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
+  */
+ #include <string.h>
+ #include <sys/types.h>
+ #include <mfx/mfxvideo.h>
+ #include "libavutil/common.h"
+ #include "libavutil/mem.h"
+ #include "libavutil/log.h"
+ #include "libavutil/pixfmt.h"
+ #include "libavutil/time.h"
+ #include "avcodec.h"
+ #include "internal.h"
+ #include "qsv_internal.h"
+ int ff_qsv_error(int mfx_err)
+ {
+     switch (mfx_err) {
+     case MFX_ERR_NONE:
+         return 0;
+     case MFX_ERR_MEMORY_ALLOC:
+     case MFX_ERR_NOT_ENOUGH_BUFFER:
+         return AVERROR(ENOMEM);
+     case MFX_ERR_INVALID_HANDLE:
+         return AVERROR(EINVAL);
+     case MFX_ERR_DEVICE_FAILED:
+     case MFX_ERR_DEVICE_LOST:
+     case MFX_ERR_LOCK_MEMORY:
+         return AVERROR(EIO);
+     case MFX_ERR_NULL_PTR:
+     case MFX_ERR_UNDEFINED_BEHAVIOR:
+     case MFX_ERR_NOT_INITIALIZED:
+         return AVERROR_BUG;
+     case MFX_ERR_UNSUPPORTED:
+     case MFX_ERR_NOT_FOUND:
+         return AVERROR(ENOSYS);
+     case MFX_ERR_MORE_DATA:
+     case MFX_ERR_MORE_SURFACE:
+     case MFX_ERR_MORE_BITSTREAM:
+         return AVERROR(EAGAIN);
+     case MFX_ERR_INCOMPATIBLE_VIDEO_PARAM:
+     case MFX_ERR_INVALID_VIDEO_PARAM:
+         return AVERROR(EINVAL);
+     case MFX_ERR_ABORTED:
+     case MFX_ERR_UNKNOWN:
+     default:
+         return AVERROR_UNKNOWN;
+     }
+ }
+ int ff_qsv_map_pixfmt(enum AVPixelFormat format)
+ {
+     switch (format) {
+     case AV_PIX_FMT_YUV420P:
+     case AV_PIX_FMT_YUVJ420P:
+         return AV_PIX_FMT_NV12;
+     default:
+         return AVERROR(ENOSYS);
+     }
+ }
+ static int codec_id_to_mfx(enum AVCodecID codec_id)
+ {
+     switch (codec_id) {
+     case AV_CODEC_ID_H264:
+         return MFX_CODEC_AVC;
+     case AV_CODEC_ID_MPEG1VIDEO:
+     case AV_CODEC_ID_MPEG2VIDEO:
+         return MFX_CODEC_MPEG2;
+     case AV_CODEC_ID_VC1:
+         return MFX_CODEC_VC1;
+     default:
+         break;
+     }
+     return AVERROR(ENOSYS);
+ }
+ static int qsv_init_session(AVCodecContext *avctx, QSVContext *q, mfxSession session)
+ {
+     if (!session) {
+         if (!q->internal_session) {
+             mfxIMPL impl   = MFX_IMPL_AUTO_ANY;
+             mfxVersion ver = { { QSV_VERSION_MINOR, QSV_VERSION_MAJOR } };
+             const char *desc;
+             int ret;
+             ret = MFXInit(impl, &ver, &q->internal_session);
+             if (ret < 0) {
+                 av_log(avctx, AV_LOG_ERROR, "Error initializing an internal MFX session\n");
+                 return ff_qsv_error(ret);
+             }
+             MFXQueryIMPL(q->internal_session, &impl);
+             if (impl & MFX_IMPL_SOFTWARE)
+                 desc = "software";
+             else if (impl & MFX_IMPL_HARDWARE)
+                 desc = "hardware accelerated";
+             else
+                 desc = "unknown";
+             av_log(avctx, AV_LOG_VERBOSE,
+                    "Initialized an internal MFX session using %s implementation\n",
+                    desc);
+         }
+         q->session = q->internal_session;
+     } else {
+         q->session = session;
+     }
+     /* make sure the decoder is uninitialized */
+     MFXVideoDECODE_Close(q->session);
+     return 0;
+ }
+ int ff_qsv_init(AVCodecContext *avctx, QSVContext *q, mfxSession session)
+ {
+     mfxVideoParam param = { { 0 } };
+     int ret;
+     ret = qsv_init_session(avctx, q, session);
+     if (ret < 0) {
+         av_log(avctx, AV_LOG_ERROR, "Error initializing an MFX session\n");
+         return ret;
+     }
+     ret = codec_id_to_mfx(avctx->codec_id);
+     if (ret < 0)
+         return ret;
+     param.mfx.CodecId      = ret;
+     param.mfx.CodecProfile = avctx->profile;
+     param.mfx.CodecLevel   = avctx->level;
+     param.mfx.FrameInfo.BitDepthLuma   = 8;
+     param.mfx.FrameInfo.BitDepthChroma = 8;
+     param.mfx.FrameInfo.Shift          = 0;
+     param.mfx.FrameInfo.FourCC         = MFX_FOURCC_NV12;
+     param.mfx.FrameInfo.Width          = avctx->coded_width;
+     param.mfx.FrameInfo.Height         = avctx->coded_height;
+     param.mfx.FrameInfo.ChromaFormat   = MFX_CHROMAFORMAT_YUV420;
+     param.IOPattern   = q->iopattern;
+     param.AsyncDepth  = q->async_depth;
+     param.ExtParam    = q->ext_buffers;
+     param.NumExtParam = q->nb_ext_buffers;
+     ret = MFXVideoDECODE_Init(q->session, &param);
+     if (ret < 0) {
+         av_log(avctx, AV_LOG_ERROR, "Error initializing the MFX video decoder\n");
+         return ff_qsv_error(ret);
+     }
+     return 0;
+ }
+ static int alloc_frame(AVCodecContext *avctx, QSVFrame *frame)
+ {
+     int ret;
+     ret = ff_get_buffer(avctx, frame->frame, AV_GET_BUFFER_FLAG_REF);
+     if (ret < 0)
+         return ret;
+     if (frame->frame->format == AV_PIX_FMT_QSV) {
+         frame->surface = (mfxFrameSurface1*)frame->frame->data[3];
+     } else {
+         frame->surface_internal.Info.BitDepthLuma   = 8;
+         frame->surface_internal.Info.BitDepthChroma = 8;
+         frame->surface_internal.Info.FourCC         = MFX_FOURCC_NV12;
+         frame->surface_internal.Info.Width          = avctx->coded_width;
+         frame->surface_internal.Info.Height         = avctx->coded_height;
+         frame->surface_internal.Info.ChromaFormat   = MFX_CHROMAFORMAT_YUV420;
+         frame->surface_internal.Data.PitchLow = frame->frame->linesize[0];
+         frame->surface_internal.Data.Y        = frame->frame->data[0];
+         frame->surface_internal.Data.UV       = frame->frame->data[1];
+         frame->surface = &frame->surface_internal;
+     }
+     return 0;
+ }
+ static void qsv_clear_unused_frames(QSVContext *q)
+ {
+     QSVFrame *cur = q->work_frames;
+     while (cur) {
+         if (cur->surface && !cur->surface->Data.Locked) {
+             cur->surface = NULL;
+             av_frame_unref(cur->frame);
+         }
+         cur = cur->next;
+     }
+ }
+ static int get_surface(AVCodecContext *avctx, QSVContext *q, mfxFrameSurface1 **surf)
+ {
+     QSVFrame *frame, **last;
+     int ret;
+     qsv_clear_unused_frames(q);
+     frame = q->work_frames;
+     last  = &q->work_frames;
+     while (frame) {
+         if (!frame->surface) {
+             ret = alloc_frame(avctx, frame);
+             if (ret < 0)
+                 return ret;
+             *surf = frame->surface;
+             return 0;
+         }
+         last  = &frame->next;
+         frame = frame->next;
+     }
+     frame = av_mallocz(sizeof(*frame));
+     if (!frame)
+         return AVERROR(ENOMEM);
+     frame->frame = av_frame_alloc();
+     if (!frame->frame) {
+         av_freep(&frame);
+         return AVERROR(ENOMEM);
+     }
+     *last = frame;
+     ret = alloc_frame(avctx, frame);
+     if (ret < 0)
+         return ret;
+     *surf = frame->surface;
+     return 0;
+ }
+ static AVFrame *find_frame(QSVContext *q, mfxFrameSurface1 *surf)
+ {
+     QSVFrame *cur = q->work_frames;
+     while (cur) {
+         if (surf == cur->surface)
+             return cur->frame;
+         cur = cur->next;
+     }
+     return NULL;
+ }
+ int ff_qsv_decode(AVCodecContext *avctx, QSVContext *q,
+                   AVFrame *frame, int *got_frame,
+                   AVPacket *avpkt)
+ {
+     mfxFrameSurface1 *insurf;
+     mfxFrameSurface1 *outsurf;
+     mfxSyncPoint sync;
+     mfxBitstream bs = { { { 0 } } };
+     int ret;
+     if (avpkt->size) {
+         bs.Data       = avpkt->data;
+         bs.DataLength = avpkt->size;
+         bs.MaxLength  = bs.DataLength;
+         bs.TimeStamp  = avpkt->pts;
+     }
+     do {
+         ret = get_surface(avctx, q, &insurf);
+         if (ret < 0)
+             return ret;
+         ret = MFXVideoDECODE_DecodeFrameAsync(q->session, avpkt->size ? &bs : NULL,
+                                               insurf, &outsurf, &sync);
+         if (ret == MFX_WRN_DEVICE_BUSY)
+             av_usleep(1);
+     } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_ERR_MORE_SURFACE);
+     if (ret != MFX_ERR_NONE &&
+         ret != MFX_ERR_MORE_DATA &&
+         ret != MFX_WRN_VIDEO_PARAM_CHANGED &&
+         ret != MFX_ERR_MORE_SURFACE) {
+         av_log(avctx, AV_LOG_ERROR, "Error during QSV decoding.\n");
+         return ff_qsv_error(ret);
+     }
+     if (sync) {
+         AVFrame *src_frame;
+         MFXVideoCORE_SyncOperation(q->session, sync, 60000);
+         src_frame = find_frame(q, outsurf);
+         if (!src_frame) {
+             av_log(avctx, AV_LOG_ERROR,
+                    "The returned surface does not correspond to any frame\n");
+             return AVERROR_BUG;
+         }
+         ret = av_frame_ref(frame, src_frame);
+         if (ret < 0)
+             return ret;
+         frame->pkt_pts = frame->pts = outsurf->Data.TimeStamp;
+         frame->repeat_pict =
+             outsurf->Info.PicStruct & MFX_PICSTRUCT_FRAME_TRIPLING ? 4 :
+             outsurf->Info.PicStruct & MFX_PICSTRUCT_FRAME_DOUBLING ? 2 :
+             outsurf->Info.PicStruct & MFX_PICSTRUCT_FIELD_REPEATED ? 1 : 0;
+         frame->top_field_first =
+             outsurf->Info.PicStruct & MFX_PICSTRUCT_FIELD_TFF;
+         frame->interlaced_frame =
+             !(outsurf->Info.PicStruct & MFX_PICSTRUCT_PROGRESSIVE);
+         *got_frame = 1;
+     }
+     return bs.DataOffset;
+ }
+ int ff_qsv_close(QSVContext *q)
+ {
+     QSVFrame *cur = q->work_frames;
+     while (cur) {
+         q->work_frames = cur->next;
+         av_frame_free(&cur->frame);
+         av_freep(&cur);
+         cur = q->work_frames;
+     }
+     if (q->internal_session)
+         MFXClose(q->internal_session);
+     return 0;
+ }
index 0000000,6532594..e7487c8
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,41 +1,41 @@@
 - * This file is part of Libav.
+ /*
+  * Intel MediaSDK QSV public API
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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_QSV_H
+ #define AVCODEC_QSV_H
+ #include <mfx/mfxvideo.h>
+ typedef struct AVQSVContext {
+     mfxSession session;
+     int iopattern;
+     mfxExtBuffer **ext_buffers;
+     int         nb_ext_buffers;
+ } AVQSVContext;
+ /**
+  * Allocate a new context.
+  *
+  * It must be freed by the caller with av_free().
+  */
+ AVQSVContext *av_qsv_alloc_context(void);
+ #endif /* AVCODEC_QSV_H */
index 0000000,8fde494..8ae3d5b
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,28 +1,28 @@@
 - * This file is part of Libav.
+ /*
+  * Intel MediaSDK QSV public API functions
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
+  */
+ #include "libavutil/mem.h"
+ #include "qsv.h"
+ AVQSVContext *av_qsv_alloc_context(void)
+ {
+     return av_mallocz(sizeof(AVQSVContext));
+ }
index 0000000,a482e9c..eafc352
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,313 +1,313 @@@
 - * This file is part of Libav.
+ /*
+  * Intel MediaSDK QSV based H.264 decoder
+  *
+  * copyright (c) 2013 Luca Barbato
+  * copyright (c) 2015 Anton Khirnov
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
+  */
+ #include <stdint.h>
+ #include <string.h>
+ #include <mfx/mfxvideo.h>
+ #include "libavutil/common.h"
+ #include "libavutil/fifo.h"
+ #include "libavutil/opt.h"
+ #include "avcodec.h"
+ #include "internal.h"
+ #include "qsv_internal.h"
+ #include "qsv.h"
+ typedef struct QSVH264Context {
+     AVClass *class;
+     QSVContext qsv;
+     // the internal parser and codec context for parsing the data
+     AVCodecParserContext *parser;
+     AVCodecContext *avctx_internal;
+     enum AVPixelFormat orig_pix_fmt;
+     // the filter for converting to Annex B
+     AVBitStreamFilterContext *bsf;
+     AVFifoBuffer *packet_fifo;
+     AVPacket input_ref;
+     AVPacket pkt_filtered;
+     uint8_t *filtered_data;
+ } QSVH264Context;
+ static void qsv_clear_buffers(QSVH264Context *s)
+ {
+     AVPacket pkt;
+     while (av_fifo_size(s->packet_fifo) >= sizeof(pkt)) {
+         av_fifo_generic_read(s->packet_fifo, &pkt, sizeof(pkt), NULL);
+         av_packet_unref(&pkt);
+     }
+     if (s->filtered_data != s->input_ref.data)
+         av_freep(&s->filtered_data);
+     s->filtered_data = NULL;
+     av_packet_unref(&s->input_ref);
+ }
+ static av_cold int qsv_decode_close(AVCodecContext *avctx)
+ {
+     QSVH264Context *s = avctx->priv_data;
+     ff_qsv_close(&s->qsv);
+     qsv_clear_buffers(s);
+     av_fifo_free(s->packet_fifo);
+     av_bitstream_filter_close(s->bsf);
+     av_parser_close(s->parser);
+     avcodec_free_context(&s->avctx_internal);
+     return 0;
+ }
+ static av_cold int qsv_decode_init(AVCodecContext *avctx)
+ {
+     QSVH264Context *s = avctx->priv_data;
+     int ret;
+     s->orig_pix_fmt = AV_PIX_FMT_NONE;
+     s->packet_fifo = av_fifo_alloc(sizeof(AVPacket));
+     if (!s->packet_fifo) {
+         ret = AVERROR(ENOMEM);
+         goto fail;
+     }
+     s->bsf = av_bitstream_filter_init("h264_mp4toannexb");
+     if (!s->bsf) {
+         ret = AVERROR(ENOMEM);
+         goto fail;
+     }
+     s->avctx_internal = avcodec_alloc_context3(NULL);
+     if (!s->avctx_internal) {
+         ret = AVERROR(ENOMEM);
+         goto fail;
+     }
+     if (avctx->extradata) {
+         s->avctx_internal->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
+         if (!s->avctx_internal->extradata) {
+             ret = AVERROR(ENOMEM);
+             goto fail;
+         }
+         memcpy(s->avctx_internal->extradata, avctx->extradata,
+                avctx->extradata_size);
+         s->avctx_internal->extradata_size = avctx->extradata_size;
+     }
+     s->parser = av_parser_init(AV_CODEC_ID_H264);
+     if (!s->parser) {
+         ret = AVERROR(ENOMEM);
+         goto fail;
+     }
+     s->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
+     s->qsv.iopattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
+     return 0;
+ fail:
+     qsv_decode_close(avctx);
+     return ret;
+ }
+ static int qsv_process_data(AVCodecContext *avctx, AVFrame *frame,
+                             int *got_frame, AVPacket *pkt)
+ {
+     QSVH264Context *s = avctx->priv_data;
+     uint8_t *dummy_data;
+     int dummy_size;
+     int ret;
+     /* we assume the packets are already split properly and want
+      * just the codec parameters here */
+     av_parser_parse2(s->parser, s->avctx_internal,
+                      &dummy_data, &dummy_size,
+                      pkt->data, pkt->size, pkt->pts, pkt->dts,
+                      pkt->pos);
+     /* TODO: flush delayed frames on reinit */
+     if (s->parser->format       != s->orig_pix_fmt    ||
+         s->parser->coded_width  != avctx->coded_width ||
+         s->parser->coded_height != avctx->coded_height) {
+         mfxSession session = NULL;
+         enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_QSV,
+                                            AV_PIX_FMT_NONE,
+                                            AV_PIX_FMT_NONE };
+         enum AVPixelFormat qsv_format;
+         qsv_format = ff_qsv_map_pixfmt(s->parser->format);
+         if (qsv_format < 0) {
+             av_log(avctx, AV_LOG_ERROR,
+                    "Only 8-bit YUV420 streams are supported.\n");
+             ret = AVERROR(ENOSYS);
+             goto reinit_fail;
+         }
+         s->orig_pix_fmt     = s->parser->format;
+         avctx->pix_fmt      = pix_fmts[1] = qsv_format;
+         avctx->width        = s->parser->width;
+         avctx->height       = s->parser->height;
+         avctx->coded_width  = s->parser->coded_width;
+         avctx->coded_height = s->parser->coded_height;
+         avctx->level        = s->avctx_internal->level;
+         avctx->profile      = s->avctx_internal->profile;
+         ret = ff_get_format(avctx, pix_fmts);
+         if (ret < 0)
+             goto reinit_fail;
+         avctx->pix_fmt = ret;
+         if (avctx->hwaccel_context) {
+             AVQSVContext *user_ctx = avctx->hwaccel_context;
+             session               = user_ctx->session;
+             s->qsv.iopattern      = user_ctx->iopattern;
+             s->qsv.ext_buffers    = user_ctx->ext_buffers;
+             s->qsv.nb_ext_buffers = user_ctx->nb_ext_buffers;
+         }
+         ret = ff_qsv_init(avctx, &s->qsv, session);
+         if (ret < 0)
+             goto reinit_fail;
+     }
+     return ff_qsv_decode(avctx, &s->qsv, frame, got_frame, &s->pkt_filtered);
+ reinit_fail:
+     s->orig_pix_fmt = s->parser->format = avctx->pix_fmt = AV_PIX_FMT_NONE;
+     return ret;
+ }
+ static int qsv_decode_frame(AVCodecContext *avctx, void *data,
+                             int *got_frame, AVPacket *avpkt)
+ {
+     QSVH264Context *s = avctx->priv_data;
+     AVFrame *frame    = data;
+     int ret;
+     /* buffer the input packet */
+     if (avpkt->size) {
+         AVPacket input_ref = { 0 };
+         if (av_fifo_space(s->packet_fifo) < sizeof(input_ref)) {
+             ret = av_fifo_realloc2(s->packet_fifo,
+                                    av_fifo_size(s->packet_fifo) + sizeof(input_ref));
+             if (ret < 0)
+                 return ret;
+         }
+         ret = av_packet_ref(&input_ref, avpkt);
+         if (ret < 0)
+             return ret;
+         av_fifo_generic_write(s->packet_fifo, &input_ref, sizeof(input_ref), NULL);
+     }
+     /* process buffered data */
+     while (!*got_frame) {
+         /* prepare the input data -- convert to Annex B if needed */
+         if (s->pkt_filtered.size <= 0) {
+             int size;
+             /* no more data */
+             if (av_fifo_size(s->packet_fifo) < sizeof(AVPacket))
+                 return avpkt->size ? avpkt->size : ff_qsv_decode(avctx, &s->qsv, frame, got_frame, avpkt);
+             if (s->filtered_data != s->input_ref.data)
+                 av_freep(&s->filtered_data);
+             s->filtered_data = NULL;
+             av_packet_unref(&s->input_ref);
+             av_fifo_generic_read(s->packet_fifo, &s->input_ref, sizeof(s->input_ref), NULL);
+             ret = av_bitstream_filter_filter(s->bsf, avctx, NULL,
+                                              &s->filtered_data, &size,
+                                              s->input_ref.data, s->input_ref.size, 0);
+             if (ret < 0) {
+                 s->filtered_data = s->input_ref.data;
+                 size             = s->input_ref.size;
+             }
+             s->pkt_filtered      = s->input_ref;
+             s->pkt_filtered.data = s->filtered_data;
+             s->pkt_filtered.size = size;
+         }
+         ret = qsv_process_data(avctx, frame, got_frame, &s->pkt_filtered);
+         if (ret < 0)
+             return ret;
+         s->pkt_filtered.size -= ret;
+         s->pkt_filtered.data += ret;
+     }
+     return avpkt->size;
+ }
+ static void qsv_decode_flush(AVCodecContext *avctx)
+ {
+     QSVH264Context *s = avctx->priv_data;
+     qsv_clear_buffers(s);
+     s->orig_pix_fmt = AV_PIX_FMT_NONE;
+ }
+ AVHWAccel ff_h264_qsv_hwaccel = {
+     .name           = "h264_qsv",
+     .type           = AVMEDIA_TYPE_VIDEO,
+     .id             = AV_CODEC_ID_H264,
+     .pix_fmt        = AV_PIX_FMT_QSV,
+ };
+ #define OFFSET(x) offsetof(QSVH264Context, x)
+ #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
+ static const AVOption options[] = {
+     { "async_depth", "Internal parallelization depth, the higher the value the higher the latency.", OFFSET(qsv.async_depth), AV_OPT_TYPE_INT, { .i64 = ASYNC_DEPTH_DEFAULT }, 0, INT_MAX, VD },
+     { NULL },
+ };
+ static const AVClass class = {
+     .class_name = "h264_qsv",
+     .item_name  = av_default_item_name,
+     .option     = options,
+     .version    = LIBAVUTIL_VERSION_INT,
+ };
+ AVCodec ff_h264_qsv_decoder = {
+     .name           = "h264_qsv",
+     .long_name      = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (Intel Quick Sync Video acceleration)"),
+     .priv_data_size = sizeof(QSVH264Context),
+     .type           = AVMEDIA_TYPE_VIDEO,
+     .id             = AV_CODEC_ID_H264,
+     .init           = qsv_decode_init,
+     .decode         = qsv_decode_frame,
+     .flush          = qsv_decode_flush,
+     .close          = qsv_decode_close,
+     .capabilities   = CODEC_CAP_DELAY,
+     .priv_class     = &class,
+ };
index 0000000,8ab149a..c154eaf
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,86 +1,86 @@@
 - * This file is part of Libav.
+ /*
+  * Intel MediaSDK QSV utility functions
+  *
+  * copyright (c) 2013 Luca Barbato
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 - * Convert a libmfx error code into a libav error code.
++ * 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_QSV_INTERNAL_H
+ #define AVCODEC_QSV_INTERNAL_H
+ #include <stdint.h>
+ #include <sys/types.h>
+ #include <mfx/mfxvideo.h>
+ #include "libavutil/frame.h"
+ #include "libavutil/pixfmt.h"
+ #include "avcodec.h"
+ #define QSV_VERSION_MAJOR 1
+ #define QSV_VERSION_MINOR 1
+ #define ASYNC_DEPTH_DEFAULT 4       // internal parallelism
+ typedef struct QSVFrame {
+     AVFrame *frame;
+     mfxFrameSurface1 *surface;
+     mfxFrameSurface1 surface_internal;
+     struct QSVFrame *next;
+ } QSVFrame;
+ typedef struct QSVContext {
+     // the session used for decoding
+     mfxSession session;
+     // the session we allocated internally, in case the caller did not provide
+     // one
+     mfxSession internal_session;
+     /**
+      * a linked list of frames currently being used by QSV
+      */
+     QSVFrame *work_frames;
+     // options set by the caller
+     int async_depth;
+     int iopattern;
+     mfxExtBuffer **ext_buffers;
+     int         nb_ext_buffers;
+ } QSVContext;
+ /**
++ * Convert a libmfx error code into a ffmpeg error code.
+  */
+ int ff_qsv_error(int mfx_err);
+ int ff_qsv_map_pixfmt(enum AVPixelFormat format);
+ int ff_qsv_init(AVCodecContext *s, QSVContext *q, mfxSession session);
+ int ff_qsv_decode(AVCodecContext *s, QSVContext *q,
+                   AVFrame *frame, int *got_frame,
+                   AVPacket *avpkt);
+ int ff_qsv_close(QSVContext *q);
+ #endif /* AVCODEC_QSV_INTERNAL_H */
@@@ -29,8 -29,8 +29,8 @@@
  #include "libavutil/version.h"
  
  #define LIBAVCODEC_VERSION_MAJOR 56
- #define LIBAVCODEC_VERSION_MINOR  23
 -#define LIBAVCODEC_VERSION_MINOR 14
 -#define LIBAVCODEC_VERSION_MICRO  0
++#define LIBAVCODEC_VERSION_MINOR  24
 +#define LIBAVCODEC_VERSION_MICRO 100
  
  #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
                                                 LIBAVCODEC_VERSION_MINOR, \