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
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]
libdc1394
libfaac
libfdk_aac
+ libflite
libfontconfig
libfreetype
+ libfribidi
+ libgme
libgsm
+ libiec61883
libilbc
+ libmfx
+ libmodplug
libmp3lame
+ libnut
libopencore_amrnb
libopencore_amrwb
libopencv
lsp
lzo
mdct
+ pixelutils
network
+ qsv
rdft
"
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"
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
avfft.h \
dv_profile.h \
dxva2.h \
+ old_codec_ids.h \
+ qsv.h \
vaapi.h \
vda.h \
vdpau.h \
mathtables.o \
options.o \
parser.o \
+ qsv_api.o \
raw.o \
+ resample.o \
+ resample2.o \
utils.o \
vorbis_parser.o \
xiph.o \
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
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
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);
--- /dev/null
- * 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, ¶m);
+ 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;
+ }
--- /dev/null
- * 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 */
--- /dev/null
- * 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));
+ }
--- /dev/null
- * 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,
+ };
--- /dev/null
- * 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 */
#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, \
OSDN Git Service
