Merge commit '41d47ea85fb4ad9cfb5c2dc808a46bc1d57f3986'
authorMichael Niedermayer <michael@niedermayer.cc>
Sat, 25 Jul 2015 23:20:46 +0000 (01:20 +0200)
committerMichael Niedermayer <michael@niedermayer.cc>
Sat, 25 Jul 2015 23:20:46 +0000 (01:20 +0200)
* commit '41d47ea85fb4ad9cfb5c2dc808a46bc1d57f3986':
  lavc: add Intel libmfx-based HEVC decoder.

Conflicts:
Changelog
configure
libavcodec/Makefile
libavcodec/allcodecs.c
libavcodec/qsvdec.c
libavcodec/qsvdec_h2645.c
libavcodec/version.h

Merged-by: Michael Niedermayer <michael@niedermayer.cc>
1  2 
Changelog
configure
libavcodec/Makefile
libavcodec/allcodecs.c
libavcodec/qsvdec.c
libavcodec/qsvdec.h
libavcodec/qsvdec_h2645.c
libavcodec/version.h

diff --cc Changelog
+++ b/Changelog
@@@ -2,85 -2,17 +2,85 @@@ 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
 +- colorkey video filter
 +- BFSTM/BCSTM demuxer
 +- little-endian ADPCM_THP decoder
 +- Hap decoder and encoder
 +- DirectDraw Surface image/texture decoder
 +- ssim filter
 +- rewritten ASF demuxer
 +- showvolume filter
 +- Many improvements to the JPEG 2000 decoder
 +- Go2Meeting decoding support
 +- adrawgraph audio and drawgraph video filter
 +- removegrain video filter
 +- Intel QSV-accelerated MPEG-2 video and HEVC encoding
- - Intel QSV-accelerated MPEG-2 video decoding
++- Intel QSV-accelerated MPEG-2 video and HEVC decoding
 +- Intel QSV-accelerated VC-1 video decoding
 +- libkvazaar HEVC encoder
 +- erosion, dilation, deflate and inflate video filters
 +- Dynamic Audio Normalizer as dynaudnorm filter
 +- Reverse video and areverse audio filter
 +- Random filter
 +- deband filter
 +- AAC fixed-point decoding
 +- sidechaincompress audio filter
 +- bitstream filter for converting HEVC from MP4 to Annex B
 +
 +
 +version 2.7:
 +- FFT video filter
 +- TDSC decoder
 +- DTS lossless extension (XLL) decoding (not lossless, disabled by default)
 +- showwavespic filter
 +- DTS decoding through libdcadec
 +- Drop support for nvenc API before 5.0
 +- nvenc HEVC encoder
 +- Detelecine filter
 +- Intel QSV-accelerated H.264 encoding
 +- MMAL-accelerated H.264 decoding
 +- basic APNG encoder and muxer with default extension "apng"
 +- unpack DivX-style packed B-frames in MPEG-4 bitstream filter
 +- WebM Live Chunk Muxer
 +- nvenc level and tier options
 +- chorus filter
 +- Canopus HQ/HQA decoder
 +- Automatically rotate videos based on metadata in ffmpeg
 +- improved Quickdraw compatibility
 +- VP9 high bit-depth and extended colorspaces decoding support
 +- WebPAnimEncoder API when available for encoding and muxing WebP
 +- Direct3D11-accelerated decoding
 +- Support Secure Transport
 +- Multipart JPEG demuxer
 +
 +
 +version 2.6:
 +- 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)
 -- Direct3D11-accelerated decoding
 +- 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 depacketizer for loss tolerant payload format for MP3 audio (RFC 5219)
 +- RTP depacketizer for AC3 payload format (RFC 4184)
 +- palettegen and paletteuse filters
 +- VP9 RTP payload format (draft 0) experimental depacketizer
 +- RTP depacketizer for DV (RFC 6469)
  - DXVA2-accelerated HEVC decoding
  - AAC ELD 480 decoding
  - Intel QSV-accelerated H.264 decoding
diff --cc configure
+++ b/configure
@@@ -2230,10 -1879,13 +2230,12 @@@ hap_decoder_select="snappy texturedsp
  hap_encoder_deps="libsnappy"
  hap_encoder_select="texturedspenc"
  hevc_decoder_select="bswapdsp cabac golomb videodsp"
 -hevc_nvenc_encoder_deps="nvenc"
  hevc_qsv_encoder_deps="libmfx"
+ hevc_qsv_decoder_deps="libmfx"
+ hevc_qsv_decoder_select="hevc_mp4toannexb_bsf hevc_parser qsvdec hevc_qsv_hwaccel"
  hevc_qsv_encoder_select="qsvenc"
 -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"
@@@ -2412,19 -2047,9 +2414,20 @@@ hevc_d3d11va_hwaccel_deps="d3d11va DXVA
  hevc_d3d11va_hwaccel_select="hevc_decoder"
  hevc_dxva2_hwaccel_deps="dxva2 DXVA_PicParams_HEVC"
  hevc_dxva2_hwaccel_select="hevc_decoder"
+ hevc_qsv_hwaccel_deps="libmfx"
 +hevc_vdpau_hwaccel_deps="vdpau VdpPictureInfoHEVC"
 +hevc_vdpau_hwaccel_select="hevc_decoder"
 +mpeg_vdpau_decoder_deps="vdpau"
 +mpeg_vdpau_decoder_select="mpeg2video_decoder"
 +mpeg_xvmc_hwaccel_deps="xvmc"
 +mpeg_xvmc_hwaccel_select="mpeg2video_decoder"
 +mpeg1_vdpau_decoder_deps="vdpau"
 +mpeg1_vdpau_decoder_select="mpeg1video_decoder"
  mpeg1_vdpau_hwaccel_deps="vdpau"
  mpeg1_vdpau_hwaccel_select="mpeg1video_decoder"
 +mpeg1_xvmc_hwaccel_deps="xvmc"
 +mpeg1_xvmc_hwaccel_select="mpeg1video_decoder"
 +mpeg2_crystalhd_decoder_select="crystalhd"
  mpeg2_d3d11va_hwaccel_deps="d3d11va"
  mpeg2_d3d11va_hwaccel_select="mpeg2video_decoder"
  mpeg2_dxva2_hwaccel_deps="dxva2"
@@@ -288,14 -240,16 +288,15 @@@ OBJS-$(CONFIG_H264_DECODER)            
                                            h264_mb.o h264_picture.o h264_ps.o \
                                            h264_refs.o h264_sei.o h264_slice.o
  OBJS-$(CONFIG_H264_MMAL_DECODER)       += mmaldec.o
 -OBJS-$(CONFIG_H264_NVENC_ENCODER)      += nvenc_h264.o
 +OBJS-$(CONFIG_H264_VDA_DECODER)        += vda_h264_dec.o
- OBJS-$(CONFIG_H264_QSV_DECODER)        += qsvdec_h264.o
+ OBJS-$(CONFIG_H264_QSV_DECODER)        += qsvdec_h2645.o
  OBJS-$(CONFIG_H264_QSV_ENCODER)        += qsvenc_h264.o
 -OBJS-$(CONFIG_HAP_DECODER)             += hapdec.o
 -OBJS-$(CONFIG_HAP_ENCODER)             += hapenc.o
 +OBJS-$(CONFIG_HAP_DECODER)             += hapdec.o hap.o
 +OBJS-$(CONFIG_HAP_ENCODER)             += hapenc.o hap.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 hevc_parse.o hevc_data.o
 -OBJS-$(CONFIG_HEVC_NVENC_ENCODER)      += nvenc_hevc.o
+ OBJS-$(CONFIG_HEVC_QSV_DECODER)        += qsvdec_h2645.o
  OBJS-$(CONFIG_HEVC_QSV_ENCODER)        += qsvenc_hevc.o hevc_ps_enc.o hevc_parse.o
  OBJS-$(CONFIG_HNM4_VIDEO_DECODER)      += hnm4video.o
  OBJS-$(CONFIG_HQ_HQA_DECODER)          += hq_hqa.o hq_hqadata.o hq_hqadsp.o \
@@@ -86,10 -86,8 +86,11 @@@ void avcodec_register_all(void
      REGISTER_HWACCEL(H264_VDPAU,        h264_vdpau);
      REGISTER_HWACCEL(HEVC_D3D11VA,      hevc_d3d11va);
      REGISTER_HWACCEL(HEVC_DXVA2,        hevc_dxva2);
+     REGISTER_HWACCEL(HEVC_QSV,          hevc_qsv);
 +    REGISTER_HWACCEL(HEVC_VDPAU,        hevc_vdpau);
 +    REGISTER_HWACCEL(MPEG1_XVMC,        mpeg1_xvmc);
      REGISTER_HWACCEL(MPEG1_VDPAU,       mpeg1_vdpau);
 +    REGISTER_HWACCEL(MPEG2_XVMC,        mpeg2_xvmc);
      REGISTER_HWACCEL(MPEG2_D3D11VA,     mpeg2_d3d11va);
      REGISTER_HWACCEL(MPEG2_DXVA2,       mpeg2_dxva2);
      REGISTER_HWACCEL(MPEG2_QSV,         mpeg2_qsv);
      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_MMAL,         h264_mmal);
      REGISTER_DECODER(H264_QSV,          h264_qsv);
 +    REGISTER_DECODER(H264_VDA,          h264_vda);
 +    REGISTER_DECODER(H264_VDPAU,        h264_vdpau);
      REGISTER_ENCDEC (HAP,               hap);
      REGISTER_DECODER(HEVC,              hevc);
+     REGISTER_DECODER(HEVC_QSV,          hevc_qsv);
      REGISTER_DECODER(HNM4_VIDEO,        hnm4_video);
      REGISTER_DECODER(HQ_HQA,            hq_hqa);
      REGISTER_DECODER(HQX,               hqx);
@@@ -49,57 -49,62 +49,58 @@@ int ff_qsv_map_pixfmt(enum AVPixelForma
      }
  }
  
 -static int qsv_init_session(AVCodecContext *avctx, QSVContext *q, mfxSession session)
 -{
 -    if (!session) {
 -        if (!q->internal_session) {
 -            int ret = ff_qsv_init_internal_session(avctx, &q->internal_session,
 -                                                   q->load_plugins);
 -            if (ret < 0)
 -                return ret;
 -        }
 -
 -        q->session = q->internal_session;
 -    } else {
 -        q->session = session;
 -    }
 -
 -    /* make sure the decoder is uninitialized */
 -    MFXVideoDECODE_Close(q->session);
 -
 -    return 0;
 -}
 -
 -int ff_qsv_decode_init(AVCodecContext *avctx, QSVContext *q, mfxSession session)
 +int ff_qsv_decode_init(AVCodecContext *avctx, QSVContext *q, AVPacket *avpkt)
  {
      mfxVideoParam param = { { 0 } };
 +    mfxBitstream bs   = { { { 0 } } };
      int ret;
  
 -    if (!q->async_fifo) {
 -        q->async_fifo = av_fifo_alloc((1 + q->async_depth) *
 -                                      (sizeof(mfxSyncPoint) + sizeof(QSVFrame*)));
 -        if (!q->async_fifo)
 -            return AVERROR(ENOMEM);
 -    }
 +    q->iopattern  = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
 +    if (!q->session) {
 +        if (avctx->hwaccel_context) {
 +            AVQSVContext *qsv = avctx->hwaccel_context;
  
 -    ret = qsv_init_session(avctx, q, session);
 -    if (ret < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "Error initializing an MFX session\n");
 -        return ret;
 +            q->session        = qsv->session;
 +            q->iopattern      = qsv->iopattern;
 +            q->ext_buffers    = qsv->ext_buffers;
 +            q->nb_ext_buffers = qsv->nb_ext_buffers;
 +        }
 +        if (!q->session) {
-             ret = ff_qsv_init_internal_session(avctx, &q->internal_qs, NULL);
++            ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,
++                                               q->load_plugins);
 +            if (ret < 0)
 +                return ret;
 +
 +            q->session = q->internal_qs.session;
 +        }
      }
  
 +    if (avpkt->size) {
 +        bs.Data       = avpkt->data;
 +        bs.DataLength = avpkt->size;
 +        bs.MaxLength  = bs.DataLength;
 +        bs.TimeStamp  = avpkt->pts;
 +    } else
 +        return AVERROR_INVALIDDATA;
  
      ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
 -    if (ret < 0)
 +    if (ret < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "Unsupported codec_id %08x\n", avctx->codec_id);
          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.mfx.CodecId = ret;
  
 +    ret = MFXVideoDECODE_DecodeHeader(q->session, &bs, &param);
 +    if (MFX_ERR_MORE_DATA==ret) {
 +        /* this code means that header not found so we return packet size to skip
 +           a current packet
 +         */
 +        return avpkt->size;
 +    } else if (ret < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "Decode header error %d\n", ret);
 +        return ff_qsv_error(ret);
 +    }
      param.IOPattern   = q->iopattern;
      param.AsyncDepth  = q->async_depth;
      param.ExtParam    = q->ext_buffers;
Simple merge
index 0000000,99bce94..d231b46
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,282 +1,222 @@@
 - * This file is part of Libav.
+ /*
+  * Intel MediaSDK QSV based H.264 / HEVC 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
 -#include "qsv_internal.h"
++ * 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.h"
+ #include "qsvdec.h"
 -    AVFifoBuffer *packet_fifo;
 -
 -    AVPacket input_ref;
 -    AVPacket pkt_filtered;
 -    uint8_t *filtered_data;
+ enum LoadPlugin {
+     LOAD_PLUGIN_NONE,
+     LOAD_PLUGIN_HEVC_SW,
+ };
+ typedef struct QSVH2645Context {
+     AVClass *class;
+     QSVContext qsv;
+     int load_plugin;
+     // the filter for converting to Annex B
+     AVBitStreamFilterContext *bsf;
 -static void qsv_clear_buffers(QSVH2645Context *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);
 -}
 -
+ } QSVH2645Context;
 -    qsv_clear_buffers(s);
 -
 -    av_fifo_free(s->packet_fifo);
 -
+ static av_cold int qsv_decode_close(AVCodecContext *avctx)
+ {
+     QSVH2645Context *s = avctx->priv_data;
+     ff_qsv_decode_close(&s->qsv);
 -    s->packet_fifo = av_fifo_alloc(sizeof(AVPacket));
 -    if (!s->packet_fifo) {
 -        ret = AVERROR(ENOMEM);
 -        goto fail;
 -    }
 -
+     av_bitstream_filter_close(s->bsf);
+     return 0;
+ }
+ static av_cold int qsv_decode_init(AVCodecContext *avctx)
+ {
+     QSVH2645Context *s = avctx->priv_data;
+     int ret;
+     if (avctx->codec_id == AV_CODEC_ID_HEVC && s->load_plugin != LOAD_PLUGIN_NONE) {
+         static const char *uid_hevcenc_sw = "15dd936825ad475ea34e35f3f54217a6";
+         if (s->qsv.load_plugins[0]) {
+             av_log(avctx, AV_LOG_WARNING,
+                    "load_plugins is not empty, but load_plugin is not set to 'none'."
+                    "The load_plugin value will be ignored.\n");
+         } else {
+             av_freep(&s->qsv.load_plugins);
+             s->qsv.load_plugins = av_strdup(uid_hevcenc_sw);
+             if (!s->qsv.load_plugins)
+                 return AVERROR(ENOMEM);
+         }
+     }
 -    s->qsv.iopattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
 -
+     if (avctx->codec_id == AV_CODEC_ID_H264)
+         s->bsf = av_bitstream_filter_init("h264_mp4toannexb");
+     else
+         s->bsf = av_bitstream_filter_init("hevc_mp4toannexb");
+     if (!s->bsf) {
+         ret = AVERROR(ENOMEM);
+         goto fail;
+     }
 -    /* buffer the input packet */
+     return 0;
+ fail:
+     qsv_decode_close(avctx);
+     return ret;
+ }
+ static int qsv_decode_frame(AVCodecContext *avctx, void *data,
+                             int *got_frame, AVPacket *avpkt)
+ {
+     QSVH2645Context *s = avctx->priv_data;
+     AVFrame *frame    = data;
+     int ret;
++    uint8_t *p_filtered = NULL;
++    int      n_filtered = NULL;
++    AVPacket pkt_filtered = { 0 };
 -        AVPacket input_ref = { 0 };
+     if (avpkt->size) {
 -        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_process_data(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);
++        if (avpkt->size > 3 && !avpkt->data[0] &&
++            !avpkt->data[1] && !avpkt->data[2] && 1==avpkt->data[3]) {
++            /* we already have annex-b prefix */
++            return ff_qsv_decode(avctx, &s->qsv, frame, got_frame, avpkt);
 -                                             &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;
++        } else {
++            /* no annex-b prefix. try to restore: */
+             ret = av_bitstream_filter_filter(s->bsf, avctx, NULL,
 -            s->pkt_filtered      = s->input_ref;
 -            s->pkt_filtered.data = s->filtered_data;
 -            s->pkt_filtered.size = size;
++                                         &p_filtered, &n_filtered,
++                                         avpkt->data, avpkt->size, 0);
++            if (ret>=0) {
++                pkt_filtered.pts  = avpkt->pts;
++                pkt_filtered.data = p_filtered;
++                pkt_filtered.size = n_filtered;
++
++                ret = ff_qsv_decode(avctx, &s->qsv, frame, got_frame, &pkt_filtered);
++
++                if (p_filtered != avpkt->data)
++                    av_free(p_filtered);
++                return ret > 0 ? avpkt->size : ret;
+             }
 -
 -        ret = ff_qsv_process_data(avctx, &s->qsv, frame, got_frame, &s->pkt_filtered);
 -        if (ret < 0)
 -            return ret;
 -
 -        s->pkt_filtered.size -= ret;
 -        s->pkt_filtered.data += ret;
+         }
 -    return avpkt->size;
+     }
 -    QSVH2645Context *s = avctx->priv_data;
 -
 -    qsv_clear_buffers(s);
 -    ff_qsv_decode_flush(avctx, &s->qsv);
++    return ff_qsv_decode(avctx, &s->qsv, frame, got_frame, avpkt);
+ }
+ static void qsv_decode_flush(AVCodecContext *avctx)
+ {
++//    QSVH2645Context *s = avctx->priv_data;
++    /* TODO: flush qsv engine if necessary */
+ }
+ #define OFFSET(x) offsetof(QSVH2645Context, x)
+ #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
+ #if CONFIG_HEVC_QSV_DECODER
+ AVHWAccel ff_hevc_qsv_hwaccel = {
+     .name           = "hevc_qsv",
+     .type           = AVMEDIA_TYPE_VIDEO,
+     .id             = AV_CODEC_ID_HEVC,
+     .pix_fmt        = AV_PIX_FMT_QSV,
+ };
+ static const AVOption hevc_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 },
+     { "load_plugin", "A user plugin to load in an internal session", OFFSET(load_plugin), AV_OPT_TYPE_INT, { .i64 = LOAD_PLUGIN_HEVC_SW }, LOAD_PLUGIN_NONE, LOAD_PLUGIN_HEVC_SW, VD, "load_plugin" },
+     { "none",     NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LOAD_PLUGIN_NONE },    0, 0, VD, "load_plugin" },
+     { "hevc_sw",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LOAD_PLUGIN_HEVC_SW }, 0, 0, VD, "load_plugin" },
+     { "load_plugins", "A :-separate list of hexadecimal plugin UIDs to load in an internal session",
+         OFFSET(qsv.load_plugins), AV_OPT_TYPE_STRING, { .str = "" }, 0, 0, VD },
+     { NULL },
+ };
+ static const AVClass hevc_class = {
+     .class_name = "hevc_qsv",
+     .item_name  = av_default_item_name,
+     .option     = hevc_options,
+     .version    = LIBAVUTIL_VERSION_INT,
+ };
+ AVCodec ff_hevc_qsv_decoder = {
+     .name           = "hevc_qsv",
+     .long_name      = NULL_IF_CONFIG_SMALL("HEVC (Intel Quick Sync Video acceleration)"),
+     .priv_data_size = sizeof(QSVH2645Context),
+     .type           = AVMEDIA_TYPE_VIDEO,
+     .id             = AV_CODEC_ID_HEVC,
+     .init           = qsv_decode_init,
+     .decode         = qsv_decode_frame,
+     .flush          = qsv_decode_flush,
+     .close          = qsv_decode_close,
+     .capabilities   = CODEC_CAP_DELAY,
+     .priv_class     = &hevc_class,
+ };
+ #endif
+ #if CONFIG_H264_QSV_DECODER
+ AVHWAccel ff_h264_qsv_hwaccel = {
+     .name           = "h264_qsv",
+     .type           = AVMEDIA_TYPE_VIDEO,
+     .id             = AV_CODEC_ID_H264,
+     .pix_fmt        = AV_PIX_FMT_QSV,
+ };
+ 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(QSVH2645Context),
+     .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,
+ };
+ #endif
@@@ -29,8 -29,8 +29,8 @@@
  #include "libavutil/version.h"
  
  #define LIBAVCODEC_VERSION_MAJOR 56
- #define LIBAVCODEC_VERSION_MINOR  54
 -#define LIBAVCODEC_VERSION_MINOR 34
 -#define LIBAVCODEC_VERSION_MICRO  0
++#define LIBAVCODEC_VERSION_MINOR  55
 +#define LIBAVCODEC_VERSION_MICRO 100
  
  #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
                                                 LIBAVCODEC_VERSION_MINOR, \