Big merge, QSV to trunk: part 2 (new files).

git-svn-id: svn://svn.handbrake.fr/HandBrake/trunk@5738 b64f7644-9d1e-0410-96f1-a4d463321fa5

11 files changed, 4385 insertions, 0 deletions

diff --git a/libhb/enc_qsv.c b/libhb/enc_qsv.c
new file mode 100644
index 000000000..c1c832a81
--- /dev/null
+++ b/libhb/enc_qsv.c
@@ -0,0 +1,1543 @@
+/* ********************************************************************* *\
+
+Copyright (C) 2013 Intel Corporation.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+- Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+- Neither the name of Intel Corporation nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL INTEL CORPORATION BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+\* ********************************************************************* */
+
+#include "hb.h"
+#include "enc_qsv.h"
+#include "qsv_common.h"
+#include "qsv_memory.h"
+#include "h264_common.h"
+
+int  encqsvInit( hb_work_object_t *, hb_job_t * );
+int  encqsvWork( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
+void encqsvClose( hb_work_object_t * );
+
+hb_work_object_t hb_encqsv =
+{
+    WORK_ENCQSV,
+    "H.264/AVC encoder (Intel QSV)",
+    encqsvInit,
+    encqsvWork,
+    encqsvClose
+};
+
+struct hb_work_private_s
+{
+    hb_job_t *job;
+    uint32_t  frames_in;
+    uint32_t  frames_out;
+    int64_t   last_start;
+
+    hb_qsv_param_t param;
+    av_qsv_space enc_space;
+
+    mfxEncodeCtrl force_keyframe;
+    struct
+    {
+        int     index;
+        int64_t start;
+    } next_chapter;
+
+#define BFRM_DELAY_MAX 16
+    // for DTS generation (when MSDK API < 1.6 or VFR)
+    int            bfrm_delay;
+    int            bfrm_workaround;
+    int64_t        init_pts[BFRM_DELAY_MAX + 1];
+    hb_list_t     *list_dts;
+
+    int async_depth;
+    int max_async_depth;
+
+    // if encode-only, system memory used
+    int is_sys_mem;
+    struct SwsContext *sws_context_to_nv12;
+
+    // whether to expect input from VPP or from QSV decode
+    int is_vpp_present;
+
+    // whether the encoder is initialized
+    int init_done;
+
+    hb_list_t *delayed_processing;
+};
+
+// for DTS generation (when MSDK API < 1.6 or VFR)
+static void hb_qsv_add_new_dts(hb_list_t *list, int64_t new_dts)
+{
+    if (list != NULL)
+    {
+        int64_t *item = malloc(sizeof(int64_t));
+        if (item != NULL)
+        {
+            *item = new_dts;
+            hb_list_add(list, item);
+        }
+    }
+}
+static int64_t hb_qsv_pop_next_dts(hb_list_t *list)
+{
+    int64_t next_dts = INT64_MIN;
+    if (list != NULL && hb_list_count(list) > 0)
+    {
+        int64_t *item = hb_list_item(list, 0);
+        if (item != NULL)
+        {
+            next_dts = *item;
+            hb_list_rem(list, item);
+            free(item);
+        }
+    }
+    return next_dts;
+}
+
+static const char* qsv_h264_profile_xlat(int profile)
+{
+    switch (profile)
+    {
+        case MFX_PROFILE_AVC_CONSTRAINED_BASELINE:
+            return "Constrained Baseline";
+        case MFX_PROFILE_AVC_BASELINE:
+            return "Baseline";
+        case MFX_PROFILE_AVC_EXTENDED:
+            return "Extended";
+        case MFX_PROFILE_AVC_MAIN:
+            return "Main";
+        case MFX_PROFILE_AVC_CONSTRAINED_HIGH:
+            return "Constrained High";
+        case MFX_PROFILE_AVC_PROGRESSIVE_HIGH:
+            return "Progressive High";
+        case MFX_PROFILE_AVC_HIGH:
+            return "High";
+        case MFX_PROFILE_UNKNOWN:
+        default:
+            return NULL;
+    }
+}
+
+static const char* qsv_h264_level_xlat(int level)
+{
+    int i;
+    for (i = 0; hb_h264_level_names[i] != NULL; i++)
+    {
+        if (hb_h264_level_values[i] == level)
+        {
+            return hb_h264_level_names[i];
+        }
+    }
+    return NULL;
+}
+
+int qsv_enc_init(av_qsv_context *qsv, hb_work_private_t *pv)
+{
+    int i = 0;
+    mfxStatus sts;
+    hb_job_t *job = pv->job;
+
+    if (pv->init_done)
+    {
+        return 0;
+    }
+
+    if (qsv == NULL)
+    {
+        if (!pv->is_sys_mem)
+        {
+            hb_error("qsv_enc_init: decode enabled but no context!");
+            return 3;
+        }
+        job->qsv = qsv = av_mallocz(sizeof(av_qsv_context));
+    }
+
+    av_qsv_space *qsv_encode = qsv->enc_space;
+    if (qsv_encode == NULL)
+    {
+        // if only for encode
+        if (pv->is_sys_mem)
+        {
+            // no need to use additional sync as encode only -> single thread
+            // XXX: this zeroes the session handle, so call it before MFXInit
+            av_qsv_add_context_usage(qsv, 0);
+
+            // initialize the session
+            qsv->impl      = MFX_IMPL_AUTO_ANY;
+            qsv->ver.Major = AV_QSV_MSDK_VERSION_MAJOR;
+            qsv->ver.Minor = AV_QSV_MSDK_VERSION_MINOR;
+            sts = MFXInit(qsv->impl, &qsv->ver, &qsv->mfx_session);
+            if (sts != MFX_ERR_NONE)
+            {
+                hb_error("qsv_enc_init: MFXInit failed (%d)", sts);
+                *job->die = 1;
+                return -1;
+            }
+        }
+        qsv->enc_space = qsv_encode = &pv->enc_space;
+    }
+
+    if (!pv->is_sys_mem)
+    {
+        if (!pv->is_vpp_present && job->list_filter != NULL)
+        {
+            for (i = 0; i < hb_list_count(job->list_filter); i++)
+            {
+                hb_filter_object_t *filter = hb_list_item(job->list_filter, i);
+                if (filter->id == HB_FILTER_QSV_PRE  ||
+                    filter->id == HB_FILTER_QSV_POST ||
+                    filter->id == HB_FILTER_QSV)
+                {
+                    pv->is_vpp_present = 1;
+                    break;
+                }
+            }
+        }
+
+        if (pv->is_vpp_present)
+        {
+            if (qsv->vpp_space == NULL)
+            {
+                return 2;
+            }
+            for (i = 0; i < av_qsv_list_count(qsv->vpp_space); i++)
+            {
+                av_qsv_space *vpp = av_qsv_list_item(qsv->vpp_space, i);
+                if (!vpp->is_init_done)
+                {
+                    return 2;
+                }
+            }
+        }
+
+        av_qsv_space *dec_space = qsv->dec_space;
+        if (dec_space == NULL || !dec_space->is_init_done)
+        {
+            return 2;
+        }
+    }
+    else
+    {
+        pv->sws_context_to_nv12 = hb_sws_get_context(job->width, job->height,
+                                                     AV_PIX_FMT_YUV420P,
+                                                     job->width, job->height,
+                                                     AV_PIX_FMT_NV12,
+                                                     SWS_LANCZOS|SWS_ACCURATE_RND);
+    }
+
+    // allocate tasks
+    qsv_encode->p_buf_max_size = AV_QSV_BUF_SIZE_DEFAULT;
+    qsv_encode->tasks          = av_qsv_list_init(HAVE_THREADS);
+    for (i = 0; i < pv->max_async_depth; i++)
+    {
+        av_qsv_task *task    = av_mallocz(sizeof(av_qsv_task));
+        task->bs             = av_mallocz(sizeof(mfxBitstream));
+        task->bs->Data       = av_mallocz(sizeof(uint8_t) * qsv_encode->p_buf_max_size);
+        task->bs->MaxLength  = qsv_encode->p_buf_max_size;
+        task->bs->DataLength = 0;
+        task->bs->DataOffset = 0;
+        av_qsv_list_add(qsv_encode->tasks, task);
+    }
+
+    // setup surface allocation
+    qsv_encode->m_mfxVideoParam.IOPattern = (pv->is_sys_mem                 ?
+                                             MFX_IOPATTERN_IN_SYSTEM_MEMORY :
+                                             MFX_IOPATTERN_IN_OPAQUE_MEMORY);
+    memset(&qsv_encode->request, 0, sizeof(mfxFrameAllocRequest) * 2);
+    sts = MFXVideoENCODE_QueryIOSurf(qsv->mfx_session,
+                                     &qsv_encode->m_mfxVideoParam,
+                                     &qsv_encode->request);
+    if (sts < MFX_ERR_NONE) // ignore warnings
+    {
+        hb_error("qsv_enc_init: MFXVideoENCODE_QueryIOSurf failed (%d)", sts);
+        *job->die = 1;
+        return -1;
+    }
+
+    // allocate surfaces
+    if (pv->is_sys_mem)
+    {
+        qsv_encode->surface_num = FFMIN(qsv_encode->request[0].NumFrameSuggested +
+                                        pv->max_async_depth, AV_QSV_SURFACE_NUM);
+        if (qsv_encode->surface_num <= 0)
+        {
+            qsv_encode->surface_num = AV_QSV_SURFACE_NUM;
+        }
+        for (i = 0; i < qsv_encode->surface_num; i++)
+        {
+            qsv_encode->p_surfaces[i] = av_mallocz(sizeof(mfxFrameSurface1));
+            AV_QSV_CHECK_POINTER(qsv_encode->p_surfaces[i], MFX_ERR_MEMORY_ALLOC);
+            memcpy(&(qsv_encode->p_surfaces[i]->Info),
+                   &(qsv_encode->request[0].Info), sizeof(mfxFrameInfo));
+        }
+    }
+    else
+    {
+        av_qsv_space *in_space = qsv->dec_space;
+        if (pv->is_vpp_present)
+        {
+            // we get our input from VPP instead
+            in_space = av_qsv_list_item(qsv->vpp_space,
+                                        av_qsv_list_count(qsv->vpp_space) - 1);
+        }
+        // introduced in API 1.3
+        memset(&qsv_encode->ext_opaque_alloc, 0, sizeof(mfxExtOpaqueSurfaceAlloc));
+        qsv_encode->ext_opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
+        qsv_encode->ext_opaque_alloc.Header.BufferSz = sizeof(mfxExtOpaqueSurfaceAlloc);
+        qsv_encode->ext_opaque_alloc.In.Surfaces     = in_space->p_surfaces;
+        qsv_encode->ext_opaque_alloc.In.NumSurface   = in_space->surface_num;
+        qsv_encode->ext_opaque_alloc.In.Type         = qsv_encode->request[0].Type;
+        qsv_encode->m_mfxVideoParam.ExtParam[qsv_encode->m_mfxVideoParam.NumExtParam++] = (mfxExtBuffer*)&qsv_encode->ext_opaque_alloc;
+    }
+
+    // allocate sync points
+    qsv_encode->sync_num = (qsv_encode->surface_num                         ?
+                            FFMIN(qsv_encode->surface_num, AV_QSV_SYNC_NUM) :
+                            AV_QSV_SYNC_NUM);
+    for (i = 0; i < qsv_encode->sync_num; i++)
+    {
+        qsv_encode->p_syncp[i] = av_mallocz(sizeof(av_qsv_sync));
+        AV_QSV_CHECK_POINTER(qsv_encode->p_syncp[i], MFX_ERR_MEMORY_ALLOC);
+        qsv_encode->p_syncp[i]->p_sync = av_mallocz(sizeof(mfxSyncPoint));
+        AV_QSV_CHECK_POINTER(qsv_encode->p_syncp[i]->p_sync, MFX_ERR_MEMORY_ALLOC);
+    }
+
+    // initialize the encoder
+    sts = MFXVideoENCODE_Init(qsv->mfx_session, &qsv_encode->m_mfxVideoParam);
+    if (sts < MFX_ERR_NONE) // ignore warnings
+    {
+        hb_error("qsv_enc_init: MFXVideoENCODE_Init failed (%d)", sts);
+        *job->die = 1;
+        return -1;
+    }
+    qsv_encode->is_init_done = 1;
+
+    pv->init_done = 1;
+    return 0;
+}
+
+/***********************************************************************
+ * encqsvInit
+ ***********************************************************************
+ *
+ **********************************************************************/
+int encqsvInit(hb_work_object_t *w, hb_job_t *job)
+{
+    hb_work_private_t *pv = calloc(1, sizeof(hb_work_private_t));
+    w->private_data       = pv;
+
+    pv->job                = job;
+    pv->is_sys_mem         = !hb_qsv_decode_is_enabled(job);
+    pv->delayed_processing = hb_list_init();
+    pv->last_start         = INT64_MIN;
+    pv->frames_in          = 0;
+    pv->frames_out         = 0;
+    pv->init_done          = 0;
+    pv->is_vpp_present     = 0;
+
+    // set up a re-usable mfxEncodeCtrl to force keyframes (e.g. for chapters)
+    pv->force_keyframe.QP          = 0;
+    pv->force_keyframe.FrameType   = MFX_FRAMETYPE_I|MFX_FRAMETYPE_IDR|MFX_FRAMETYPE_REF;
+    pv->force_keyframe.NumExtParam = 0;
+    pv->force_keyframe.NumPayload  = 0;
+    pv->force_keyframe.ExtParam    = NULL;
+    pv->force_keyframe.Payload     = NULL;
+
+    pv->next_chapter.index = 0;
+    pv->next_chapter.start = INT64_MIN;
+
+    // default encoding parameters
+    if (hb_qsv_param_default(&pv->param, &pv->enc_space.m_mfxVideoParam))
+    {
+        hb_error("encqsvInit: hb_qsv_param_default failed");
+        return -1;
+    }
+
+    // set AsyncDepth to match that of decode and VPP
+    pv->param.videoParam->AsyncDepth = job->qsv_async_depth;
+
+    // enable and set colorimetry (video signal information)
+    pv->param.videoSignalInfo.ColourDescriptionPresent = 1;
+    switch (job->color_matrix_code)
+    {
+        case 4:
+            // custom
+            pv->param.videoSignalInfo.ColourPrimaries         = job->color_prim;
+            pv->param.videoSignalInfo.TransferCharacteristics = job->color_transfer;
+            pv->param.videoSignalInfo.MatrixCoefficients      = job->color_matrix;
+            break;
+        case 3:
+            // ITU BT.709 HD content
+            pv->param.videoSignalInfo.ColourPrimaries         = HB_COLR_PRI_BT709;
+            pv->param.videoSignalInfo.TransferCharacteristics = HB_COLR_TRA_BT709;
+            pv->param.videoSignalInfo.MatrixCoefficients      = HB_COLR_MAT_BT709;
+            break;
+        case 2:
+            // ITU BT.601 DVD or SD TV content (PAL)
+            pv->param.videoSignalInfo.ColourPrimaries         = HB_COLR_PRI_EBUTECH;
+            pv->param.videoSignalInfo.TransferCharacteristics = HB_COLR_TRA_BT709;
+            pv->param.videoSignalInfo.MatrixCoefficients      = HB_COLR_MAT_SMPTE170M;
+            break;
+        case 1:
+            // ITU BT.601 DVD or SD TV content (NTSC)
+            pv->param.videoSignalInfo.ColourPrimaries         = HB_COLR_PRI_SMPTEC;
+            pv->param.videoSignalInfo.TransferCharacteristics = HB_COLR_TRA_BT709;
+            pv->param.videoSignalInfo.MatrixCoefficients      = HB_COLR_MAT_SMPTE170M;
+            break;
+        default:
+            // detected during scan
+            pv->param.videoSignalInfo.ColourPrimaries         = job->title->color_prim;
+            pv->param.videoSignalInfo.TransferCharacteristics = job->title->color_transfer;
+            pv->param.videoSignalInfo.MatrixCoefficients      = job->title->color_matrix;
+            break;
+    }
+
+    // parse user-specified advanced options, if present
+    if (job->advanced_opts != NULL && job->advanced_opts[0] != '\0')
+    {
+        hb_dict_t *options_list;
+        hb_dict_entry_t *option = NULL;
+        options_list = hb_encopts_to_dict(job->advanced_opts, job->vcodec);
+        while ((option = hb_dict_next(options_list, option)) != NULL)
+        {
+            switch (hb_qsv_param_parse(&pv->param,
+                                       option->key, option->value, job->vcodec))
+            {
+                case HB_QSV_PARAM_OK:
+                    break;
+
+                case HB_QSV_PARAM_BAD_NAME:
+                    hb_log("encqsvInit: hb_qsv_param_parse: bad key %s",
+                           option->key);
+                    break;
+                case HB_QSV_PARAM_BAD_VALUE:
+                    hb_log("encqsvInit: hb_qsv_param_parse: bad value %s for key %s",
+                           option->value, option->key);
+                    break;
+                case HB_QSV_PARAM_UNSUPPORTED:
+                    hb_log("encqsvInit: hb_qsv_param_parse: unsupported option %s",
+                           option->key);
+                    break;
+
+                case HB_QSV_PARAM_ERROR:
+                default:
+                    hb_log("encqsvInit: hb_qsv_param_parse: unknown error");
+                    break;
+            }
+        }
+        hb_dict_free(&options_list);
+    }
+
+    // reload colorimetry in case values were set in advanced_opts
+    if (pv->param.videoSignalInfo.ColourDescriptionPresent)
+    {
+        job->color_matrix_code = 4;
+        job->color_prim        = pv->param.videoSignalInfo.ColourPrimaries;
+        job->color_transfer    = pv->param.videoSignalInfo.TransferCharacteristics;
+        job->color_matrix      = pv->param.videoSignalInfo.MatrixCoefficients;
+    }
+    else
+    {
+        job->color_matrix_code = 0;
+        job->color_prim        = HB_COLR_PRI_UNDEF;
+        job->color_transfer    = HB_COLR_TRA_UNDEF;
+        job->color_matrix      = HB_COLR_MAT_UNDEF;
+    }
+
+    // sanitize values that may exceed the Media SDK variable size
+    int64_t vrate, vrate_base;
+    int64_t par_width, par_height;
+    hb_limit_rational64(&vrate, &vrate_base,
+                        job->vrate, job->vrate_base, UINT32_MAX);
+    hb_limit_rational64(&par_width, &par_height,
+                        job->anamorphic.par_width,
+                        job->anamorphic.par_height, UINT16_MAX);
+
+    // some encoding parameters are used by filters to configure their output
+    if (pv->param.videoParam->mfx.FrameInfo.PicStruct != MFX_PICSTRUCT_PROGRESSIVE)
+    {
+        job->qsv_enc_info.align_height = AV_QSV_ALIGN32(job->height);
+    }
+    else
+    {
+        job->qsv_enc_info.align_height = AV_QSV_ALIGN16(job->height);
+    }
+    job->qsv_enc_info.align_width  = AV_QSV_ALIGN16(job->width);
+    job->qsv_enc_info.pic_struct   = pv->param.videoParam->mfx.FrameInfo.PicStruct;
+    job->qsv_enc_info.is_init_done = 1;
+
+    // encode to H.264 and set FrameInfo
+    pv->param.videoParam->mfx.CodecId                 = MFX_CODEC_AVC;
+    pv->param.videoParam->mfx.CodecLevel              = MFX_LEVEL_UNKNOWN;
+    pv->param.videoParam->mfx.CodecProfile            = MFX_PROFILE_UNKNOWN;
+    pv->param.videoParam->mfx.FrameInfo.FourCC        = MFX_FOURCC_NV12;
+    pv->param.videoParam->mfx.FrameInfo.ChromaFormat  = MFX_CHROMAFORMAT_YUV420;
+    pv->param.videoParam->mfx.FrameInfo.FrameRateExtN = vrate;
+    pv->param.videoParam->mfx.FrameInfo.FrameRateExtD = vrate_base;
+    pv->param.videoParam->mfx.FrameInfo.AspectRatioW  = par_width;
+    pv->param.videoParam->mfx.FrameInfo.AspectRatioH  = par_height;
+    pv->param.videoParam->mfx.FrameInfo.CropX         = 0;
+    pv->param.videoParam->mfx.FrameInfo.CropY         = 0;
+    pv->param.videoParam->mfx.FrameInfo.CropW         = job->width;
+    pv->param.videoParam->mfx.FrameInfo.CropH         = job->height;
+    pv->param.videoParam->mfx.FrameInfo.PicStruct     = job->qsv_enc_info.pic_struct;
+    pv->param.videoParam->mfx.FrameInfo.Width         = job->qsv_enc_info.align_width;
+    pv->param.videoParam->mfx.FrameInfo.Height        = job->qsv_enc_info.align_height;
+
+    // set H.264 profile and level
+    if (job->h264_profile != NULL && job->h264_profile[0] != '\0' &&
+        strcasecmp(job->h264_profile, "auto"))
+    {
+        if (!strcasecmp(job->h264_profile, "baseline"))
+        {
+            pv->param.videoParam->mfx.CodecProfile = MFX_PROFILE_AVC_BASELINE;
+        }
+        else if (!strcasecmp(job->h264_profile, "main"))
+        {
+            pv->param.videoParam->mfx.CodecProfile = MFX_PROFILE_AVC_MAIN;
+        }
+        else if (!strcasecmp(job->h264_profile, "high"))
+        {
+            pv->param.videoParam->mfx.CodecProfile = MFX_PROFILE_AVC_HIGH;
+        }
+        else
+        {
+            hb_error("encqsvInit: bad profile %s", job->h264_profile);
+            return -1;
+        }
+    }
+    if (job->h264_level != NULL && job->h264_level[0] != '\0' &&
+        strcasecmp(job->h264_level, "auto"))
+    {
+        int err;
+        int i = hb_qsv_atoindex(hb_h264_level_names, job->h264_level, &err);
+        if (err || i >= (sizeof(hb_h264_level_values) /
+                         sizeof(hb_h264_level_values[0])))
+        {
+            hb_error("encqsvInit: bad level %s", job->h264_level);
+            return -1;
+        }
+        else if (hb_qsv_info->capabilities & HB_QSV_CAP_MSDK_API_1_6)
+        {
+            pv->param.videoParam->mfx.CodecLevel = HB_QSV_CLIP3(MFX_LEVEL_AVC_1,
+                                                                MFX_LEVEL_AVC_52,
+                                                                hb_h264_level_values[i]);
+        }
+        else
+        {
+            // Media SDK API < 1.6, MFX_LEVEL_AVC_52 unsupported
+            pv->param.videoParam->mfx.CodecLevel = HB_QSV_CLIP3(MFX_LEVEL_AVC_1,
+                                                                MFX_LEVEL_AVC_51,
+                                                                hb_h264_level_values[i]);
+        }
+    }
+
+    // interlaced encoding is not always possible
+    if (pv->param.videoParam->mfx.FrameInfo.PicStruct != MFX_PICSTRUCT_PROGRESSIVE)
+    {
+        if (pv->param.videoParam->mfx.CodecProfile == MFX_PROFILE_AVC_CONSTRAINED_BASELINE ||
+            pv->param.videoParam->mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE             ||
+            pv->param.videoParam->mfx.CodecProfile == MFX_PROFILE_AVC_PROGRESSIVE_HIGH)
+        {
+            hb_error("encqsvInit: profile %s doesn't support interlaced encoding",
+                     qsv_h264_profile_xlat(pv->param.videoParam->mfx.CodecProfile));
+            return -1;
+        }
+        if ((pv->param.videoParam->mfx.CodecLevel >= MFX_LEVEL_AVC_1b &&
+             pv->param.videoParam->mfx.CodecLevel <= MFX_LEVEL_AVC_2) ||
+            (pv->param.videoParam->mfx.CodecLevel >= MFX_LEVEL_AVC_42))
+        {
+            hb_error("encqsvInit: level %s doesn't support interlaced encoding",
+                     qsv_h264_level_xlat(pv->param.videoParam->mfx.CodecLevel));
+            return -1;
+        }
+    }
+
+    // set rate control paremeters
+    if (job->vquality >= 0)
+    {
+        // introduced in API 1.1
+        pv->param.videoParam->mfx.RateControlMethod = MFX_RATECONTROL_CQP;
+        pv->param.videoParam->mfx.QPI = HB_QSV_CLIP3(0, 51, job->vquality + pv->param.rc.cqp_offsets[0]);
+        pv->param.videoParam->mfx.QPP = HB_QSV_CLIP3(0, 51, job->vquality + pv->param.rc.cqp_offsets[1]);
+        pv->param.videoParam->mfx.QPB = HB_QSV_CLIP3(0, 51, job->vquality + pv->param.rc.cqp_offsets[2]);
+    }
+    else if (job->vbitrate > 0)
+    {
+        // sanitize lookahead
+        if (!(hb_qsv_info->capabilities & HB_QSV_CAP_OPTION2_LOOKAHEAD))
+        {
+            // lookahead not supported
+            pv->param.rc.lookahead = 0;
+        }
+        else if (pv->param.rc.lookahead > 0 &&
+                 pv->param.videoParam->mfx.FrameInfo.PicStruct != MFX_PICSTRUCT_PROGRESSIVE)
+        {
+            // user force-enabled lookahead but we can't use it
+            hb_log("encqsvInit: MFX_RATECONTROL_LA not used (LookAhead is progressive-only)");
+            pv->param.rc.lookahead = 0;
+        }
+        else if (pv->param.rc.lookahead < 0)
+        {
+            if (pv->param.rc.vbv_max_bitrate > 0 ||
+                pv->param.videoParam->mfx.FrameInfo.PicStruct != MFX_PICSTRUCT_PROGRESSIVE)
+            {
+                // lookahead doesn't support VBV or interlaced encoding
+                pv->param.rc.lookahead = 0;
+            }
+            else
+            {
+                // set automatically based on target usage
+                pv->param.rc.lookahead = (pv->param.videoParam->mfx.TargetUsage <= MFX_TARGETUSAGE_2);
+            }
+        }
+        else
+        {
+            // user force-enabled or force-disabled lookahead
+            pv->param.rc.lookahead = !!pv->param.rc.lookahead;
+        }
+        if (pv->param.rc.lookahead)
+        {
+            // introduced in API 1.7
+            pv->param.videoParam->mfx.RateControlMethod = MFX_RATECONTROL_LA;
+            pv->param.videoParam->mfx.TargetKbps        = job->vbitrate;
+            if (pv->param.rc.vbv_max_bitrate > 0)
+            {
+                hb_log("encqsvInit: MFX_RATECONTROL_LA, ignoring VBV");
+            }
+        }
+        else if (job->vbitrate == pv->param.rc.vbv_max_bitrate)
+        {
+            // introduced in API 1.0
+            pv->param.videoParam->mfx.RateControlMethod = MFX_RATECONTROL_CBR;
+            pv->param.videoParam->mfx.MaxKbps           = job->vbitrate;
+            pv->param.videoParam->mfx.TargetKbps        = job->vbitrate;
+            pv->param.videoParam->mfx.BufferSizeInKB    = (pv->param.rc.vbv_buffer_size / 8);
+            // only set BufferSizeInKB and InitialDelayInKB is bufsize is set
+            // else Media SDK will pick some good values for us automatically
+            if (pv->param.rc.vbv_buffer_size > 0)
+            {
+                if (pv->param.rc.vbv_buffer_init > 1.0)
+                {
+                    pv->param.videoParam->mfx.InitialDelayInKB = (pv->param.rc.vbv_buffer_init / 8);
+                }
+                else
+                {
+                    pv->param.videoParam->mfx.InitialDelayInKB = (pv->param.rc.vbv_buffer_size *
+                                                                  pv->param.rc.vbv_buffer_init / 8);
+                }
+                pv->param.videoParam->mfx.BufferSizeInKB = (pv->param.rc.vbv_buffer_size / 8);
+            }
+        }
+        else if (pv->param.rc.vbv_max_bitrate > 0)
+        {
+            // introduced in API 1.0
+            pv->param.videoParam->mfx.RateControlMethod = MFX_RATECONTROL_VBR;
+            pv->param.videoParam->mfx.MaxKbps           = pv->param.rc.vbv_max_bitrate;
+            pv->param.videoParam->mfx.TargetKbps        = job->vbitrate;
+            // only set BufferSizeInKB and InitialDelayInKB is bufsize is set
+            // else Media SDK will pick some good values for us automatically
+            if (pv->param.rc.vbv_buffer_size > 0)
+            {
+                if (pv->param.rc.vbv_buffer_init > 1.0)
+                {
+                    pv->param.videoParam->mfx.InitialDelayInKB = (pv->param.rc.vbv_buffer_init / 8);
+                }
+                else
+                {
+                    pv->param.videoParam->mfx.InitialDelayInKB = (pv->param.rc.vbv_buffer_size *
+                                                                  pv->param.rc.vbv_buffer_init / 8);
+                }
+                pv->param.videoParam->mfx.BufferSizeInKB = (pv->param.rc.vbv_buffer_size / 8);
+            }
+        }
+        else
+        {
+            // introduced in API 1.3
+            // Media SDK will set Accuracy and Convergence for us automatically
+            pv->param.videoParam->mfx.RateControlMethod = MFX_RATECONTROL_AVBR;
+            pv->param.videoParam->mfx.TargetKbps        = job->vbitrate;
+        }
+    }
+    else
+    {
+        hb_error("encqsvInit: invalid rate control (%d, %d)",
+                 job->vquality, job->vbitrate);
+        return -1;
+    }
+
+    // set the keyframe interval
+    if (pv->param.gop.gop_pic_size < 0)
+    {
+        int rate = (int)((double)job->vrate / (double)job->vrate_base + 0.5);
+        if (pv->param.videoParam->mfx.RateControlMethod == MFX_RATECONTROL_CQP)
+        {
+            // ensure B-pyramid is enabled for CQP on Haswell
+            pv->param.gop.gop_pic_size = 32;
+        }
+        else
+        {
+            // set the keyframe interval based on the framerate
+            pv->param.gop.gop_pic_size = 5 * rate + 1;
+        }
+    }
+    pv->param.videoParam->mfx.GopPicSize = pv->param.gop.gop_pic_size;
+
+    // sanitize some settings that affect memory consumption
+    if (!pv->is_sys_mem)
+    {
+        // limit these to avoid running out of resources (causes hang)
+        pv->param.videoParam->mfx.GopRefDist   = FFMIN(pv->param.videoParam->mfx.GopRefDist,
+                                                       pv->param.rc.lookahead ? 8 : 16);
+        pv->param.codingOption2.LookAheadDepth = FFMIN(pv->param.codingOption2.LookAheadDepth,
+                                                       pv->param.rc.lookahead ? 48 - pv->param.videoParam->mfx.GopRefDist : 0);
+    }
+    else
+    {
+        // encode-only is a bit less sensitive to memory issues
+        pv->param.videoParam->mfx.GopRefDist   = FFMIN(pv->param.videoParam->mfx.GopRefDist, 16);
+        pv->param.codingOption2.LookAheadDepth = FFMIN(pv->param.codingOption2.LookAheadDepth,
+                                                       pv->param.rc.lookahead ? 60 : 0);
+    }
+
+    /*
+     * init a dummy encode-only session to get the SPS/PPS
+     * and the final output settings sanitized by Media SDK
+     * this is fine since the actual encode will use the same
+     * values for all parameters relevant to the H.264 bitstream
+     */
+    mfxIMPL impl;
+    mfxStatus err;
+    mfxVersion version;
+    mfxVideoParam videoParam;
+    mfxExtBuffer* ExtParamArray[3];
+    mfxSession session = (mfxSession)0;
+    mfxExtCodingOption  option1_buf, *option1 = &option1_buf;
+    mfxExtCodingOption2 option2_buf, *option2 = &option2_buf;
+    mfxExtCodingOptionSPSPPS sps_pps_buf, *sps_pps = &sps_pps_buf;
+    impl          = MFX_IMPL_AUTO_ANY|MFX_IMPL_VIA_ANY;
+    version.Major = HB_QSV_MINVERSION_MAJOR;
+    version.Minor = HB_QSV_MINVERSION_MINOR;
+    err = MFXInit(impl, &version, &session);
+    if (err != MFX_ERR_NONE)
+    {
+        hb_error("encqsvInit: MFXInit failed (%d)", err);
+        return -1;
+    }
+    err = MFXVideoENCODE_Init(session, pv->param.videoParam);
+    if (err < MFX_ERR_NONE) // ignore warnings
+    {
+        hb_error("encqsvInit: MFXVideoENCODE_Init failed (%d)", err);
+        MFXClose(session);
+        return -1;
+    }
+    memset(&videoParam, 0, sizeof(mfxVideoParam));
+    videoParam.ExtParam = ExtParamArray;
+    videoParam.NumExtParam = 0;
+    // introduced in API 1.3
+    memset(sps_pps, 0, sizeof(mfxExtCodingOptionSPSPPS));
+    sps_pps->Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS;
+    sps_pps->Header.BufferSz = sizeof(mfxExtCodingOptionSPSPPS);
+    sps_pps->SPSId           = 0;
+    sps_pps->SPSBuffer       = w->config->h264.sps;
+    sps_pps->SPSBufSize      = sizeof(w->config->h264.sps);
+    sps_pps->PPSId           = 0;
+    sps_pps->PPSBuffer       = w->config->h264.pps;
+    sps_pps->PPSBufSize      = sizeof(w->config->h264.pps);
+    videoParam.ExtParam[videoParam.NumExtParam++] = (mfxExtBuffer*)sps_pps;
+    // introduced in API 1.0
+    memset(option1, 0, sizeof(mfxExtCodingOption));
+    option1->Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
+    option1->Header.BufferSz = sizeof(mfxExtCodingOption);
+    videoParam.ExtParam[videoParam.NumExtParam++] = (mfxExtBuffer*)option1;
+    // introduced in API 1.6
+    memset(option2, 0, sizeof(mfxExtCodingOption2));
+    option2->Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
+    option2->Header.BufferSz = sizeof(mfxExtCodingOption2);
+    if (hb_qsv_info->capabilities & HB_QSV_CAP_MSDK_API_1_6)
+    {
+        // attach to get the final output mfxExtCodingOption2 settings
+        videoParam.ExtParam[videoParam.NumExtParam++] = (mfxExtBuffer*)option2;
+    }
+    err = MFXVideoENCODE_GetVideoParam(session, &videoParam);
+    if (err == MFX_ERR_NONE)
+    {
+        // remove 32-bit NAL prefix (0x00 0x00 0x00 0x01)
+        w->config->h264.sps_length = sps_pps->SPSBufSize - 4;
+        memmove(w->config->h264.sps, w->config->h264.sps + 4,
+                w->config->h264.sps_length);
+        w->config->h264.pps_length = sps_pps->PPSBufSize - 4;
+        memmove(w->config->h264.pps, w->config->h264.pps + 4,
+                w->config->h264.pps_length);
+    }
+    else
+    {
+        hb_error("encqsvInit: MFXVideoENCODE_GetVideoParam failed (%d)", err);
+        MFXVideoENCODE_Close(session);
+        MFXClose            (session);
+        return -1;
+    }
+
+    // log implementation details before closing this session
+    if (pv->is_sys_mem)
+    {
+        hb_log("encqsvInit: using encode-only path");
+    }
+    if ((MFXQueryIMPL   (session, &impl)    == MFX_ERR_NONE) &&
+        (MFXQueryVersion(session, &version) == MFX_ERR_NONE))
+    {
+        hb_log("encqsvInit: using %s implementation (%"PRIu16".%"PRIu16")",
+               impl == MFX_IMPL_SOFTWARE ? "software" : "hardware",
+               version.Major, version.Minor);
+    }
+    MFXVideoENCODE_Close(session);
+    MFXClose            (session);
+
+    // log main output settings
+    hb_log("encqsvInit: TargetUsage %"PRIu16" AsyncDepth %"PRIu16"",
+           videoParam.mfx.TargetUsage, videoParam.AsyncDepth);
+    hb_log("encqsvInit: GopRefDist %"PRIu16" GopPicSize %"PRIu16" NumRefFrame %"PRIu16"",
+           videoParam.mfx.GopRefDist, videoParam.mfx.GopPicSize, videoParam.mfx.NumRefFrame);
+    if (videoParam.mfx.RateControlMethod == MFX_RATECONTROL_CQP)
+    {
+        char qpi[7], qpp[9], qpb[9];
+        snprintf(qpi, sizeof(qpi),  "QPI %"PRIu16"", videoParam.mfx.QPI);
+        snprintf(qpp, sizeof(qpp), " QPP %"PRIu16"", videoParam.mfx.QPP);
+        snprintf(qpb, sizeof(qpb), " QPB %"PRIu16"", videoParam.mfx.QPB);
+        hb_log("encqsvInit: RateControlMethod CQP with %s%s%s", qpi,
+               videoParam.mfx.GopPicSize > 1 ? qpp : "",
+               videoParam.mfx.GopRefDist > 1 ? qpb : "");
+    }
+    else
+    {
+        switch (videoParam.mfx.RateControlMethod)
+        {
+            case MFX_RATECONTROL_AVBR:
+                hb_log("encqsvInit: RateControlMethod AVBR TargetKbps %"PRIu16"",
+                       videoParam.mfx.TargetKbps);
+                break;
+            case MFX_RATECONTROL_LA:
+                hb_log("encqsvInit: RateControlMethod LA TargetKbps %"PRIu16" LookAheadDepth %"PRIu16"",
+                       videoParam.mfx.TargetKbps, option2->LookAheadDepth);
+                break;
+            case MFX_RATECONTROL_CBR:
+            case MFX_RATECONTROL_VBR:
+                hb_log("encqsvInit: RateControlMethod %s TargetKbps %"PRIu16" MaxKbps %"PRIu16" BufferSizeInKB %"PRIu16" InitialDelayInKB %"PRIu16"",
+                       videoParam.mfx.RateControlMethod == MFX_RATECONTROL_CBR ? "CBR" : "VBR",
+                       videoParam.mfx.TargetKbps,     videoParam.mfx.MaxKbps,
+                       videoParam.mfx.BufferSizeInKB, videoParam.mfx.InitialDelayInKB);
+                break;
+            default:
+                hb_log("encqsvInit: invalid rate control method %"PRIu16"",
+                       videoParam.mfx.RateControlMethod);
+                return -1;
+        }
+    }
+    switch (videoParam.mfx.FrameInfo.PicStruct)
+    {
+        case MFX_PICSTRUCT_PROGRESSIVE:
+            hb_log("encqsvInit: PicStruct progressive");
+            break;
+        case MFX_PICSTRUCT_FIELD_TFF:
+            hb_log("encqsvInit: PicStruct top field first");
+            break;
+        case MFX_PICSTRUCT_FIELD_BFF:
+            hb_log("encqsvInit: PicStruct bottom field first");
+            break;
+        default:
+            hb_error("encqsvInit: invalid PicStruct value 0x%"PRIx16"",
+                     videoParam.mfx.FrameInfo.PicStruct);
+            return -1;
+    }
+    const char *cavlc, *rdopt;
+    switch (option1->CAVLC)
+    {
+        case MFX_CODINGOPTION_ON:
+            cavlc = "on";
+            break;
+        case MFX_CODINGOPTION_OFF:
+            cavlc = "off";
+            break;
+        default:
+            hb_error("encqsvInit: invalid CAVLC value %"PRIu16"",
+                     option1->CAVLC);
+            return -1;
+    }
+    switch (option1->RateDistortionOpt)
+    {
+        case MFX_CODINGOPTION_ON:
+            rdopt = "on";
+            break;
+        case MFX_CODINGOPTION_OFF:
+            rdopt = "off";
+            break;
+        default:
+            hb_error("encqsvInit: invalid RateDistortionOpt value %"PRIu16"",
+                     option1->RateDistortionOpt);
+            return -1;
+    }
+    hb_log("encqsvInit: CAVLC %s RateDistortionOpt %s", cavlc, rdopt);
+    if (hb_qsv_info->capabilities & HB_QSV_CAP_OPTION2_BRC)
+    {
+        const char *mbbrc, *extbrc;
+        switch (option2->MBBRC)
+        {
+            case MFX_CODINGOPTION_ON:
+                mbbrc = "on";
+                break;
+            case MFX_CODINGOPTION_OFF:
+                mbbrc = "off";
+                break;
+            case MFX_CODINGOPTION_ADAPTIVE:
+                mbbrc = "adaptive";
+                break;
+            case MFX_CODINGOPTION_UNKNOWN:
+                mbbrc = "unknown (auto)";
+                break;
+            default:
+                hb_error("encqsvInit: invalid MBBRC value %"PRIu16"",
+                         option2->MBBRC);
+                return -1;
+        }
+        switch (option2->ExtBRC)
+        {
+            case MFX_CODINGOPTION_ON:
+                extbrc = "on";
+                break;
+            case MFX_CODINGOPTION_OFF:
+                extbrc = "off";
+                break;
+            case MFX_CODINGOPTION_ADAPTIVE:
+                extbrc = "adaptive";
+                break;
+            case MFX_CODINGOPTION_UNKNOWN:
+                extbrc = "unknown (auto)";
+                break;
+            default:
+                hb_error("encqsvInit: invalid ExtBRC value %"PRIu16"",
+                         option2->ExtBRC);
+                return -1;
+        }
+        hb_log("encqsvInit: MBBRC %s ExtBRC %s", mbbrc, extbrc);
+    }
+    if (hb_qsv_info->capabilities & HB_QSV_CAP_OPTION2_TRELLIS)
+    {
+        switch (option2->Trellis)
+        {
+            case MFX_TRELLIS_OFF:
+                hb_log("encqsvInit: Trellis off");
+                break;
+            case MFX_TRELLIS_UNKNOWN:
+                hb_log("encqsvInit: Trellis unknown (auto)");
+                break;
+            default:
+                hb_log("encqsvInit: Trellis on (%s%s%s)",
+                       option2->Trellis & MFX_TRELLIS_I ? "I" : "",
+                       option2->Trellis & MFX_TRELLIS_P ? "P" : "",
+                       option2->Trellis & MFX_TRELLIS_B ? "B" : "");
+                break;
+        }
+    }
+    hb_log("encqsvInit: H.264 profile %s @ level %s",
+           qsv_h264_profile_xlat(videoParam.mfx.CodecProfile),
+           qsv_h264_level_xlat  (videoParam.mfx.CodecLevel));
+
+    // AsyncDepth has now been set and/or modified by Media SDK
+    pv->max_async_depth = videoParam.AsyncDepth;
+    pv->async_depth     = 0;
+
+    // check whether B-frames are used
+    switch (videoParam.mfx.CodecProfile)
+    {
+        case MFX_PROFILE_AVC_BASELINE:
+        case MFX_PROFILE_AVC_CONSTRAINED_HIGH:
+        case MFX_PROFILE_AVC_CONSTRAINED_BASELINE:
+            pv->bfrm_delay = 0;
+            break;
+        default:
+            pv->bfrm_delay = 1;
+            break;
+    }
+    // sanitize
+    pv->bfrm_delay = FFMIN(pv->bfrm_delay, videoParam.mfx.GopRefDist - 1);
+    pv->bfrm_delay = FFMIN(pv->bfrm_delay, videoParam.mfx.GopPicSize - 2);
+    pv->bfrm_delay = FFMAX(pv->bfrm_delay, 0);
+    // let the muxer know whether to expect B-frames or not
+    job->areBframes = !!pv->bfrm_delay;
+    // check whether we need to generate DTS ourselves (MSDK API < 1.6 or VFR)
+    pv->bfrm_workaround = job->cfr != 1 || !(hb_qsv_info->capabilities &
+                                             HB_QSV_CAP_MSDK_API_1_6);
+    if (pv->bfrm_delay && pv->bfrm_workaround)
+    {
+        pv->bfrm_workaround = 1;
+        pv->list_dts        = hb_list_init();
+    }
+    else
+    {
+        pv->bfrm_workaround = 0;
+        pv->list_dts        = NULL;
+    }
+
+    return 0;
+}
+
+void encqsvClose( hb_work_object_t * w )
+{
+    int i = 0;
+    hb_work_private_t * pv = w->private_data;
+
+    hb_log( "enc_qsv done: frames: %u in, %u out", pv->frames_in, pv->frames_out );
+
+    // if system memory ( encode only ) additional free(s) for surfaces
+    if( pv && pv->job && pv->job->qsv &&
+        pv->job->qsv->is_context_active ){
+
+        av_qsv_context *qsv = pv->job->qsv;
+
+        if(qsv && qsv->enc_space){
+        av_qsv_space* qsv_encode = qsv->enc_space;
+        if(qsv_encode->is_init_done){
+            if(pv->is_sys_mem){
+                if( qsv_encode && qsv_encode->surface_num > 0)
+                    for (i = 0; i < qsv_encode->surface_num; i++){
+                        if( qsv_encode->p_surfaces[i]->Data.Y){
+                            free(qsv_encode->p_surfaces[i]->Data.Y);
+                            qsv_encode->p_surfaces[i]->Data.Y = 0;
+                        }
+                        if( qsv_encode->p_surfaces[i]->Data.VU){
+                            free(qsv_encode->p_surfaces[i]->Data.VU);
+                            qsv_encode->p_surfaces[i]->Data.VU = 0;
+                        }
+                        if(qsv_encode->p_surfaces[i])
+                            av_freep(qsv_encode->p_surfaces[i]);
+                    }
+                qsv_encode->surface_num = 0;
+
+                sws_freeContext(pv->sws_context_to_nv12);
+            }
+
+            for (i = av_qsv_list_count(qsv_encode->tasks); i > 1; i--){
+                av_qsv_task* task = av_qsv_list_item(qsv_encode->tasks,i-1);
+                if(task && task->bs){
+                    av_freep(&task->bs->Data);
+                    av_freep(&task->bs);
+                    av_qsv_list_rem(qsv_encode->tasks,task);
+                }
+            }
+            av_qsv_list_close(&qsv_encode->tasks);
+
+            for (i = 0; i < qsv_encode->surface_num; i++){
+                av_freep(&qsv_encode->p_surfaces[i]);
+            }
+            qsv_encode->surface_num = 0;
+
+            for (i = 0; i < qsv_encode->sync_num; i++){
+                    av_freep(&qsv_encode->p_syncp[i]->p_sync);
+                    av_freep(&qsv_encode->p_syncp[i]);
+            }
+            qsv_encode->sync_num = 0;
+
+                qsv_encode->is_init_done = 0;
+        }
+        }
+
+        if(qsv){
+        // closing the commong stuff
+        av_qsv_context_clean(qsv);
+
+        if(pv->is_sys_mem){
+            av_freep(&qsv);
+        }
+        }
+    }
+
+    if (pv != NULL)
+    {
+        if (pv->list_dts != NULL)
+        {
+            while (hb_list_count(pv->list_dts) > 0)
+            {
+                int64_t *item = hb_list_item(pv->list_dts, 0);
+                hb_list_rem(pv->list_dts, item);
+                free(item);
+            }
+            hb_list_close(&pv->list_dts);
+        }
+    }
+
+    free( pv );
+    w->private_data = NULL;
+}
+
+int encqsvWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
+                  hb_buffer_t ** buf_out )
+{
+    hb_work_private_t * pv = w->private_data;
+    hb_job_t * job = pv->job;
+    hb_buffer_t * in = *buf_in, *buf;
+    av_qsv_context *qsv = job->qsv;
+    av_qsv_space* qsv_encode;
+    hb_buffer_t *last_buf = NULL;
+    mfxStatus sts = MFX_ERR_NONE;
+    int is_end = 0;
+    av_qsv_list* received_item = 0;
+    av_qsv_stage* stage = 0;
+
+    while(1){
+        int ret = qsv_enc_init(qsv, pv);
+        qsv = job->qsv;
+        qsv_encode = qsv->enc_space;
+        if(ret >= 2)
+            av_qsv_sleep(1);
+        else
+            break;
+    }
+    *buf_out = NULL;
+
+    if( in->size <= 0 )
+    {
+        // do delayed frames yet
+        *buf_in = NULL;
+        is_end = 1;
+    }
+
+    // input from decode, as called - we always have some to proceed with
+    while (1)
+    {
+    {
+        mfxEncodeCtrl    *work_control = NULL;
+        mfxFrameSurface1 *work_surface = NULL;
+
+        if (!is_end)
+        {
+            if (pv->is_sys_mem)
+            {
+                int surface_idx = av_qsv_get_free_surface(qsv_encode, qsv,
+                                                          &qsv_encode->request[0].Info, QSV_PART_ANY);
+                work_surface = qsv_encode->p_surfaces[surface_idx];
+
+                if (work_surface->Data.Y == NULL)
+                {
+                    // if nv12 and 422 12bits per pixel
+                    work_surface->Data.Pitch = pv->enc_space.m_mfxVideoParam.mfx.FrameInfo.Width;
+                    work_surface->Data.Y     = calloc(1,
+                                                      pv->enc_space.m_mfxVideoParam.mfx.FrameInfo.Width *
+                                                      pv->enc_space.m_mfxVideoParam.mfx.FrameInfo.Height);
+                    work_surface->Data.VU    = calloc(1,
+                                                      pv->enc_space.m_mfxVideoParam.mfx.FrameInfo.Width *
+                                                      pv->enc_space.m_mfxVideoParam.mfx.FrameInfo.Height / 2);
+                }
+                qsv_yuv420_to_nv12(pv->sws_context_to_nv12, work_surface, in);
+            }
+            else
+            {
+                received_item = in->qsv_details.qsv_atom;
+                stage = av_qsv_get_last_stage(received_item);
+                work_surface = stage->out.p_surface;
+
+                // don't let qsv->dts_seq grow needlessly
+                av_qsv_dts_pop(qsv);
+            }
+
+            work_surface->Data.TimeStamp = in->s.start;
+
+            /*
+             * Debugging code to check that the upstream modules have generated
+             * a continuous, self-consistent frame stream.
+             */
+            int64_t start = work_surface->Data.TimeStamp;
+            if (pv->last_start > start)
+            {
+                hb_log("encqsvWork: input continuity error, last start %"PRId64" start %"PRId64"",
+                       pv->last_start, start);
+            }
+            pv->last_start = start;
+
+            // for DTS generation (when MSDK API < 1.6 or VFR)
+            if (pv->bfrm_delay && pv->bfrm_workaround)
+            {
+                if (pv->frames_in <= BFRM_DELAY_MAX)
+                {
+                    pv->init_pts[pv->frames_in] = work_surface->Data.TimeStamp;
+                }
+                if (pv->frames_in)
+                {
+                    hb_qsv_add_new_dts(pv->list_dts,
+                                       work_surface->Data.TimeStamp);
+                }
+            }
+
+            /*
+             * Chapters have to start with a keyframe so request that this
+             * frame be coded as IDR. Since there may be several frames
+             * buffered in the encoder, remember the timestamp so when this
+             * frame finally pops out of the encoder we'll mark its buffer
+             * as the start of a chapter.
+             */
+            if (in->s.new_chap > 0 && job->chapter_markers)
+            {
+                if (!pv->next_chapter.index)
+                {
+                    pv->next_chapter.start = work_surface->Data.TimeStamp;
+                    pv->next_chapter.index = in->s.new_chap;
+                    work_control           = &pv->force_keyframe;
+                }
+                else
+                {
+                    // however unlikely, this can happen in theory
+                    hb_log("encqsvWork: got chapter %d before we could write chapter %d, dropping marker",
+                           in->s.new_chap, pv->next_chapter.index);
+                }
+                // don't let 'work_loop' put a chapter mark on the wrong buffer
+                in->s.new_chap = 0;
+            }
+
+            /*
+             * If interlaced encoding is requested during encoder initialization,
+             * but the input mfxFrameSurface1 is flagged as progressive here,
+             * the output bitstream will be progressive (according to MediaInfo).
+             *
+             * Assume the user knows what he's doing (say he is e.g. encoding a
+             * progressive-flagged source using interlaced compression - he may
+             * well have a good reason to do so; mis-flagged sources do exist).
+             */
+            work_surface->Info.PicStruct = pv->enc_space.m_mfxVideoParam.mfx.FrameInfo.PicStruct;
+        }
+        else{
+            work_surface = NULL;
+            received_item = NULL;
+        }
+        int sync_idx = av_qsv_get_free_sync( qsv_encode, qsv );
+        if (sync_idx == -1)
+        {
+            hb_error("qsv: Not enough resources allocated for QSV encode");
+            return 0;
+        }
+        av_qsv_task *task = av_qsv_list_item( qsv_encode->tasks, pv->async_depth );
+
+        for (;;)
+        {
+            // Encode a frame asychronously (returns immediately)
+            sts = MFXVideoENCODE_EncodeFrameAsync(qsv->mfx_session,
+                                                  work_control, work_surface, task->bs,
+                                                  qsv_encode->p_syncp[sync_idx]->p_sync);
+
+            if (MFX_ERR_MORE_DATA == sts || (MFX_ERR_NONE <= sts && MFX_WRN_DEVICE_BUSY != sts))
+                if (work_surface && !pv->is_sys_mem)
+                    ff_qsv_atomic_dec(&work_surface->Data.Locked);
+
+            if( MFX_ERR_MORE_DATA == sts ){
+                ff_qsv_atomic_dec(&qsv_encode->p_syncp[sync_idx]->in_use);
+                if(work_surface && received_item)
+                    hb_list_add(pv->delayed_processing, received_item);
+                break;
+            }
+
+            AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
+
+            if (MFX_ERR_NONE <= sts /*&& !syncpE*/) // repeat the call if warning and no output
+            {
+                if (MFX_WRN_DEVICE_BUSY == sts){
+                    av_qsv_sleep(10); // wait if device is busy
+                    continue;
+                }
+
+                av_qsv_stage* new_stage = av_qsv_stage_init();
+                new_stage->type = AV_QSV_ENCODE;
+                new_stage->in.p_surface = work_surface;
+                new_stage->out.sync = qsv_encode->p_syncp[sync_idx];
+
+                new_stage->out.p_bs = task->bs;//qsv_encode->bs;
+                task->stage = new_stage;
+
+                pv->async_depth++;
+
+                if(received_item){
+                    av_qsv_add_stagee( &received_item, new_stage,HAVE_THREADS );
+                }
+                else{
+                   // flushing the end
+                    int pipe_idx = av_qsv_list_add( qsv->pipes, av_qsv_list_init(HAVE_THREADS) );
+                    av_qsv_list* list_item = av_qsv_list_item( qsv->pipes, pipe_idx );
+                    av_qsv_add_stagee( &list_item, new_stage,HAVE_THREADS );
+                }
+
+                int i = 0;
+                for(i=hb_list_count(pv->delayed_processing); i > 0;i--){
+                    hb_list_t *item = hb_list_item(pv->delayed_processing,i-1);
+                    if(item){
+                        hb_list_rem(pv->delayed_processing,item);
+                        av_qsv_flush_stages(qsv->pipes, &item);
+                    }
+                }
+
+                break;
+            }
+
+            ff_qsv_atomic_dec(&qsv_encode->p_syncp[sync_idx]->in_use);
+
+            if (MFX_ERR_NOT_ENOUGH_BUFFER == sts)
+                DEBUG_ASSERT( 1,"The bitstream buffer size is insufficient." );
+
+            break;
+        }
+    }
+
+    buf = NULL;
+
+    do{
+
+    if(pv->async_depth==0) break;
+
+    // working properly with sync depth approach of MediaSDK OR flushing, if at the end
+    if( (pv->async_depth >= pv->max_async_depth) || is_end ){
+
+        pv->async_depth--;
+
+        av_qsv_task *task = av_qsv_list_item( qsv_encode->tasks, 0 );
+        av_qsv_stage* stage = task->stage;
+        av_qsv_list*  this_pipe = av_qsv_pipe_by_stage(qsv->pipes,stage);
+        sts = MFX_ERR_NONE;
+
+        // only here we need to wait on operation been completed, therefore SyncOperation is used,
+        // after this step - we continue to work with bitstream, muxing ...
+        av_qsv_wait_on_sync( qsv,stage );
+
+        if(task->bs->DataLength>0){
+                av_qsv_flush_stages( qsv->pipes, &this_pipe );
+
+                // see nal_encode
+                buf = hb_video_buffer_init( job->width, job->height );
+                buf->size = 0;
+                buf->s.frametype = 0;
+
+                // maping of FrameType(s)
+                if(task->bs->FrameType & MFX_FRAMETYPE_IDR ) buf->s.frametype = HB_FRAME_IDR;
+                else
+                if(task->bs->FrameType & MFX_FRAMETYPE_I )   buf->s.frametype = HB_FRAME_I;
+                else
+                if(task->bs->FrameType & MFX_FRAMETYPE_P )   buf->s.frametype = HB_FRAME_P;
+                else
+                if(task->bs->FrameType & MFX_FRAMETYPE_B )   buf->s.frametype = HB_FRAME_B;
+
+                if(task->bs->FrameType & MFX_FRAMETYPE_REF ) buf->s.flags      = HB_FRAME_REF;
+
+                parse_nalus(task->bs->Data + task->bs->DataOffset,task->bs->DataLength, buf, pv->frames_out);
+
+                if ( last_buf == NULL )
+                    *buf_out = buf;
+                else
+                    last_buf->next = buf;
+                last_buf = buf;
+
+            // simple for now but check on TimeStampCalc from MSDK
+            int64_t duration  = ((double)pv->enc_space.m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD /
+                                 (double)pv->enc_space.m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN) * 90000.;
+
+            // start        -> PTS
+            // renderOffset -> DTS
+            buf->s.start    = buf->s.renderOffset = task->bs->TimeStamp;
+            buf->s.stop     = buf->s.start + duration;
+            buf->s.duration = duration;
+            if (pv->bfrm_delay)
+            {
+                if (!pv->bfrm_workaround)
+                {
+                    buf->s.renderOffset = task->bs->DecodeTimeStamp;
+                }
+                else
+                {
+                    // MSDK API < 1.6 or VFR, so generate our own DTS
+                    if ((pv->frames_out == 0)                                 &&
+                        (hb_qsv_info->capabilities & HB_QSV_CAP_MSDK_API_1_6) &&
+                        (hb_qsv_info->capabilities & HB_QSV_CAP_H264_BPYRAMID))
+                    {
+                        // with B-pyramid, the delay may be more than 1 frame,
+                        // so compute the actual delay based on the initial DTS
+                        // provided by MSDK; also, account for rounding errors
+                        // (e.g. 24000/1001 fps @ 90kHz -> 3753.75 ticks/frame)
+                        pv->bfrm_delay = ((task->bs->TimeStamp -
+                                           task->bs->DecodeTimeStamp +
+                                           (duration / 2)) / duration);
+                        pv->bfrm_delay = FFMAX(pv->bfrm_delay, 1);
+                        pv->bfrm_delay = FFMIN(pv->bfrm_delay, BFRM_DELAY_MAX);
+                    }
+                    /*
+                     * Generate VFR-compatible output DTS based on input PTS.
+                     *
+                     * Depends on the B-frame delay:
+                     *
+                     * 0: ipts0,  ipts1, ipts2...
+                     * 1: ipts0 - ipts1, ipts1 - ipts1, ipts1,  ipts2...
+                     * 2: ipts0 - ipts2, ipts1 - ipts2, ipts2 - ipts2, ipts1...
+                     * ...and so on.
+                     */
+                    if (pv->frames_out <= pv->bfrm_delay)
+                    {
+                        buf->s.renderOffset = (pv->init_pts[pv->frames_out] -
+                                               pv->init_pts[pv->bfrm_delay]);
+                    }
+                    else
+                    {
+                        buf->s.renderOffset = hb_qsv_pop_next_dts(pv->list_dts);
+                    }
+                }
+
+                /*
+                 * In the MP4 container, DT(0) = STTS(0) = 0.
+                 *
+                 * Which gives us:
+                 * CT(0) = CTTS(0) + STTS(0) = CTTS(0) = PTS(0) - DTS(0)
+                 * When DTS(0) < PTS(0), we then have:
+                 * CT(0) > 0 for video, but not audio (breaks A/V sync).
+                 *
+                 * This is typically solved by writing an edit list shifting
+                 * video samples by the initial delay, PTS(0) - DTS(0).
+                 *
+                 * See:
+                 * ISO/IEC 14496-12:2008(E), ISO base media file format
+                 *  - 8.6.1.2 Decoding Time to Sample Box
+                 */
+                if (w->config->h264.init_delay == 0 && buf->s.renderOffset < 0)
+                {
+                    w->config->h264.init_delay = -buf->s.renderOffset;
+                }
+            }
+
+            /*
+             * If we have a chapter marker pending and this frame's
+             * presentation time stamp is at or after the marker's time stamp,
+             * use this as the chapter start.
+             */
+            if (pv->next_chapter.index && buf->s.frametype == HB_FRAME_IDR &&
+                pv->next_chapter.start <= buf->s.start)
+            {
+                buf->s.new_chap = pv->next_chapter.index;
+                pv->next_chapter.index = 0;
+            }
+
+                // shift for fifo
+                if(pv->async_depth){
+                    av_qsv_list_rem(qsv_encode->tasks,task);
+                    av_qsv_list_add(qsv_encode->tasks,task);
+                }
+
+                task->bs->DataLength    = 0;
+                task->bs->DataOffset    = 0;
+                task->bs->MaxLength = qsv_encode->p_buf_max_size;
+                task->stage        = 0;
+                pv->frames_out++;
+            }
+        }
+    }while(is_end);
+
+
+    if(is_end){
+        if( !buf && MFX_ERR_MORE_DATA == sts )
+            break;
+
+    }
+    else
+        break;
+
+    }
+
+    if(!is_end)
+        ++pv->frames_in;
+
+    if(is_end){
+        *buf_in = NULL;
+        if(last_buf){
+            last_buf->next = in;
+        }
+        else
+            *buf_out = in;
+        return HB_WORK_DONE;
+    }
+    else{
+        return HB_WORK_OK;
+    }
+}
+
+int nal_find_start_code(uint8_t** pb, size_t* size){
+    if ((int) *size < 4 )
+        return 0;
+
+    // find start code by MSDK , see ff_prefix_code[]
+    while ((4 <= *size) &&
+        ((0 != (*pb)[0]) ||
+         (0 != (*pb)[1]) ||
+         (1 != (*pb)[2]) ))
+    {
+        *pb += 1;
+        *size -= 1;
+    }
+
+    if (4 <= *size)
+        return (((*pb)[0] << 24) | ((*pb)[1] << 16) | ((*pb)[2] << 8) | ((*pb)[3]));
+
+    return 0;
+}
+
+void parse_nalus(uint8_t *nal_inits, size_t length, hb_buffer_t *buf, uint32_t frame_num){
+    uint8_t *offset = nal_inits;
+    size_t size     = length;
+
+    if( nal_find_start_code(&offset,&size) == 0 )
+        size = 0;
+
+    while( size > 0 ){
+
+            uint8_t* current_nal = offset + sizeof(ff_prefix_code)-1;
+            uint8_t *next_offset = offset + sizeof(ff_prefix_code);
+            size_t next_size     = size - sizeof(ff_prefix_code);
+            size_t current_size  = next_size;
+            if( nal_find_start_code(&next_offset,&next_size) == 0 ){
+                size = 0;
+                current_size += 1;
+            }
+            else{
+                current_size -= next_size;
+                if( next_offset > 0 && *(next_offset-1) != 0  )
+                    current_size += 1;
+            }
+            {
+                char size_position[4] = {0,0,0,0};
+                size_position[1] = (current_size >> 24) & 0xFF;
+                size_position[1] = (current_size >> 16) & 0xFF;
+                size_position[2] = (current_size >> 8)  & 0xFF;
+                size_position[3] =  current_size        & 0xFF;
+
+                memcpy(buf->data + buf->size,&size_position ,sizeof(size_position));
+                buf->size += sizeof(size_position);
+
+                memcpy(buf->data + buf->size,current_nal ,current_size);
+                buf->size += current_size;
+            }
+
+            if(size){
+                size   = next_size;
+                offset = next_offset;
+            }
+        }
+}
diff --git a/libhb/enc_qsv.h b/libhb/enc_qsv.h
new file mode 100644
index 000000000..9d27347cd
--- /dev/null
+++ b/libhb/enc_qsv.h
@@ -0,0 +1,38 @@
+/* ********************************************************************* *\
+
+Copyright (C) 2013 Intel Corporation.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+- Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+- Neither the name of Intel Corporation nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL INTEL CORPORATION BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+\* ********************************************************************* */
+
+#ifndef ENC_QSV_H
+#define ENC_QSV_H
+
+#include "hb.h"
+#include "qsv_common.h"
+
+int nal_find_start_code(uint8_t** pb, size_t* size);
+void parse_nalus( uint8_t *nal_inits, size_t length, hb_buffer_t *buf, uint32_t frame_num);
+
+#endif // ENC_QSV_H
diff --git a/libhb/h264_common.h b/libhb/h264_common.h
new file mode 100644
index 000000000..febe1965f
--- /dev/null
+++ b/libhb/h264_common.h
@@ -0,0 +1,17 @@
+/* h264_common.h
+
+   Copyright (c) 2003-2012 HandBrake Team
+   This file is part of the HandBrake source code
+   Homepage: <http://handbrake.fr/>.
+   It may be used under the terms of the GNU General Public License v2.
+   For full terms see the file COPYING file or visit http://www.gnu.org/licenses/gpl-2.0.html
+ */
+
+#ifndef HB_H264_COMMON_H
+#define HB_H264_COMMON_H
+
+static const char * const hb_h264_profile_names[] = { "auto", "high", "main", "baseline", NULL, };
+static const char * const   hb_h264_level_names[] = { "auto", "1.0", "1b", "1.1", "1.2", "1.3", "2.0", "2.1", "2.2", "3.0", "3.1", "3.2", "4.0", "4.1", "4.2", "5.0", "5.1", "5.2",  NULL, };
+static const int    const  hb_h264_level_values[] = {     -1,    10,    9,    11,    12,    13,    20,    21,    22,    30,    31,    32,    40,    41,    42,    50,    51,    52,     0, };
+
+#endif  //HB_H264_COMMON_H
diff --git a/libhb/qsv_common.c b/libhb/qsv_common.c
new file mode 100644
index 000000000..7cc0bb70c
--- /dev/null
+++ b/libhb/qsv_common.c
@@ -0,0 +1,780 @@
+/* qsv_common.c
+ *
+ * Copyright (c) 2003-2013 HandBrake Team
+ * This file is part of the HandBrake source code.
+ * Homepage: <http://handbrake.fr/>.
+ * It may be used under the terms of the GNU General Public License v2.
+ * For full terms see the file COPYING file or visit http://www.gnu.org/licenses/gpl-2.0.html
+ */
+
+#include "hb.h"
+#include "ports.h"
+#include "common.h"
+#include "hb_dict.h"
+#include "qsv_common.h"
+#include "h264_common.h"
+
+// for x264_vidformat_names etc.
+#include "x264.h"
+
+// avoids a warning
+#include "libavutil/cpu.h"
+extern void ff_cpu_cpuid(int index, int *eax, int *ebx, int *ecx, int *edx);
+
+// make the Intel QSV information available to the UIs
+hb_qsv_info_t *hb_qsv_info = NULL;
+
+// availability and versions
+static mfxVersion qsv_hardware_version;
+static mfxVersion qsv_software_version;
+static mfxVersion qsv_minimum_version;
+static int qsv_hardware_available = 0;
+static int qsv_software_available = 0;
+
+// check available Intel Media SDK version against a minimum
+#define HB_CHECK_MFX_VERSION(MFX_VERSION, MAJOR, MINOR) \
+    (MFX_VERSION.Major == MAJOR  && MFX_VERSION.Minor >= MINOR)
+
+int hb_qsv_available()
+{
+    return hb_qsv_info != NULL && (qsv_hardware_available ||
+                                   qsv_software_available);
+}
+
+int hb_qsv_info_init()
+{
+    static int init_done = 0;
+    if (init_done)
+        return (hb_qsv_info == NULL);
+    init_done = 1;
+
+    hb_qsv_info = calloc(1, sizeof(*hb_qsv_info));
+    if (hb_qsv_info == NULL)
+    {
+        hb_error("hb_qsv_info_init: alloc failure");
+        return -1;
+    }
+
+    mfxSession session;
+    qsv_minimum_version.Major = HB_QSV_MINVERSION_MAJOR;
+    qsv_minimum_version.Minor = HB_QSV_MINVERSION_MINOR;
+
+    // check for software fallback
+    if (MFXInit(MFX_IMPL_SOFTWARE,
+                &qsv_minimum_version, &session) == MFX_ERR_NONE)
+    {
+        qsv_software_available = 1;
+        // our minimum is supported, but query the actual version
+        MFXQueryVersion(session, &qsv_software_version);
+        MFXClose(session);
+    }
+
+    // check for actual hardware support
+    if (MFXInit(MFX_IMPL_HARDWARE_ANY|MFX_IMPL_VIA_ANY,
+                &qsv_minimum_version, &session) == MFX_ERR_NONE)
+    {
+        qsv_hardware_available = 1;
+        // our minimum is supported, but query the actual version
+        MFXQueryVersion(session, &qsv_hardware_version);
+        MFXClose(session);
+    }
+
+    // check for version-specific or hardware-specific capabilities
+    // we only use software as a fallback, so check hardware first
+    if (qsv_hardware_available)
+    {
+        if (HB_CHECK_MFX_VERSION(qsv_hardware_version, 1, 6))
+        {
+            hb_qsv_info->capabilities |= HB_QSV_CAP_OPTION2_BRC;
+            hb_qsv_info->capabilities |= HB_QSV_CAP_MSDK_API_1_6;
+        }
+        if (hb_get_cpu_platform() == HB_CPU_PLATFORM_INTEL_HSW)
+        {
+            if (HB_CHECK_MFX_VERSION(qsv_hardware_version, 1, 7))
+            {
+                hb_qsv_info->capabilities |= HB_QSV_CAP_OPTION2_TRELLIS;
+                hb_qsv_info->capabilities |= HB_QSV_CAP_OPTION2_LOOKAHEAD;
+            }
+            hb_qsv_info->capabilities |= HB_QSV_CAP_H264_BPYRAMID;
+        }
+    }
+    else if (qsv_software_available)
+    {
+        if (HB_CHECK_MFX_VERSION(qsv_software_version, 1, 6))
+        {
+            hb_qsv_info->capabilities |= HB_QSV_CAP_MSDK_API_1_6;
+            hb_qsv_info->capabilities |= HB_QSV_CAP_H264_BPYRAMID;
+        }
+    }
+
+    // note: we pass a pointer to MFXInit but it never gets modified
+    //       let's make sure of it just to be safe though
+    if (qsv_minimum_version.Major != HB_QSV_MINVERSION_MAJOR ||
+        qsv_minimum_version.Minor != HB_QSV_MINVERSION_MINOR)
+    {
+        hb_error("hb_qsv_info_init: minimum version (%d.%d) was modified",
+                 qsv_minimum_version.Major,
+                 qsv_minimum_version.Minor);
+    }
+
+    // success
+    return 0;
+}
+
+// we don't need it beyond this point
+#undef HB_CHECK_MFX_VERSION
+
+void hb_qsv_info_print()
+{
+    if (hb_qsv_info == NULL)
+        return;
+
+    // is QSV available?
+    hb_log("Intel Quick Sync Video support: %s",
+           hb_qsv_available() ? "yes": "no");
+
+    // if we have Quick Sync Video support, also print the details
+    if (hb_qsv_available())
+    {
+        if (qsv_hardware_available)
+        {
+            hb_log(" - Intel Media SDK hardware: API %d.%d (minimum: %d.%d)",
+                   qsv_hardware_version.Major,
+                   qsv_hardware_version.Minor,
+                   qsv_minimum_version.Major,
+                   qsv_minimum_version.Minor);
+        }
+        if (qsv_software_available)
+        {
+            hb_log(" - Intel Media SDK software: API %d.%d (minimum: %d.%d)",
+                   qsv_software_version.Major,
+                   qsv_software_version.Minor,
+                   qsv_minimum_version.Major,
+                   qsv_minimum_version.Minor);
+        }
+    }
+}
+
+const char* hb_qsv_decode_get_codec_name(enum AVCodecID codec_id)
+{
+    switch (codec_id)
+    {
+        case AV_CODEC_ID_H264:
+            return "h264_qsv";
+
+        default:
+            return NULL;
+    }
+}
+
+int hb_qsv_decode_is_enabled(hb_job_t *job)
+{
+    return ((job != NULL && job->title->qsv_decode_support && job->qsv_decode) &&
+            (job->vcodec & HB_VCODEC_QSV_MASK));
+}
+
+int hb_qsv_decode_is_supported(enum AVCodecID codec_id,
+                               enum AVPixelFormat pix_fmt)
+{
+    switch (codec_id)
+    {
+        case AV_CODEC_ID_H264:
+            return (pix_fmt == AV_PIX_FMT_YUV420P ||
+                    pix_fmt == AV_PIX_FMT_YUVJ420P);
+
+        default:
+            return 0;
+    }
+}
+
+int hb_qsv_codingoption_xlat(int val)
+{
+    switch (HB_QSV_CLIP3(-1, 2, val))
+    {
+        case 0:
+            return MFX_CODINGOPTION_OFF;
+        case 1:
+        case 2: // MFX_CODINGOPTION_ADAPTIVE, reserved
+            return MFX_CODINGOPTION_ON;
+        case -1:
+        default:
+            return MFX_CODINGOPTION_UNKNOWN;
+    }
+}
+
+int hb_qsv_trellisvalue_xlat(int val)
+{
+    switch (HB_QSV_CLIP3(-1, 3, val))
+    {
+        case 0:
+            return MFX_TRELLIS_OFF;
+        case 1: // I-frames only
+            return MFX_TRELLIS_I;
+        case 2: // I- and P-frames
+            return MFX_TRELLIS_I|MFX_TRELLIS_P;
+        case 3: // all frames
+            return MFX_TRELLIS_I|MFX_TRELLIS_P|MFX_TRELLIS_B;
+        case -1:
+        default:
+            return MFX_TRELLIS_UNKNOWN;
+    }
+}
+
+int hb_qsv_atoindex(const char* const *arr, const char *str, int *err)
+{
+    int i;
+    for (i = 0; arr[i] != NULL; i++)
+    {
+        if (!strcasecmp(arr[i], str))
+        {
+            break;
+        }
+    }
+    *err = (arr[i] == NULL);
+    return i;
+}
+
+// adapted from libx264
+int hb_qsv_atobool(const char *str, int *err)
+{
+    if (!strcasecmp(str,    "1") ||
+        !strcasecmp(str,  "yes") ||
+        !strcasecmp(str, "true"))
+    {
+        return 1;
+    }
+    if (!strcasecmp(str,     "0") ||
+        !strcasecmp(str,    "no") ||
+        !strcasecmp(str, "false"))
+    {
+        return 0;
+    }
+    *err = 1;
+    return 0;
+}
+
+// adapted from libx264
+int hb_qsv_atoi(const char *str, int *err)
+{
+    char *end;
+    int v = strtol(str, &end, 0);
+    if (end == str || end[0] != '\0')
+    {
+        *err = 1;
+    }
+    return v;
+}
+
+// adapted from libx264
+float hb_qsv_atof(const char *str, int *err)
+{
+    char *end;
+    float v = strtod(str, &end);
+    if (end == str || end[0] != '\0')
+    {
+        *err = 1;
+    }
+    return v;
+}
+
+int hb_qsv_param_parse(hb_qsv_param_t *param,
+                       const char *key, const char *value, int vcodec)
+{
+    float fvalue;
+    int ivalue, error = 0;
+    if (param == NULL)
+    {
+        return HB_QSV_PARAM_ERROR;
+    }
+    if (value == NULL || value[0] == '\0')
+    {
+        value = "true";
+    }
+    else if (value[0] == '=')
+    {
+        value++;
+    }
+    if (key == NULL || key[0] == '\0')
+    {
+        return HB_QSV_PARAM_BAD_NAME;
+    }
+    else if (!strncasecmp(key, "no-", 3))
+    {
+        key  += 3;
+        value = hb_qsv_atobool(value, &error) ? "false" : "true";
+        if (error)
+        {
+            return HB_QSV_PARAM_BAD_VALUE;
+        }
+    }
+    if (!strcasecmp(key, "target-usage") ||
+        !strcasecmp(key, "tu"))
+    {
+        ivalue = hb_qsv_atoi(value, &error);
+        if (!error)
+        {
+            param->videoParam->mfx.TargetUsage = HB_QSV_CLIP3(MFX_TARGETUSAGE_1,
+                                                              MFX_TARGETUSAGE_7,
+                                                              ivalue);
+        }
+    }
+    else if (!strcasecmp(key, "num-ref-frame") ||
+             !strcasecmp(key, "ref"))
+    {
+        ivalue = hb_qsv_atoi(value, &error);
+        if (!error)
+        {
+            param->videoParam->mfx.NumRefFrame = HB_QSV_CLIP3(0, 16, ivalue);
+        }
+    }
+    else if (!strcasecmp(key, "gop-ref-dist"))
+    {
+        ivalue = hb_qsv_atoi(value, &error);
+        if (!error)
+        {
+            param->videoParam->mfx.GopRefDist = HB_QSV_CLIP3(0, 32, ivalue);
+        }
+    }
+    else if (!strcasecmp(key, "gop-pic-size") ||
+             !strcasecmp(key, "keyint"))
+    {
+        ivalue = hb_qsv_atoi(value, &error);
+        if (!error)
+        {
+            param->gop.gop_pic_size = HB_QSV_CLIP3(-1, UINT16_MAX, ivalue);
+        }
+    }
+    else if (!strcasecmp(key, "scenecut"))
+    {
+        ivalue = hb_qsv_atobool(value, &error);
+        if (!error)
+        {
+            if (!ivalue)
+            {
+                param->videoParam->mfx.GopOptFlag |= MFX_GOP_STRICT;
+            }
+            else
+            {
+                param->videoParam->mfx.GopOptFlag &= ~MFX_GOP_STRICT;
+            }
+        }
+    }
+    else if (!strcasecmp(key, "cqp-offset-i"))
+    {
+        ivalue = hb_qsv_atoi(value, &error);
+        if (!error)
+        {
+            param->rc.cqp_offsets[0] = HB_QSV_CLIP3(INT16_MIN, INT16_MAX, ivalue);
+        }
+    }
+    else if (!strcasecmp(key, "cqp-offset-p"))
+    {
+        ivalue = hb_qsv_atoi(value, &error);
+        if (!error)
+        {
+            param->rc.cqp_offsets[1] = HB_QSV_CLIP3(INT16_MIN, INT16_MAX, ivalue);
+        }
+    }
+    else if (!strcasecmp(key, "cqp-offset-b"))
+    {
+        ivalue = hb_qsv_atoi(value, &error);
+        if (!error)
+        {
+            param->rc.cqp_offsets[2] = HB_QSV_CLIP3(INT16_MIN, INT16_MAX, ivalue);
+        }
+    }
+    else if (!strcasecmp(key, "vbv-init"))
+    {
+        fvalue = hb_qsv_atof(value, &error);
+        if (!error)
+        {
+            param->rc.vbv_buffer_init = HB_QSV_CLIP3(0, UINT16_MAX, fvalue);
+        }
+    }
+    else if (!strcasecmp(key, "vbv-bufsize"))
+    {
+        ivalue = hb_qsv_atoi(value, &error);
+        if (!error)
+        {
+            param->rc.vbv_buffer_size = HB_QSV_CLIP3(0, UINT16_MAX, ivalue);
+        }
+    }
+    else if (!strcasecmp(key, "vbv-maxrate"))
+    {
+        ivalue = hb_qsv_atoi(value, &error);
+        if (!error)
+        {
+            param->rc.vbv_max_bitrate = HB_QSV_CLIP3(0, UINT16_MAX, ivalue);
+        }
+    }
+    else if (!strcasecmp(key, "cabac"))
+    {
+        switch (vcodec)
+        {
+            case HB_VCODEC_QSV_H264:
+                ivalue = !hb_qsv_atobool(value, &error);
+                break;
+            default:
+                return HB_QSV_PARAM_UNSUPPORTED;
+        }
+        if (!error)
+        {
+            param->codingOption.CAVLC = hb_qsv_codingoption_xlat(ivalue);
+        }
+    }
+    else if (!strcasecmp(key, "rate-distorsion-opt") ||
+             !strcasecmp(key, "rdo"))
+    {
+        switch (vcodec)
+        {
+            case HB_VCODEC_QSV_H264:
+                ivalue = hb_qsv_atobool(value, &error);
+                break;
+            default:
+                return HB_QSV_PARAM_UNSUPPORTED;
+        }
+        if (!error)
+        {
+            param->codingOption.RateDistortionOpt = hb_qsv_codingoption_xlat(ivalue);
+        }
+    }
+    else if (!strcasecmp(key, "videoformat"))
+    {
+        switch (vcodec)
+        {
+            case HB_VCODEC_QSV_H264:
+                ivalue = hb_qsv_atoindex(x264_vidformat_names, value, &error);
+                break;
+            default:
+                return HB_QSV_PARAM_UNSUPPORTED;
+        }
+        if (!error)
+        {
+            param->videoSignalInfo.VideoFormat = ivalue;
+        }
+    }
+    else if (!strcasecmp(key, "fullrange"))
+    {
+        switch (vcodec)
+        {
+            case HB_VCODEC_QSV_H264:
+                ivalue = hb_qsv_atoindex(x264_fullrange_names, value, &error);
+                break;
+            default:
+                return HB_QSV_PARAM_UNSUPPORTED;
+        }
+        if (!error)
+        {
+            param->videoSignalInfo.VideoFullRange = ivalue;
+        }
+    }
+    else if (!strcasecmp(key, "colorprim"))
+    {
+        switch (vcodec)
+        {
+            case HB_VCODEC_QSV_H264:
+                ivalue = hb_qsv_atoindex(x264_colorprim_names, value, &error);
+                break;
+            default:
+                return HB_QSV_PARAM_UNSUPPORTED;
+        }
+        if (!error)
+        {
+            param->videoSignalInfo.ColourDescriptionPresent = 1;
+            param->videoSignalInfo.ColourPrimaries = ivalue;
+        }
+    }
+    else if (!strcasecmp(key, "transfer"))
+    {
+        switch (vcodec)
+        {
+            case HB_VCODEC_QSV_H264:
+                ivalue = hb_qsv_atoindex(x264_transfer_names, value, &error);
+                break;
+            default:
+                return HB_QSV_PARAM_UNSUPPORTED;
+        }
+        if (!error)
+        {
+            param->videoSignalInfo.ColourDescriptionPresent = 1;
+            param->videoSignalInfo.TransferCharacteristics = ivalue;
+        }
+    }
+    else if (!strcasecmp(key, "colormatrix"))
+    {
+        switch (vcodec)
+        {
+            case HB_VCODEC_QSV_H264:
+                ivalue = hb_qsv_atoindex(x264_colmatrix_names, value, &error);
+                break;
+            default:
+                return HB_QSV_PARAM_UNSUPPORTED;
+        }
+        if (!error)
+        {
+            param->videoSignalInfo.ColourDescriptionPresent = 1;
+            param->videoSignalInfo.MatrixCoefficients = ivalue;
+        }
+    }
+    else if (!strcasecmp(key, "tff") ||
+             !strcasecmp(key, "interlaced"))
+    {
+        switch (vcodec)
+        {
+            case HB_VCODEC_QSV_H264:
+                ivalue = hb_qsv_atobool(value, &error);
+                break;
+            default:
+                return HB_QSV_PARAM_UNSUPPORTED;
+        }
+        if (!error)
+        {
+            param->videoParam->mfx.FrameInfo.PicStruct = (ivalue                  ?
+                                                          MFX_PICSTRUCT_FIELD_TFF :
+                                                          MFX_PICSTRUCT_PROGRESSIVE);
+        }
+    }
+    else if (!strcasecmp(key, "bff"))
+    {
+        switch (vcodec)
+        {
+            case HB_VCODEC_QSV_H264:
+                ivalue = hb_qsv_atobool(value, &error);
+                break;
+            default:
+                return HB_QSV_PARAM_UNSUPPORTED;
+        }
+        if (!error)
+        {
+            param->videoParam->mfx.FrameInfo.PicStruct = (ivalue                  ?
+                                                          MFX_PICSTRUCT_FIELD_BFF :
+                                                          MFX_PICSTRUCT_PROGRESSIVE);
+        }
+    }
+    else if (!strcasecmp(key, "mbbrc"))
+    {
+        if (hb_qsv_info->capabilities & HB_QSV_CAP_OPTION2_BRC)
+        {
+            ivalue = hb_qsv_atoi(value, &error);
+            if (!error)
+            {
+                param->codingOption2.MBBRC = hb_qsv_codingoption_xlat(ivalue);
+            }
+        }
+        else
+        {
+            return HB_QSV_PARAM_UNSUPPORTED;
+        }
+    }
+    else if (!strcasecmp(key, "extbrc"))
+    {
+        if (hb_qsv_info->capabilities & HB_QSV_CAP_OPTION2_BRC)
+        {
+            ivalue = hb_qsv_atoi(value, &error);
+            if (!error)
+            {
+                param->codingOption2.ExtBRC = hb_qsv_codingoption_xlat(ivalue);
+            }
+        }
+        else
+        {
+            return HB_QSV_PARAM_UNSUPPORTED;
+        }
+    }
+    else if (!strcasecmp(key, "lookahead") ||
+             !strcasecmp(key, "la"))
+    {
+        switch (vcodec)
+        {
+            case HB_VCODEC_QSV_H264:
+                ivalue = hb_qsv_atobool(value, &error);
+                break;
+            default:
+                return HB_QSV_PARAM_UNSUPPORTED;
+        }
+        if (hb_qsv_info->capabilities & HB_QSV_CAP_OPTION2_LOOKAHEAD)
+        {
+            if (!error)
+            {
+                param->rc.lookahead = ivalue;
+            }
+        }
+        else
+        {
+            return HB_QSV_PARAM_UNSUPPORTED;
+        }
+    }
+    else if (!strcasecmp(key, "lookahead-depth") ||
+             !strcasecmp(key, "la-depth"))
+    {
+        switch (vcodec)
+        {
+            case HB_VCODEC_QSV_H264:
+                ivalue = hb_qsv_atoi(value, &error);
+                break;
+            default:
+                return HB_QSV_PARAM_UNSUPPORTED;
+        }
+        if (hb_qsv_info->capabilities & HB_QSV_CAP_OPTION2_LOOKAHEAD)
+        {
+            if (!error)
+            {
+                param->codingOption2.LookAheadDepth = HB_QSV_CLIP3(10, 100,
+                                                                   ivalue);
+            }
+        }
+        else
+        {
+            return HB_QSV_PARAM_UNSUPPORTED;
+        }
+    }
+    else if (!strcasecmp(key, "trellis"))
+    {
+        switch (vcodec)
+        {
+            case HB_VCODEC_QSV_H264:
+                ivalue = hb_qsv_atoi(value, &error);
+                break;
+            default:
+                return HB_QSV_PARAM_UNSUPPORTED;
+        }
+        if (hb_qsv_info->capabilities & HB_QSV_CAP_OPTION2_TRELLIS)
+        {
+            if (!error)
+            {
+                param->codingOption2.Trellis = hb_qsv_trellisvalue_xlat(ivalue);
+            }
+        }
+        else
+        {
+            return HB_QSV_PARAM_UNSUPPORTED;
+        }
+    }
+    else
+    {
+        /*
+         * TODO:
+         * - slice count control
+         * - open-gop
+         * - fake-interlaced (mfxExtCodingOption.FramePicture???)
+         * - intra-refresh
+         */
+        return HB_QSV_PARAM_BAD_NAME;
+    }
+    return error ? HB_QSV_PARAM_BAD_VALUE : HB_QSV_PARAM_OK;
+}
+
+int hb_qsv_param_default(hb_qsv_param_t *param, mfxVideoParam *videoParam)
+{
+    if (param != NULL && videoParam != NULL)
+    {
+        // introduced in API 1.0
+        memset(&param->codingOption, 0, sizeof(mfxExtCodingOption));
+        param->codingOption.Header.BufferId      = MFX_EXTBUFF_CODING_OPTION;
+        param->codingOption.Header.BufferSz      = sizeof(mfxExtCodingOption);
+        param->codingOption.MECostType           = 0; // reserved, must be 0
+        param->codingOption.MESearchType         = 0; // reserved, must be 0
+        param->codingOption.MVSearchWindow.x     = 0; // reserved, must be 0
+        param->codingOption.MVSearchWindow.y     = 0; // reserved, must be 0
+        param->codingOption.RefPicListReordering = 0; // reserved, must be 0
+        param->codingOption.IntraPredBlockSize   = 0; // reserved, must be 0
+        param->codingOption.InterPredBlockSize   = 0; // reserved, must be 0
+        param->codingOption.MVPrecision          = 0; // reserved, must be 0
+        param->codingOption.EndOfSequence        = MFX_CODINGOPTION_UNKNOWN;
+        param->codingOption.RateDistortionOpt    = MFX_CODINGOPTION_UNKNOWN;
+        param->codingOption.CAVLC                = MFX_CODINGOPTION_UNKNOWN;
+        param->codingOption.ResetRefList         = MFX_CODINGOPTION_UNKNOWN;
+        param->codingOption.MaxDecFrameBuffering = 0; // unspecified
+        param->codingOption.AUDelimiter          = MFX_CODINGOPTION_OFF;
+        param->codingOption.SingleSeiNalUnit     = MFX_CODINGOPTION_UNKNOWN;
+        param->codingOption.PicTimingSEI         = MFX_CODINGOPTION_OFF;
+        param->codingOption.VuiNalHrdParameters  = MFX_CODINGOPTION_UNKNOWN;
+        param->codingOption.FramePicture         = MFX_CODINGOPTION_UNKNOWN;
+        // introduced in API 1.3
+        param->codingOption.RefPicMarkRep        = MFX_CODINGOPTION_UNKNOWN;
+        param->codingOption.FieldOutput          = MFX_CODINGOPTION_UNKNOWN;
+        param->codingOption.NalHrdConformance    = MFX_CODINGOPTION_UNKNOWN;
+        param->codingOption.SingleSeiNalUnit     = MFX_CODINGOPTION_UNKNOWN;
+        param->codingOption.VuiVclHrdParameters  = MFX_CODINGOPTION_UNKNOWN;
+        // introduced in API 1.4
+        param->codingOption.ViewOutput           = MFX_CODINGOPTION_UNKNOWN;
+        // introduced in API 1.6
+        param->codingOption.RecoveryPointSEI     = MFX_CODINGOPTION_UNKNOWN;
+
+        // introduced in API 1.3
+        memset(&param->videoSignalInfo, 0, sizeof(mfxExtVideoSignalInfo));
+        param->videoSignalInfo.Header.BufferId          = MFX_EXTBUFF_VIDEO_SIGNAL_INFO;
+        param->videoSignalInfo.Header.BufferSz          = sizeof(mfxExtVideoSignalInfo);
+        param->videoSignalInfo.VideoFormat              = 5; // undefined
+        param->videoSignalInfo.VideoFullRange           = 0; // TV range
+        param->videoSignalInfo.ColourDescriptionPresent = 0; // don't write to bitstream
+        param->videoSignalInfo.ColourPrimaries          = 2; // undefined
+        param->videoSignalInfo.TransferCharacteristics  = 2; // undefined
+        param->videoSignalInfo.MatrixCoefficients       = 2; // undefined
+
+        // introduced in API 1.6
+        memset(&param->codingOption2, 0, sizeof(mfxExtCodingOption2));
+        param->codingOption2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
+        param->codingOption2.Header.BufferSz = sizeof(mfxExtCodingOption2);
+        param->codingOption2.IntRefType      = 0;
+        param->codingOption2.IntRefCycleSize = 2;
+        param->codingOption2.IntRefQPDelta   = 0;
+        param->codingOption2.MaxFrameSize    = 0;
+        param->codingOption2.BitrateLimit    = MFX_CODINGOPTION_ON;
+        param->codingOption2.ExtBRC          = MFX_CODINGOPTION_OFF;
+        param->codingOption2.MBBRC           = MFX_CODINGOPTION_UNKNOWN;
+        // introduced in API 1.7
+        param->codingOption2.LookAheadDepth  = 40;
+        param->codingOption2.Trellis         = MFX_TRELLIS_UNKNOWN;
+
+        // GOP & rate control
+        param->gop.gop_pic_size       = -1; // set automatically
+        param->gop.int_ref_cycle_size = -1; // set automatically
+        param->rc.lookahead           = -1; // set automatically
+        param->rc.cqp_offsets[0]      =  0;
+        param->rc.cqp_offsets[1]      =  2;
+        param->rc.cqp_offsets[2]      =  4;
+        param->rc.vbv_max_bitrate     =  0;
+        param->rc.vbv_buffer_size     =  0;
+        param->rc.vbv_buffer_init     = .5;
+
+        // introduced in API 1.0
+        memset(videoParam, 0, sizeof(mfxVideoParam));
+        param->videoParam                   = videoParam;
+        param->videoParam->Protected        = 0; // reserved, must be 0
+        param->videoParam->NumExtParam      = 0;
+        param->videoParam->IOPattern        = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
+        param->videoParam->mfx.TargetUsage  = MFX_TARGETUSAGE_2;
+        param->videoParam->mfx.GopOptFlag   = MFX_GOP_CLOSED;
+        param->videoParam->mfx.NumThread    = 0; // deprecated, must be 0
+        param->videoParam->mfx.EncodedOrder = 0; // input is in display order
+        param->videoParam->mfx.IdrInterval  = 0; // all I-frames are IDR
+        param->videoParam->mfx.NumSlice     = 0; // use Media SDK default
+        param->videoParam->mfx.NumRefFrame  = 0; // use Media SDK default
+        param->videoParam->mfx.GopPicSize   = 0; // use Media SDK default
+        param->videoParam->mfx.GopRefDist   = 4; // power of 2, >= 4: B-pyramid
+        // introduced in API 1.1
+        param->videoParam->AsyncDepth = AV_QSV_ASYNC_DEPTH_DEFAULT;
+        // introduced in API 1.3
+        param->videoParam->mfx.BRCParamMultiplier = 0; // no multiplier
+
+        // FrameInfo: set by video encoder, except PicStruct
+        param->videoParam->mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
+
+        // attach supported mfxExtBuffer structures to the mfxVideoParam
+        param->videoParam->NumExtParam                                = 0;
+        param->videoParam->ExtParam                                   = param->ExtParamArray;
+        param->videoParam->ExtParam[param->videoParam->NumExtParam++] = (mfxExtBuffer*)&param->codingOption;
+        param->videoParam->ExtParam[param->videoParam->NumExtParam++] = (mfxExtBuffer*)&param->videoSignalInfo;
+        if (hb_qsv_info->capabilities & HB_QSV_CAP_MSDK_API_1_6)
+        {
+            param->videoParam->ExtParam[param->videoParam->NumExtParam++] = (mfxExtBuffer*)&param->codingOption2;
+        }
+    }
+    else
+    {
+        hb_error("hb_qsv_param_default: invalid pointer(s)");
+        return -1;
+    }
+    return 0;
+}
diff --git a/libhb/qsv_common.h b/libhb/qsv_common.h
new file mode 100644
index 000000000..cd85d33a2
--- /dev/null
+++ b/libhb/qsv_common.h
@@ -0,0 +1,119 @@
+/* qsv_common.h
+ *
+ * Copyright (c) 2003-2013 HandBrake Team
+ * This file is part of the HandBrake source code.
+ * Homepage: <http://handbrake.fr/>.
+ * It may be used under the terms of the GNU General Public License v2.
+ * For full terms see the file COPYING file or visit http://www.gnu.org/licenses/gpl-2.0.html
+ */
+
+#ifndef HB_QSV_COMMON_H
+#define HB_QSV_COMMON_H
+
+#include "msdk/mfxvideo.h"
+#include "libavcodec/avcodec.h"
+
+/* Minimum Intel Media SDK version (currently 1.3, for Sandy Bridge support) */
+#define HB_QSV_MINVERSION_MAJOR AV_QSV_MSDK_VERSION_MAJOR
+#define HB_QSV_MINVERSION_MINOR AV_QSV_MSDK_VERSION_MINOR
+
+/*
+ * Get & store all available Intel Quick Sync information:
+ *
+ * - general availability
+ * - available implementations (hardware-accelerated, software fallback, etc.)
+ * - available codecs, filters, etc. for direct access (convenience)
+ * - supported API version
+ * - supported resolutions
+ */
+typedef struct hb_qsv_info_s
+{
+    // supported version-specific or hardware-specific capabilities
+    int capabilities;
+#define HB_QSV_CAP_H264_BPYRAMID     (1 << 0) // H.264: reference B-frames
+#define HB_QSV_CAP_MSDK_API_1_6      (1 << 1) // Support for API 1.6 or later
+#define HB_QSV_CAP_OPTION2_BRC       (1 << 2) // mfxExtCodingOption2: MBBRC/ExtBRC
+#define HB_QSV_CAP_OPTION2_LOOKAHEAD (1 << 3) // mfxExtCodingOption2: LookAhead
+#define HB_QSV_CAP_OPTION2_TRELLIS   (1 << 4) // mfxExtCodingOption2: Trellis
+
+    // TODO: add available decoders, filters, encoders,
+    //       maximum decode and encode resolution, etc.
+} hb_qsv_info_t;
+
+/* Global Intel QSV information for use by the UIs */
+extern hb_qsv_info_t *hb_qsv_info;
+
+/* Intel Quick Sync Video utilities */
+int  hb_qsv_available();
+int  hb_qsv_info_init();
+void hb_qsv_info_print();
+
+/* Intel Quick Sync Video DECODE utilities */
+const char* hb_qsv_decode_get_codec_name(enum AVCodecID codec_id);
+int hb_qsv_decode_is_enabled(hb_job_t *job);
+int hb_qsv_decode_is_supported(enum AVCodecID codec_id, enum AVPixelFormat pix_fmt);
+
+/* Media SDK parameters handling */
+enum
+{
+    HB_QSV_PARAM_OK,
+    HB_QSV_PARAM_ERROR,
+    HB_QSV_PARAM_BAD_NAME,
+    HB_QSV_PARAM_BAD_VALUE,
+    HB_QSV_PARAM_UNSUPPORTED,
+};
+
+typedef struct
+{
+    /*
+     * Supported mfxExtBuffer.BufferId values:
+     *
+     * MFX_EXTBUFF_AVC_REFLIST_CTRL
+     * MFX_EXTBUFF_AVC_TEMPORAL_LAYERS
+     * MFX_EXTBUFF_CODING_OPTION
+     * MFX_EXTBUFF_CODING_OPTION_SPSPPS
+     * MFX_EXTBUFF_CODING_OPTION2
+     * MFX_EXTBUFF_ENCODER_CAPABILITY
+     * MFX_EXTBUFF_ENCODER_RESET_OPTION
+     * MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION
+     * MFX_EXTBUFF_PICTURE_TIMING_SEI
+     * MFX_EXTBUFF_VIDEO_SIGNAL_INFO
+     *
+     * This should cover all encode-compatible extended
+     * buffers that can be attached to an mfxVideoParam.
+     */
+#define HB_QSV_ENC_NUM_EXT_PARAM_MAX 10
+    mfxExtBuffer*         ExtParamArray[HB_QSV_ENC_NUM_EXT_PARAM_MAX];
+    mfxExtCodingOption    codingOption;
+    mfxExtCodingOption2   codingOption2;
+    mfxExtVideoSignalInfo videoSignalInfo;
+    struct
+    {
+        int gop_pic_size;
+        int int_ref_cycle_size;
+    } gop;
+    struct
+    {
+        int   lookahead;
+        int   cqp_offsets[3];
+        int   vbv_max_bitrate;
+        int   vbv_buffer_size;
+        float vbv_buffer_init;
+    } rc;
+
+    // assigned via hb_qsv_param_default, may be shared with another structure
+    mfxVideoParam *videoParam;
+} hb_qsv_param_t;
+
+#define HB_QSV_CLIP3(min, max, val) ((val < min) ? min : (val > max) ? max : val)
+int   hb_qsv_codingoption_xlat(int val);
+int   hb_qsv_trellisvalue_xlat(int val);
+int   hb_qsv_atoindex(const char* const *arr, const char *str, int *err);
+int   hb_qsv_atobool (const char *str, int *err);
+int   hb_qsv_atoi    (const char *str, int *err);
+float hb_qsv_atof    (const char *str, int *err);
+
+int hb_qsv_param_default(hb_qsv_param_t *param, mfxVideoParam *videoParam);
+int hb_qsv_param_parse  (hb_qsv_param_t *param, const char *key, const char *value, int vcodec);
+
+#endif
diff --git a/libhb/qsv_filter.c b/libhb/qsv_filter.c
new file mode 100644
index 000000000..3de9d6254
--- /dev/null
+++ b/libhb/qsv_filter.c
@@ -0,0 +1,648 @@
+/* ********************************************************************* *\
+
+Copyright (C) 2013 Intel Corporation.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+- Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+- Neither the name of Intel Corporation nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL INTEL CORPORATION BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+\* ********************************************************************* */
+
+#include "hb.h"
+#include "hbffmpeg.h"
+#include "libavcodec/qsv.h"
+#include "qsv_filter.h"
+#include "enc_qsv.h"
+
+struct hb_filter_private_s
+{
+    hb_job_t            *job;
+    hb_list_t           *list;
+
+    int                 width_in;
+    int                 height_in;
+    int                 pix_fmt;
+    int                 pix_fmt_out;
+    int                 width_out;
+    int                 height_out;
+    int                 crop[4];
+    int                 deinterlace;
+    int                 is_frc_used;
+
+    av_qsv_space           *vpp_space;
+
+    // FRC param(s)
+    mfxExtVPPFrameRateConversion    frc_config;
+};
+
+static int hb_qsv_filter_init( hb_filter_object_t * filter,
+                               hb_filter_init_t * init );
+
+static int hb_qsv_filter_work( hb_filter_object_t * filter,
+                               hb_buffer_t ** buf_in,
+                               hb_buffer_t ** buf_out );
+
+static int hb_qsv_filter_info( hb_filter_object_t * filter,
+                               hb_filter_info_t * info );
+
+static void hb_qsv_filter_close( hb_filter_object_t * filter );
+
+hb_filter_object_t hb_filter_qsv =
+{
+    .id            = HB_FILTER_QSV,
+    .enforce_order = 1,
+    .name          = "Quick Sync Video VPP",
+    .settings      = NULL,
+    .init          = hb_qsv_filter_init,
+    .work          = hb_qsv_filter_work,
+    .close         = hb_qsv_filter_close,
+    .info          = hb_qsv_filter_info,
+};
+
+static int filter_init( av_qsv_context* qsv, hb_filter_private_t * pv ){
+    mfxStatus sts;
+    int i=0;
+
+    if(!qsv) return 3;
+
+
+    if(!qsv->vpp_space){
+        qsv->vpp_space = av_qsv_list_init(HAVE_THREADS);
+    }
+    if(!pv->vpp_space){
+        for(i=0; i<av_qsv_list_count(qsv->vpp_space);i++){
+            av_qsv_space *qsv_vpp = av_qsv_list_item( qsv->vpp_space, i );
+            if(qsv_vpp->type == AV_QSV_VPP_DEFAULT){
+                pv->vpp_space = qsv_vpp;
+                break;
+            }
+        }
+    }
+
+    if(!pv->vpp_space){
+        pv->vpp_space = calloc( 1, sizeof( av_qsv_space ));
+        pv->vpp_space->type = AV_QSV_VPP_DEFAULT;
+        av_qsv_list_add( qsv->vpp_space, pv->vpp_space );
+    }
+    else
+        if(pv->vpp_space->is_init_done ) return 1;
+
+    if(!qsv->dec_space || !qsv->dec_space->is_init_done) return 2;
+
+    // we need to know final output settings before we can properly configure
+    if (!pv->job->qsv_enc_info.is_init_done)
+    {
+        return 2;
+    }
+
+    av_qsv_add_context_usage(qsv,HAVE_THREADS);
+
+    // see params needed like at mediasdk-man.pdf:"Appendix A: Configuration Parameter Constraints"
+    // for now - most will take from the decode
+    {
+        av_qsv_space *qsv_vpp = pv->vpp_space;
+        AV_QSV_ZERO_MEMORY(qsv_vpp->m_mfxVideoParam);
+
+        if (pv->deinterlace)
+        {
+            /*
+             * Input may be progressive, interlaced or even mixed, so init with
+             * MFX_PICSTRUCT_UNKNOWN and use per-frame field order information
+             * (mfxFrameSurface1.Info.PicStruct)
+             */
+            qsv_vpp->m_mfxVideoParam.vpp.In.PicStruct  = MFX_PICSTRUCT_UNKNOWN;
+            qsv_vpp->m_mfxVideoParam.vpp.Out.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
+        }
+        else
+        {
+            /* Same PicStruct in/out: no filtering */
+            qsv_vpp->m_mfxVideoParam.vpp.In.PicStruct  = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.PicStruct;
+            qsv_vpp->m_mfxVideoParam.vpp.Out.PicStruct = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.PicStruct;
+        }
+
+        // FrameRate is important for VPP to start with
+        if( qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN == 0 &&
+            qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD == 0 ){
+            qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN = pv->job->title->rate;
+            qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD = pv->job->title->rate_base;
+        }
+
+        qsv_vpp->m_mfxVideoParam.vpp.In.FourCC          = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FourCC;
+        qsv_vpp->m_mfxVideoParam.vpp.In.ChromaFormat    = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.ChromaFormat;
+        qsv_vpp->m_mfxVideoParam.vpp.In.CropX           = pv->crop[2];
+        qsv_vpp->m_mfxVideoParam.vpp.In.CropY           = pv->crop[0];
+        qsv_vpp->m_mfxVideoParam.vpp.In.CropW           = pv-> width_in - pv->crop[3] - pv->crop[2];
+        qsv_vpp->m_mfxVideoParam.vpp.In.CropH           = pv->height_in - pv->crop[1] - pv->crop[0];
+        qsv_vpp->m_mfxVideoParam.vpp.In.FrameRateExtN   = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN;
+        qsv_vpp->m_mfxVideoParam.vpp.In.FrameRateExtD   = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD;
+        qsv_vpp->m_mfxVideoParam.vpp.In.AspectRatioW    = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioW;
+        qsv_vpp->m_mfxVideoParam.vpp.In.AspectRatioH    = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioH;
+        qsv_vpp->m_mfxVideoParam.vpp.In.Width           = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.Width;
+        qsv_vpp->m_mfxVideoParam.vpp.In.Height          = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.Height;
+
+        qsv_vpp->m_mfxVideoParam.vpp.Out.FourCC          = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FourCC;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.ChromaFormat    = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.ChromaFormat;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.CropX           = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.CropX;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.CropY           = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.CropY;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.CropW           = pv->width_out;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.CropH           = pv->height_out;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.FrameRateExtN   = pv->job->vrate;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.FrameRateExtD   = pv->job->vrate_base;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.AspectRatioW    = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioW;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.AspectRatioH    = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioH;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.Width           = pv->job->qsv_enc_info.align_width;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.Height          = pv->job->qsv_enc_info.align_height;
+
+        qsv_vpp->m_mfxVideoParam.IOPattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY | MFX_IOPATTERN_OUT_OPAQUE_MEMORY;
+
+        qsv_vpp->m_mfxVideoParam.AsyncDepth = pv->job->qsv_async_depth;
+
+        memset(&qsv_vpp->request, 0, sizeof(mfxFrameAllocRequest)*2);
+
+        sts = MFXVideoVPP_QueryIOSurf(qsv->mfx_session, &qsv_vpp->m_mfxVideoParam, qsv_vpp->request );
+        AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
+
+        int num_surfaces_in  = qsv_vpp->request[0].NumFrameSuggested;
+        int num_surfaces_out = qsv_vpp->request[1].NumFrameSuggested;
+
+        av_qsv_config *config = qsv->qsv_config;
+
+
+        qsv_vpp->surface_num = FFMIN( num_surfaces_in + num_surfaces_out + qsv_vpp->m_mfxVideoParam.AsyncDepth + config ? config->additional_buffers/2 :0 , AV_QSV_SURFACE_NUM );
+        if(qsv_vpp->surface_num <= 0 )
+            qsv_vpp->surface_num = AV_QSV_SURFACE_NUM;
+
+        int i = 0;
+        for (i = 0; i < qsv_vpp->surface_num; i++){
+            qsv_vpp->p_surfaces[i] = av_mallocz( sizeof(mfxFrameSurface1) );
+            AV_QSV_CHECK_POINTER(qsv_vpp->p_surfaces[i], MFX_ERR_MEMORY_ALLOC);
+            memcpy(&(qsv_vpp->p_surfaces[i]->Info), &(qsv_vpp->m_mfxVideoParam.vpp.Out), sizeof(mfxFrameInfo));
+        }
+
+        qsv_vpp->sync_num = FFMIN( qsv_vpp->surface_num, AV_QSV_SYNC_NUM );
+
+        for (i = 0; i < qsv_vpp->sync_num; i++){
+            qsv_vpp->p_syncp[i] = av_mallocz(sizeof(av_qsv_sync));
+            AV_QSV_CHECK_POINTER(qsv_vpp->p_syncp[i], MFX_ERR_MEMORY_ALLOC);
+            qsv_vpp->p_syncp[i]->p_sync = av_mallocz(sizeof(mfxSyncPoint));
+            AV_QSV_CHECK_POINTER(qsv_vpp->p_syncp[i]->p_sync, MFX_ERR_MEMORY_ALLOC);
+        }
+/*
+    about available VPP filters, see "Table 4 Configurable VPP filters", mediasdk-man.pdf
+    Hints (optional feature) IDs:
+    MFX_EXTBUFF_VPP_DENOISE                 // Remove noise
+                                            //    Value of 0-100 (inclusive) indicates
+                                            //    the level of noise to remove.
+    MFX_EXTBUFF_VPP_DETAIL                  // Enhance picture details/edges:
+                                            //    0-100 value (inclusive) to indicate
+                                            //    the level of details to be enhanced.
+    MFX_EXTBUFF_VPP_FRAME_RATE_CONVERSION   // Convert input frame rate to match the output, based on frame interpolation:
+                                            //    MFX_FRCALGM_PRESERVE_TIMESTAMP,
+                                            //    MFX_FRCALGM_DISTRIBUTED_TIMESTAMP,
+                                            //    MFX_FRCALGM_FRAME_INTERPOLATION
+    MFX_EXTBUFF_VPP_IMAGE_STABILIZATION     // Perform image stabilization
+                                            //  Stabilization modes:
+                                            //      MFX_IMAGESTAB_MODE_UPSCALE
+                                            //      MFX_IMAGESTAB_MODE_BOXING
+    MFX_EXTBUFF_VPP_PICSTRUCT_DETECTION     // Perform detection of picture structure:
+                                            //    Detected picture structure - top field first, bottom field first, progressive or unknown
+                                            //    if video processor cannot detect picture structure.
+    MFX_EXTBUFF_VPP_PROCAMP                 // Adjust the brightness, contrast, saturation, and hue settings
+
+    // Initialize extended buffer for frame processing
+    // - Process amplifier (ProcAmp) used to control brightness
+    // - mfxExtVPPDoUse:   Define the processing algorithm to be used
+    // - mfxExtVPPProcAmp: ProcAmp configuration
+    // - mfxExtBuffer:     Add extended buffers to VPP parameter configuration
+    mfxExtVPPDoUse extDoUse;
+    mfxU32 tabDoUseAlg[1];
+    extDoUse.Header.BufferId = MFX_EXTBUFF_VPP_DOUSE;
+    extDoUse.Header.BufferSz = sizeof(mfxExtVPPDoUse);
+    extDoUse.NumAlg  = 1;
+    extDoUse.AlgList = tabDoUseAlg;
+    tabDoUseAlg[0] = MFX_EXTBUFF_VPP_PROCAMP;
+
+    mfxExtVPPProcAmp procampConfig;
+    procampConfig.Header.BufferId = MFX_EXTBUFF_VPP_PROCAMP;
+    procampConfig.Header.BufferSz = sizeof(mfxExtVPPProcAmp);
+    procampConfig.Hue        = 0.0f;  // Default
+    procampConfig.Saturation = 1.0f;  // Default
+    procampConfig.Contrast   = 1.0;   // Default
+    procampConfig.Brightness = 40.0;  // Adjust brightness
+
+    mfxExtBuffer* ExtBuffer[2];
+    ExtBuffer[0] = (mfxExtBuffer*)&extDoUse;
+    ExtBuffer[1] = (mfxExtBuffer*)&procampConfig;
+    VPPParams.NumExtParam = 2;
+    VPPParams.ExtParam = (mfxExtBuffer**)&ExtBuffer[0];
+*/
+        memset(&qsv_vpp->ext_opaque_alloc, 0, sizeof(qsv_vpp->ext_opaque_alloc));
+
+        if( (qsv_vpp->m_mfxVideoParam.vpp.In.FrameRateExtN  /  qsv_vpp->m_mfxVideoParam.vpp.In.FrameRateExtD ) !=
+            (qsv_vpp->m_mfxVideoParam.vpp.Out.FrameRateExtN /  qsv_vpp->m_mfxVideoParam.vpp.Out.FrameRateExtD) )
+        {
+            pv->is_frc_used = 1;
+        }
+
+        qsv_vpp->m_mfxVideoParam.NumExtParam        = qsv_vpp->p_ext_param_num = 1 + pv->is_frc_used;
+
+        qsv_vpp->p_ext_params = av_mallocz(sizeof(mfxExtBuffer *)*qsv_vpp->p_ext_param_num);
+        AV_QSV_CHECK_POINTER(qsv_vpp->p_ext_params, MFX_ERR_MEMORY_ALLOC);
+
+        qsv_vpp->m_mfxVideoParam.ExtParam           = qsv_vpp->p_ext_params;
+
+        qsv_vpp->ext_opaque_alloc.In.Surfaces       = qsv->dec_space->p_surfaces;
+        qsv_vpp->ext_opaque_alloc.In.NumSurface     = qsv->dec_space->surface_num;
+        qsv_vpp->ext_opaque_alloc.In.Type           = qsv->dec_space->request[0].Type;
+
+        qsv_vpp->ext_opaque_alloc.Out.Surfaces      = qsv_vpp->p_surfaces;
+        qsv_vpp->ext_opaque_alloc.Out.NumSurface    = qsv_vpp->surface_num;
+        qsv_vpp->ext_opaque_alloc.Out.Type          = qsv->dec_space->request[0].Type;
+
+        qsv_vpp->ext_opaque_alloc.Header.BufferId   = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
+        qsv_vpp->ext_opaque_alloc.Header.BufferSz   = sizeof(mfxExtOpaqueSurfaceAlloc);
+        qsv_vpp->p_ext_params[0]                    = (mfxExtBuffer*)&qsv_vpp->ext_opaque_alloc;
+
+        if(pv->is_frc_used)
+        {
+            pv->frc_config.Header.BufferId  = MFX_EXTBUFF_VPP_FRAME_RATE_CONVERSION;
+            pv->frc_config.Header.BufferSz  = sizeof(mfxExtVPPFrameRateConversion);
+            pv->frc_config.Algorithm        = MFX_FRCALGM_PRESERVE_TIMESTAMP;
+
+            qsv_vpp->p_ext_params[1] = (mfxExtBuffer*)&pv->frc_config;
+        }
+
+        sts = MFXVideoVPP_Init(qsv->mfx_session, &qsv_vpp->m_mfxVideoParam);
+
+        AV_QSV_IGNORE_MFX_STS(sts, MFX_WRN_PARTIAL_ACCELERATION);
+        AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
+
+        qsv_vpp->is_init_done = 1;
+    }
+    return 0;
+}
+
+static int hb_qsv_filter_init( hb_filter_object_t * filter,
+                               hb_filter_init_t * init )
+{
+
+    filter->private_data = calloc( 1, sizeof(struct hb_filter_private_s) );
+    hb_filter_private_t * pv = filter->private_data;
+
+    pv->list = hb_list_init();
+    // list of init params provided at work.c:~700
+    pv->width_in  = init->width;
+    pv->height_in = init->height;
+    pv->width_out = init->width;
+    pv->height_out = init->height;
+    memcpy( pv->crop, init->crop, sizeof( int[4] ) );
+
+    if (filter->settings != NULL)
+    {
+        sscanf(filter->settings, "%d:%d:%d:%d:%d:%d_dei:%d",
+               &pv->width_out, &pv->height_out,
+               &pv->crop[0], &pv->crop[1], &pv->crop[2], &pv->crop[3],
+               &pv->deinterlace);
+    }
+
+    pv->job = init->job;
+
+    // will be later as more params will be known
+    // filter_init(pv->job->qsv, pv);
+
+    // just passing
+    init->vrate = init->vrate;
+    init->vrate_base = init->vrate_base;
+
+    // framerate shaping not yet supported
+    init->cfr = 0;
+
+    init->pix_fmt = pv->pix_fmt;
+    init->width = pv->width_out;
+    init->height = pv->height_out;
+    memcpy( init->crop, pv->crop, sizeof( int[4] ) );
+
+    return 0;
+}
+
+static int hb_qsv_filter_info( hb_filter_object_t * filter,
+                               hb_filter_info_t * info )
+{
+
+    hb_filter_private_t *pv = filter->private_data;
+    if (pv == NULL)
+        return -1;
+
+    sprintf(info->human_readable_desc,
+            "source: %d * %d, crop (%d/%d/%d/%d): %d * %d, scale: %d * %d",
+            pv->width_in, pv->height_in,
+            pv->crop[0], pv->crop[1], pv->crop[2], pv->crop[3],
+            pv->width_in  - pv->crop[2] - pv->crop[3],
+            pv->height_in - pv->crop[0] - pv->crop[1],
+            pv->width_out, pv->height_out);
+
+    if (pv->deinterlace)
+    {
+        sprintf(info->human_readable_desc + strlen(info->human_readable_desc),
+                ", deinterlace");
+    }
+
+    return 0;
+}
+
+void qsv_filter_close( av_qsv_context* qsv, AV_QSV_STAGE_TYPE vpp_type ){
+    int i = 0;
+    av_qsv_space* vpp_space = 0;
+
+    if(qsv && qsv->is_context_active && qsv->vpp_space)
+    for(i=av_qsv_list_count( qsv->vpp_space);i>0;i--){
+
+        vpp_space = av_qsv_list_item( qsv->vpp_space, i-1 );
+        if( vpp_space->type == vpp_type && vpp_space->is_init_done){
+
+            hb_log( "qsv_filter[%s] done: max_surfaces: %u/%u , max_syncs: %u/%u", ((vpp_type == AV_QSV_VPP_DEFAULT)?"Default": "User") ,vpp_space->surface_num_max_used, vpp_space->surface_num, vpp_space->sync_num_max_used, vpp_space->sync_num );
+
+            for (i = 0; i < vpp_space->surface_num; i++){
+                av_freep(&vpp_space->p_surfaces[i]);
+            }
+            vpp_space->surface_num = 0;
+
+            if( vpp_space->p_ext_param_num || vpp_space->p_ext_params )
+                av_freep(&vpp_space->p_ext_params);
+            vpp_space->p_ext_param_num = 0;
+
+            for (i = 0; i < vpp_space->sync_num; i++){
+                av_freep(&vpp_space->p_syncp[i]->p_sync);
+                av_freep(&vpp_space->p_syncp[i]);
+            }
+            vpp_space->sync_num = 0;
+
+            av_qsv_list_rem(qsv->vpp_space,vpp_space);
+            if( av_qsv_list_count(qsv->vpp_space) == 0 )
+                av_qsv_list_close(&qsv->vpp_space);
+
+            vpp_space->is_init_done = 0;
+            break;
+        }
+    }
+}
+
+static void hb_qsv_filter_close( hb_filter_object_t * filter )
+{
+    int i = 0;
+    hb_filter_private_t * pv = filter->private_data;
+
+    if ( !pv )
+    {
+        return;
+    }
+
+    av_qsv_context* qsv = pv->job->qsv;
+    if(qsv && qsv->vpp_space && av_qsv_list_count(qsv->vpp_space) > 0){
+
+        // closing local stuff
+        qsv_filter_close(qsv,AV_QSV_VPP_DEFAULT);
+
+        // closing the commong stuff
+        av_qsv_context_clean(qsv);
+    }
+    hb_list_close(&pv->list);
+    free( pv );
+    filter->private_data = NULL;
+}
+
+int process_frame(av_qsv_list* received_item, av_qsv_context* qsv, hb_filter_private_t * pv ){
+
+    // 1 if have results , 0 - otherwise
+    int ret = 1;
+
+    mfxStatus sts = MFX_ERR_NONE;
+    mfxFrameSurface1 *work_surface = NULL;
+    av_qsv_stage* stage = 0;
+
+    av_qsv_space *qsv_vpp = pv->vpp_space;
+
+    if(received_item){
+        stage = av_qsv_get_last_stage( received_item );
+        work_surface = stage->out.p_surface;
+    }
+
+    int sync_idx = av_qsv_get_free_sync(qsv_vpp, qsv);
+    int surface_idx = -1;
+
+    for(;;)
+    {
+            if (sync_idx == -1)
+            {
+                hb_error("qsv: Not enough resources allocated for QSV filter");
+                ret = 0;
+                break;
+            }
+            if( sts == MFX_ERR_MORE_SURFACE || sts == MFX_ERR_NONE )
+               surface_idx = av_qsv_get_free_surface(qsv_vpp, qsv,  &(qsv_vpp->m_mfxVideoParam.vpp.Out), QSV_PART_ANY);
+            if (surface_idx == -1) {
+                hb_error("qsv: Not enough resources allocated for QSV filter");
+                ret = 0;
+                break;
+            }
+            if (work_surface) {
+                    work_surface->Info.CropX           = pv->crop[2];
+                    work_surface->Info.CropY           = pv->crop[0];
+                    work_surface->Info.CropW           = pv->width_in - pv->crop[3] - pv->crop[2];
+                    work_surface->Info.CropH           = pv->height_in - pv->crop[1] - pv->crop[0];
+            }
+
+            sts = MFXVideoVPP_RunFrameVPPAsync(qsv->mfx_session, work_surface, qsv_vpp->p_surfaces[surface_idx] , NULL, qsv_vpp->p_syncp[sync_idx]->p_sync);
+
+            if( MFX_ERR_MORE_DATA == sts ){
+                if(!qsv_vpp->pending){
+                    qsv_vpp->pending = av_qsv_list_init(0);
+                }
+
+                // if we have no results, we should not miss resource(s)
+                av_qsv_list_add( qsv_vpp->pending, received_item);
+
+                ff_qsv_atomic_dec(&qsv_vpp->p_syncp[sync_idx]->in_use);
+
+                ret = 0;
+                break;
+            }
+
+            if( MFX_ERR_MORE_DATA == sts || (MFX_ERR_NONE <= sts && MFX_WRN_DEVICE_BUSY != sts)){
+                if (work_surface){
+                   ff_qsv_atomic_dec(&work_surface->Data.Locked);
+               }
+            }
+
+            if( MFX_ERR_MORE_SURFACE == sts || MFX_ERR_NONE <= sts){
+                if( MFX_ERR_MORE_SURFACE == sts )
+                    continue;
+
+                if (qsv_vpp->p_surfaces[surface_idx] && MFX_WRN_DEVICE_BUSY != sts )
+                   ff_qsv_atomic_inc(&qsv_vpp->p_surfaces[surface_idx]->Data.Locked);
+            }
+
+            AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
+
+            if (MFX_ERR_NONE <= sts ) // repeat the call if warning and no output
+            {
+                if (MFX_WRN_DEVICE_BUSY == sts){
+                    av_qsv_sleep(10); // wait if device is busy
+                    continue;
+                }
+
+                // shouldnt be a case but drain
+                if(stage){
+                        av_qsv_stage* new_stage = av_qsv_stage_init();
+
+                        new_stage->type = AV_QSV_VPP_DEFAULT;
+                        new_stage->in.p_surface  =  work_surface;
+                        new_stage->out.p_surface = qsv_vpp->p_surfaces[surface_idx];
+                        new_stage->out.sync      = qsv_vpp->p_syncp[sync_idx];
+                        av_qsv_add_stagee( &received_item, new_stage,HAVE_THREADS );
+
+                        // add pending resources for the proper reclaim later
+                        if( qsv_vpp->pending ){
+                            if( av_qsv_list_count(qsv_vpp->pending)>0 ){
+                                new_stage->pending = qsv_vpp->pending;
+                }
+                            qsv_vpp->pending = 0;
+
+                            // making free via decrement for all pending
+                            int i = 0;
+                            for (i = av_qsv_list_count(new_stage->pending); i > 0; i--){
+                                av_qsv_list *atom_list = av_qsv_list_item(new_stage->pending, i-1);
+                                av_qsv_stage *stage = av_qsv_get_last_stage( atom_list );
+                                mfxFrameSurface1 *work_surface = stage->out.p_surface;
+                                if (work_surface)
+                                   ff_qsv_atomic_dec(&work_surface->Data.Locked);
+                            }
+                        }
+                }
+                break;
+            }
+
+            ff_qsv_atomic_dec(&qsv_vpp->p_syncp[sync_idx]->in_use);
+
+            if (MFX_ERR_NOT_ENOUGH_BUFFER == sts)
+                DEBUG_ASSERT( 1,"The bitstream buffer size is insufficient." );
+
+            break;
+    }
+
+    return ret;
+}
+
+static int hb_qsv_filter_work( hb_filter_object_t * filter,
+                               hb_buffer_t ** buf_in,
+                               hb_buffer_t ** buf_out )
+{
+
+    hb_filter_private_t * pv = filter->private_data;
+    hb_buffer_t * in = *buf_in;
+    hb_buffer_t * out = *buf_out;
+    int sts = 0;
+
+    av_qsv_context* qsv = pv->job->qsv;
+
+    if ( !pv )
+    {
+        *buf_out = in;
+        *buf_in = NULL;
+        return HB_FILTER_OK;
+    }
+
+    while(1){
+        int ret = filter_init(qsv,pv);
+        if(ret >= 2)
+            av_qsv_sleep(1);
+        else
+            break;
+    }
+
+    *buf_in = NULL;
+
+    if ( in->size <= 0 )
+    {
+        while(1){
+            sts = process_frame(in->qsv_details.qsv_atom, qsv, pv);
+            if(sts)
+                hb_list_add(pv->list,in);
+            else
+                break;
+        }
+
+        hb_list_add( pv->list, in );
+        *buf_out = link_buf_list( pv );
+        return HB_FILTER_DONE;
+    }
+
+    sts = process_frame(in->qsv_details.qsv_atom, qsv, pv);
+
+    if(sts){
+        hb_list_add(pv->list,in);
+    }
+
+    if( hb_list_count(pv->list) ){
+        *buf_out = hb_list_item(pv->list,0);
+        out = *buf_out;
+        if(pv->is_frc_used && out)
+        {
+            mfxStatus sts = MFX_ERR_NONE;
+                if(out->qsv_details.qsv_atom){
+                    av_qsv_stage* stage = av_qsv_get_last_stage( out->qsv_details.qsv_atom );
+                    mfxFrameSurface1 *work_surface = stage->out.p_surface;
+
+                    av_qsv_wait_on_sync( qsv,stage );
+
+                    av_qsv_space *qsv_vpp = pv->vpp_space;
+                    int64_t duration  = ((double)qsv_vpp->m_mfxVideoParam.vpp.Out.FrameRateExtD/(double)qsv_vpp->m_mfxVideoParam.vpp.Out.FrameRateExtN ) * 90000.;
+                    out->s.start = work_surface->Data.TimeStamp;
+                    out->s.stop = work_surface->Data.TimeStamp + duration;
+                }
+        }
+        hb_list_rem(pv->list,*buf_out);
+    }
+    else
+        *buf_out = NULL;
+
+    return HB_FILTER_OK;
+}
+
+// see devavcode.c
+hb_buffer_t *link_buf_list( hb_filter_private_t *pv )
+{
+        hb_buffer_t *head = hb_list_item( pv->list, 0 );
+
+        if ( head )
+        {
+            hb_list_rem( pv->list, head );
+            hb_buffer_t *last = head, *buf;
+            while ( ( buf = hb_list_item( pv->list, 0 ) ) != NULL )
+            {
+                hb_list_rem( pv->list, buf );
+                last->next = buf;
+                last = buf;
+            }
+        }
+    return head;
+}
+
diff --git a/libhb/qsv_filter.h b/libhb/qsv_filter.h
new file mode 100644
index 000000000..e55a85cdf
--- /dev/null
+++ b/libhb/qsv_filter.h
@@ -0,0 +1,35 @@
+/* ********************************************************************* *\
+
+Copyright (C) 2013 Intel Corporation.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+- Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+- Neither the name of Intel Corporation nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL INTEL CORPORATION BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+\* ********************************************************************* */
+
+#ifndef QSV_FILTER_H
+#define QSV_FILTER_H
+
+hb_buffer_t *link_buf_list( hb_filter_private_t *pv );
+void qsv_filter_close( av_qsv_context* qsv, AV_QSV_STAGE_TYPE vpp_type );
+
+#endif // QSV_FILTER_H
diff --git a/libhb/qsv_filter_pp.c b/libhb/qsv_filter_pp.c
new file mode 100644
index 000000000..1aef1eb80
--- /dev/null
+++ b/libhb/qsv_filter_pp.c
@@ -0,0 +1,916 @@
+/* ********************************************************************* *\
+
+Copyright (C) 2013 Intel Corporation.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+- Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+- Neither the name of Intel Corporation nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL INTEL CORPORATION BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+\* ********************************************************************* */
+
+#include "hb.h"
+#include "hbffmpeg.h"
+#include "libavcodec/qsv.h"
+#include "qsv_filter_pp.h"
+#include "qsv_filter.h"
+#include "qsv_memory.h"
+
+
+static int hb_qsv_filter_pre_init( hb_filter_object_t * filter,
+                               hb_filter_init_t * init );
+static int hb_qsv_filter_pre_work( hb_filter_object_t * filter,
+                               hb_buffer_t ** buf_in,
+                               hb_buffer_t ** buf_out );
+static int hb_qsv_filter_pre_info( hb_filter_object_t * filter,
+                               hb_filter_info_t * info );
+static void hb_qsv_filter_pre_close( hb_filter_object_t * filter );
+
+static int hb_qsv_filter_post_init( hb_filter_object_t * filter,
+                               hb_filter_init_t * init );
+static int hb_qsv_filter_post_work( hb_filter_object_t * filter,
+                               hb_buffer_t ** buf_in,
+                               hb_buffer_t ** buf_out );
+static int hb_qsv_filter_post_info( hb_filter_object_t * filter,
+                               hb_filter_info_t * info );
+static void hb_qsv_filter_post_close( hb_filter_object_t * filter );
+
+
+hb_filter_object_t hb_filter_qsv_pre =
+{
+    .id            = HB_FILTER_QSV_PRE,
+    .enforce_order = 1,
+    .name          = "Quick Sync Video user filter (pre)",
+    .settings      = NULL,
+    .init          = hb_qsv_filter_pre_init,
+    .work          = hb_qsv_filter_pre_work,
+    .close         = hb_qsv_filter_pre_close,
+    .info          = hb_qsv_filter_pre_info,
+};
+
+hb_filter_object_t hb_filter_qsv_post =
+{
+    .id            = HB_FILTER_QSV_POST,
+    .enforce_order = 1,
+    .name          = "Quick Sync Video user filter (post)",
+    .settings      = NULL,
+    .init          = hb_qsv_filter_post_init,
+    .work          = hb_qsv_filter_post_work,
+    .close         = hb_qsv_filter_post_close,
+    .info          = hb_qsv_filter_post_info,
+};
+
+
+static int filter_pre_init( av_qsv_context* qsv, hb_filter_private_t * pv ){
+    mfxStatus sts = MFX_ERR_NONE;
+    int i=0;
+
+    if(!qsv) return 3;
+
+    av_qsv_space *prev_vpp = 0;
+
+    if(!qsv->vpp_space){
+        qsv->vpp_space = av_qsv_list_init(HAVE_THREADS);
+        // note some change as : when no size changes -> no VPP used
+        // impact on : prev_vpp
+    }
+
+    if(!pv->vpp_space){
+        for(i=0; i<av_qsv_list_count(qsv->vpp_space);i++){
+            av_qsv_space *qsv_vpp = av_qsv_list_item( qsv->vpp_space, i );
+            if(qsv_vpp->type == AV_QSV_VPP_USER){
+                pv->vpp_space = qsv_vpp;
+                break;
+            }
+            else
+            if(qsv_vpp->type == AV_QSV_VPP_DEFAULT){
+                prev_vpp = qsv_vpp;
+            }
+
+        }
+    }
+
+    if(!pv->vpp_space){
+        pv->vpp_space = calloc( 1, sizeof( av_qsv_space ));
+        pv->vpp_space->type = AV_QSV_VPP_USER;
+        av_qsv_list_add( qsv->vpp_space, pv->vpp_space );
+        av_qsv_add_context_usage(qsv,HAVE_THREADS);
+    }
+    else
+        if(pv->vpp_space->is_init_done ) return 1;
+
+    if(!qsv->dec_space || !qsv->dec_space->is_init_done) return 2;
+
+    av_qsv_space *qsv_vpp = pv->vpp_space;
+
+    AV_QSV_ZERO_MEMORY(qsv_vpp->m_mfxVideoParam);
+
+
+    if (prev_vpp)
+    {
+        memcpy( &qsv_vpp->m_mfxVideoParam.vpp,  &prev_vpp->m_mfxVideoParam.vpp, sizeof(prev_vpp->m_mfxVideoParam.vpp));
+    }
+    else
+    {
+        AV_QSV_ZERO_MEMORY(qsv_vpp->m_mfxVideoParam);
+
+        // FrameRate is important for VPP to start with
+        if( qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN == 0 &&
+            qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD == 0 ){
+            qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN = pv->job->title->rate;
+            qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD = pv->job->title->rate_base;
+        }
+
+        qsv_vpp->m_mfxVideoParam.vpp.In.FourCC          = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FourCC;
+        qsv_vpp->m_mfxVideoParam.vpp.In.ChromaFormat    = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.ChromaFormat;
+        qsv_vpp->m_mfxVideoParam.vpp.In.CropX           = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.CropX;
+        qsv_vpp->m_mfxVideoParam.vpp.In.CropY           = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.CropY;
+        qsv_vpp->m_mfxVideoParam.vpp.In.CropW           = pv->job->title->width;
+        qsv_vpp->m_mfxVideoParam.vpp.In.CropH           = pv->job->title->height;
+        qsv_vpp->m_mfxVideoParam.vpp.In.PicStruct       = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.PicStruct;
+        qsv_vpp->m_mfxVideoParam.vpp.In.FrameRateExtN   = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN;
+        qsv_vpp->m_mfxVideoParam.vpp.In.FrameRateExtD   = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD;
+        qsv_vpp->m_mfxVideoParam.vpp.In.AspectRatioW    = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioW;
+        qsv_vpp->m_mfxVideoParam.vpp.In.AspectRatioH    = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioH;
+        qsv_vpp->m_mfxVideoParam.vpp.In.Width           = AV_QSV_ALIGN16(pv->job->title->width);
+        qsv_vpp->m_mfxVideoParam.vpp.In.Height          = (MFX_PICSTRUCT_PROGRESSIVE == qsv_vpp->m_mfxVideoParam.vpp.In.PicStruct)?
+                                                            AV_QSV_ALIGN16(pv->job->title->height) : AV_QSV_ALIGN32(pv->job->title->height);
+
+        qsv_vpp->m_mfxVideoParam.vpp.Out.FourCC          = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FourCC;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.ChromaFormat    = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.ChromaFormat;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.CropX           = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.CropX;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.CropY           = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.CropY;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.CropW           = pv->job->title->width;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.CropH           = pv->job->title->height;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.PicStruct       = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.PicStruct;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.FrameRateExtN   = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.FrameRateExtD   = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.AspectRatioW    = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioW;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.AspectRatioH    = qsv->dec_space->m_mfxVideoParam.mfx.FrameInfo.AspectRatioH;
+        qsv_vpp->m_mfxVideoParam.vpp.Out.Width           = AV_QSV_ALIGN16(pv->job->title->width);
+        qsv_vpp->m_mfxVideoParam.vpp.Out.Height          = (MFX_PICSTRUCT_PROGRESSIVE == qsv_vpp->m_mfxVideoParam.vpp.In.PicStruct)?
+                                                            AV_QSV_ALIGN16(pv->job->title->height) : AV_QSV_ALIGN32(pv->job->title->height);
+
+        memset(&qsv_vpp->request, 0, sizeof(mfxFrameAllocRequest)*2);
+    }
+
+    qsv_vpp->m_mfxVideoParam.IOPattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY | MFX_IOPATTERN_OUT_OPAQUE_MEMORY;
+
+    qsv_vpp->surface_num = FFMIN(prev_vpp ? prev_vpp->surface_num : qsv->dec_space->surface_num/2, AV_QSV_SURFACE_NUM);
+
+    for(i = 0; i < qsv_vpp->surface_num; i++){
+        qsv_vpp->p_surfaces[i] = av_mallocz( sizeof(mfxFrameSurface1) );
+        AV_QSV_CHECK_POINTER(qsv_vpp->p_surfaces[i], MFX_ERR_MEMORY_ALLOC);
+        memcpy(&(qsv_vpp->p_surfaces[i]->Info), &(qsv_vpp->m_mfxVideoParam.vpp.Out), sizeof(mfxFrameInfo));
+    }
+
+    qsv_vpp->sync_num = FFMIN(prev_vpp ? prev_vpp->sync_num : qsv->dec_space->sync_num, AV_QSV_SYNC_NUM);
+    for (i = 0; i < qsv_vpp->sync_num; i++){
+        qsv_vpp->p_syncp[i] = av_mallocz(sizeof(av_qsv_sync));
+        AV_QSV_CHECK_POINTER(qsv_vpp->p_syncp[i], MFX_ERR_MEMORY_ALLOC);
+        qsv_vpp->p_syncp[i]->p_sync = av_mallocz(sizeof(mfxSyncPoint));
+        AV_QSV_CHECK_POINTER(qsv_vpp->p_syncp[i]->p_sync, MFX_ERR_MEMORY_ALLOC);
+    }
+
+    memset(&qsv_vpp->ext_opaque_alloc, 0, sizeof(mfxExtOpaqueSurfaceAlloc));
+    qsv_vpp->m_mfxVideoParam.NumExtParam        = qsv_vpp->p_ext_param_num = 1;
+
+    qsv_vpp->p_ext_params = av_mallocz(sizeof(mfxExtBuffer *)*qsv_vpp->p_ext_param_num);
+    AV_QSV_CHECK_POINTER(qsv_vpp->p_ext_params, MFX_ERR_MEMORY_ALLOC);
+
+    qsv_vpp->m_mfxVideoParam.ExtParam           = qsv_vpp->p_ext_params;
+
+    qsv_vpp->ext_opaque_alloc.Header.BufferId   = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
+    qsv_vpp->ext_opaque_alloc.Header.BufferSz   = sizeof(mfxExtOpaqueSurfaceAlloc);
+    qsv_vpp->p_ext_params[0]                    = (mfxExtBuffer*)&qsv_vpp->ext_opaque_alloc;
+
+    if(prev_vpp){
+        qsv_vpp->ext_opaque_alloc.In.Surfaces       = prev_vpp->p_surfaces;
+        qsv_vpp->ext_opaque_alloc.In.NumSurface     = prev_vpp->surface_num;
+    }
+    else{
+        qsv_vpp->ext_opaque_alloc.In.Surfaces       = qsv->dec_space->p_surfaces;
+        qsv_vpp->ext_opaque_alloc.In.NumSurface     = qsv->dec_space->surface_num;
+    }
+    qsv_vpp->ext_opaque_alloc.In.Type           = qsv->dec_space->request[0].Type;
+
+    qsv_vpp->ext_opaque_alloc.Out.Surfaces      = qsv_vpp->p_surfaces;
+    qsv_vpp->ext_opaque_alloc.Out.NumSurface    = qsv_vpp->surface_num;
+    qsv_vpp->ext_opaque_alloc.Out.Type          = qsv->dec_space->request[0].Type;
+
+    pv->qsv_user = hb_list_init();
+
+    qsv_filter_t *plugin = av_mallocz( sizeof(qsv_filter_t) );
+
+    plugin->pv               = pv;
+    plugin->plug.pthis       = plugin;
+    plugin->plug.PluginInit  = qsv_PluginInit;
+    plugin->plug.PluginClose = qsv_PluginClose;
+    plugin->plug.GetPluginParam = qsv_GetPluginParam;
+    plugin->plug.Submit      = qsv_Submit;
+    plugin->plug.Execute     = qsv_Execute;
+    plugin->plug.FreeResources = qsv_FreeResources;
+
+    hb_list_add(pv->qsv_user,plugin);
+
+    sts=MFXVideoUSER_Register(qsv->mfx_session,0,&plugin->plug);
+    AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
+
+    plugin_init(plugin,&qsv_vpp->m_mfxVideoParam);
+
+    qsv_vpp->is_init_done = 1;
+
+    return 0;
+}
+
+static int hb_qsv_filter_pre_info( hb_filter_object_t * filter,
+                               hb_filter_info_t * info ){
+    hb_filter_private_t * pv = filter->private_data;
+    if( !pv )
+        return 0;
+
+    sprintf(info->human_readable_desc, "copy data to system memory");
+
+    return 0;
+}
+static int hb_qsv_filter_pre_init( hb_filter_object_t * filter,
+                               hb_filter_init_t * init ){
+    filter->private_data = calloc( 1, sizeof(struct hb_filter_private_s) );
+    hb_filter_private_t * pv = filter->private_data;
+    pv->job = init->job;
+
+    pv->pre.frame_go             = 0;
+    pv->pre.frame_completed      = hb_cond_init();
+    pv->pre.frame_completed_lock = hb_lock_init();
+
+    pv->post.frame_go            = 0;
+    pv->post.frame_completed     = hb_cond_init();
+    pv->post.frame_completed_lock = hb_lock_init();
+
+    pv->pre_busy.frame_go            = 0;
+    pv->pre_busy.frame_completed     = hb_cond_init();
+    pv->pre_busy.frame_completed_lock = hb_lock_init();
+
+    pv->post_busy.frame_go               = 0;
+    pv->post_busy.frame_completed        = hb_cond_init();
+    pv->post_busy.frame_completed_lock   = hb_lock_init();
+
+    pv->list = hb_list_init();
+
+    // just to remind:
+    // PIX_FMT_YUV420P,   ///< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples) , 3 planes: Y, U, V
+    // PIX_FMT_NV12,      ///< planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)
+    pv->sws_context_from_nv12 = hb_sws_get_context(
+                        pv->job->title->width, pv->job->title->height, AV_PIX_FMT_NV12,
+                        pv->job->title->width, pv->job->title->height, AV_PIX_FMT_YUV420P,
+                        SWS_LANCZOS|SWS_ACCURATE_RND);
+    pv->sws_context_to_nv12 = hb_sws_get_context(
+                        pv->job->title->width, pv->job->title->height, AV_PIX_FMT_YUV420P,
+                        pv->job->title->width, pv->job->title->height, AV_PIX_FMT_NV12,
+                        SWS_LANCZOS|SWS_ACCURATE_RND);
+    return 0;
+}
+int pre_process_frame(hb_buffer_t *in, av_qsv_context* qsv, hb_filter_private_t * pv ){
+
+    // 1 if have results , 0 otherwise
+    int ret = 1;
+
+    av_qsv_list* received_item = in->qsv_details.qsv_atom;
+
+    mfxStatus sts = MFX_ERR_NONE;
+    mfxFrameSurface1 *work_surface = NULL;
+    av_qsv_stage* stage = 0;
+
+    av_qsv_space *qsv_vpp = pv->vpp_space;
+
+    if (received_item)
+    {
+        stage = av_qsv_get_last_stage( received_item );
+        work_surface = stage->out.p_surface;
+    }
+
+    int sync_idx = av_qsv_get_free_sync(qsv_vpp, qsv);
+    int surface_idx = -1;
+
+    for (;;)
+    {
+            if (sync_idx == -1)
+            {
+                hb_error("qsv: Not enough resources allocated for the preprocessing filter");
+                ret = 0;
+                break;
+            }
+
+            if (sts == MFX_ERR_MORE_SURFACE || sts == MFX_ERR_NONE)
+               surface_idx = av_qsv_get_free_surface(qsv_vpp, qsv,  &(qsv_vpp->m_mfxVideoParam.vpp.Out), QSV_PART_ANY);
+            if (surface_idx == -1) {
+                hb_error("qsv: Not enough resources allocated for the preprocessing filter");
+                ret = 0;
+                break;
+            }
+
+            sts = MFXVideoUSER_ProcessFrameAsync(qsv->mfx_session, &work_surface, 1, &qsv_vpp->p_surfaces[surface_idx] , 1, qsv_vpp->p_syncp[sync_idx]->p_sync);
+
+            if (MFX_ERR_MORE_DATA == sts)
+            {
+                if (!qsv_vpp->pending)
+                {
+                    qsv_vpp->pending = av_qsv_list_init(0);
+                }
+
+                // if we have no results, we should not miss resource(s)
+                av_qsv_list_add( qsv_vpp->pending, received_item);
+
+                ff_qsv_atomic_dec(&qsv_vpp->p_syncp[sync_idx]->in_use);
+
+                ret = 0;
+                break;
+            }
+
+            if( MFX_ERR_MORE_SURFACE == sts || MFX_ERR_NONE <= sts){
+                if( MFX_ERR_MORE_SURFACE == sts )
+                    continue;
+
+                if (qsv_vpp->p_surfaces[surface_idx] && MFX_WRN_DEVICE_BUSY != sts )
+                   ff_qsv_atomic_inc(&qsv_vpp->p_surfaces[surface_idx]->Data.Locked);
+            }
+
+            AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
+
+            if (MFX_ERR_NONE <= sts ) // repeat the call if warning and no output
+            {
+                if (MFX_WRN_DEVICE_BUSY == sts){
+                    hb_lock(pv->pre_busy.frame_completed_lock);
+                    while(!pv->pre_busy.frame_go){
+                        hb_cond_timedwait(pv->pre_busy.frame_completed,pv->pre_busy.frame_completed_lock,1000);
+                        if(*pv->job->die)
+                            break;
+                    }
+                    pv->pre_busy.frame_go = 0;
+                    hb_unlock(pv->pre_busy.frame_completed_lock);
+
+                    continue;
+                }
+                hb_lock(pv->pre.frame_completed_lock);
+                while(!pv->pre.frame_go){
+                    hb_cond_timedwait(pv->pre.frame_completed,pv->pre.frame_completed_lock,1000);
+                    if(*pv->job->die)
+                        break;
+                }
+                pv->pre.frame_go = 0;
+                hb_unlock(pv->pre.frame_completed_lock);
+
+                in = pv->pre.out;
+
+                if (work_surface){
+                   ff_qsv_atomic_dec(&work_surface->Data.Locked);
+                }
+
+                // inserting for the future, will be locked until very ready
+                if(stage){
+                        av_qsv_stage* new_stage = av_qsv_stage_init();
+
+                        new_stage->type = AV_QSV_VPP_USER;
+                        new_stage->in.p_surface  =  work_surface;
+                        new_stage->out.p_surface = qsv_vpp->p_surfaces[surface_idx];
+                        new_stage->out.sync = qsv_vpp->p_syncp[sync_idx];
+                        av_qsv_add_stagee( &received_item, new_stage,HAVE_THREADS );
+
+                        // add pending resources for the proper reclaim later
+                        if( qsv_vpp->pending ){
+                            if( av_qsv_list_count(qsv_vpp->pending)>0 ){
+                                new_stage->pending = qsv_vpp->pending;
+                }
+                            qsv_vpp->pending = 0;
+
+                            // making free via decrement for all pending
+                            int i = 0;
+                            for (i = av_qsv_list_count(new_stage->pending); i > 0; i--){
+                                av_qsv_list *atom_list = av_qsv_list_item(new_stage->pending, i-1);
+                                av_qsv_stage *stage = av_qsv_get_last_stage( atom_list );
+                                mfxFrameSurface1 *work_surface = stage->out.p_surface;
+                                if (work_surface)
+                                   ff_qsv_atomic_dec(&work_surface->Data.Locked);
+                            }
+                        }
+                }
+
+                break;
+            }
+
+            ff_qsv_atomic_dec(&qsv_vpp->p_syncp[sync_idx]->in_use);
+
+            if (MFX_ERR_NOT_ENOUGH_BUFFER == sts)
+                DEBUG_ASSERT( 1,"The bitstream buffer size is insufficient." );
+
+            break;
+    }
+
+    return ret;
+}
+
+static int hb_qsv_filter_pre_work( hb_filter_object_t * filter,
+                               hb_buffer_t ** buf_in,
+                               hb_buffer_t ** buf_out ){
+    hb_filter_private_t * pv = filter->private_data;
+    hb_buffer_t * in = *buf_in;
+    hb_buffer_t * out = *buf_out;
+    int sts = 0;
+
+    av_qsv_context* qsv = pv->job->qsv;
+
+    if(!in->qsv_details.filter_details)
+        in->qsv_details.filter_details = pv;
+
+    if ( in->size <= 0 )
+    {
+        *buf_out = in;
+        *buf_in = NULL;
+        return HB_FILTER_DONE;
+    }
+
+    while(1){
+        int ret = filter_pre_init(qsv,pv);
+        if(ret >= 2)
+            av_qsv_sleep(1);
+        else
+            break;
+    }
+
+    pv->pre.in  = in;
+    pv->pre.out = in;
+
+    sts = pre_process_frame(in, qsv, pv);
+
+    if(sts){
+        hb_list_add(pv->list,out);
+    }
+
+    if( hb_list_count(pv->list) ){
+        *buf_out = hb_list_item(pv->list,0);
+        hb_list_rem(pv->list,*buf_out);
+         *buf_in = NULL;
+    }
+    else{
+        *buf_in = NULL;
+        *buf_out = in;
+    }
+
+    return HB_FILTER_OK;
+}
+static void hb_qsv_filter_pre_close( hb_filter_object_t * filter ){
+    int i = 0;
+    mfxStatus sts = MFX_ERR_NONE;
+
+    hb_filter_private_t * pv = filter->private_data;
+
+    if ( !pv )
+    {
+        return;
+    }
+
+    sws_freeContext(pv->sws_context_to_nv12);
+    sws_freeContext(pv->sws_context_from_nv12);
+
+    av_qsv_context* qsv = pv->job->qsv;
+    if(qsv && qsv->vpp_space && av_qsv_list_count(qsv->vpp_space) > 0 ){
+        if(pv->qsv_user && qsv->mfx_session){
+
+            sts=MFXVideoUSER_Unregister(qsv->mfx_session,0);
+            AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
+
+            for(i=hb_list_count(pv->qsv_user);i>0;i--){
+                qsv_filter_t *plugin = hb_list_item(pv->qsv_user,i-1);
+                hb_list_rem(pv->qsv_user,plugin);
+                plugin_close(plugin);
+            }
+            hb_list_close(&pv->qsv_user);
+        }
+
+        // closing local stuff
+        qsv_filter_close(qsv,AV_QSV_VPP_USER);
+
+        // closing the commong stuff
+        av_qsv_context_clean(qsv);
+    }
+    hb_cond_close(&pv->pre.frame_completed);
+    hb_lock_close(&pv->pre.frame_completed_lock);
+
+    hb_cond_close(&pv->post.frame_completed);
+    hb_lock_close(&pv->post.frame_completed_lock);
+
+    hb_cond_close(&pv->pre_busy.frame_completed);
+    hb_lock_close(&pv->pre_busy.frame_completed_lock);
+
+    hb_cond_close(&pv->post_busy.frame_completed);
+    hb_lock_close(&pv->post_busy.frame_completed_lock);
+
+    hb_list_close( &pv->list );
+
+    free( pv );
+    filter->private_data = NULL;
+}
+
+
+static int hb_qsv_filter_post_info( hb_filter_object_t * filter,
+                               hb_filter_info_t * info ){
+    hb_filter_private_t * pv = filter->private_data;
+    if( !pv )
+        return 0;
+
+    sprintf(info->human_readable_desc, "copy data to opaque memory");
+
+    return 0;
+}
+static int hb_qsv_filter_post_init( hb_filter_object_t * filter,
+                               hb_filter_init_t * init ){
+    filter->private_data = calloc( 1, sizeof(struct hb_filter_private_s) );
+    hb_filter_private_t * pv = filter->private_data;
+    pv->job = init->job;
+    return 0;
+}
+static int hb_qsv_filter_post_work( hb_filter_object_t * filter,
+                               hb_buffer_t ** buf_in,
+                               hb_buffer_t ** buf_out ){
+    hb_filter_private_t * pv = filter->private_data;
+    hb_buffer_t * in = *buf_in;
+    hb_buffer_t * out = *buf_out;
+
+    if ( in->size <= 0 )
+    {
+        *buf_out = in;
+        *buf_in = NULL;
+        return HB_FILTER_DONE;
+    }
+
+    av_qsv_context* qsv = pv->job->qsv;
+    pv = in->qsv_details.filter_details;
+
+    if (!pv)
+    {
+        *buf_out = NULL;
+        *buf_in = NULL;
+        return HB_FILTER_OK;
+    }
+
+    while(1){
+        int ret = filter_pre_init(qsv,pv);
+        if(ret >= 2)
+            av_qsv_sleep(1);
+        else
+            break;
+    }
+
+    pv->post.in = in;
+    pv->post.out = out;
+
+    // signal: input is prepared, can start inserting data back into pipeline
+    hb_lock(pv->post.frame_completed_lock);
+    pv->post.frame_go = 1;
+    hb_cond_broadcast(pv->post.frame_completed);
+    hb_unlock(pv->post.frame_completed_lock);
+
+    // wait: on signal that data is ready
+    hb_lock(pv->post_busy.frame_completed_lock);
+    while(!pv->post_busy.frame_go){
+        hb_cond_timedwait(pv->post_busy.frame_completed,pv->post_busy.frame_completed_lock,1000);
+        if(*pv->job->die)
+            break;
+    }
+    pv->post_busy.frame_go = 0;
+    hb_unlock(pv->post_busy.frame_completed_lock);
+
+    if (pv->post.status == HB_FILTER_OK || pv->post.status == HB_FILTER_DONE)
+    {
+    *buf_out = in;
+    }
+    else
+    {
+        *buf_out = NULL;
+        pv->post.status = HB_FILTER_OK;
+    }
+    *buf_in = NULL;
+
+    return HB_FILTER_OK;
+}
+static void hb_qsv_filter_post_close( hb_filter_object_t * filter ){
+    hb_filter_private_t * pv = filter->private_data;
+
+    if ( !pv )
+    {
+        return;
+    }
+
+    free( pv );
+    filter->private_data = NULL;
+}
+
+
+mfxStatus MFX_CDECL qsv_PluginInit(mfxHDL pthis, mfxCoreInterface *core){
+    mfxStatus sts = MFX_ERR_NONE;
+
+    if(core && pthis){
+        qsv_filter_t *plugin = pthis;
+        plugin->core = core;
+
+        plugin->pluginparam.MaxThreadNum = 1;
+        plugin->pluginparam.ThreadPolicy = MFX_THREADPOLICY_SERIAL;
+    }
+    else
+        sts = MFX_ERR_NULL_PTR;
+
+    return sts;
+}
+mfxStatus MFX_CDECL qsv_PluginClose (mfxHDL pthis){
+    mfxStatus sts = MFX_ERR_NONE;
+    return sts;
+}
+mfxStatus MFX_CDECL qsv_GetPluginParam(mfxHDL pthis, mfxPluginParam *par){
+    mfxStatus sts = MFX_ERR_NONE;
+
+    if(pthis){
+        qsv_filter_t *plugin = pthis;
+        *par = plugin->pluginparam;
+    }
+    else
+        sts = MFX_ERR_NULL_PTR;
+    return sts;
+}
+mfxStatus MFX_CDECL qsv_Submit(mfxHDL pthis, const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxThreadTask *task){
+    mfxStatus sts = MFX_ERR_NONE;
+
+    qsv_filter_t *plugin = pthis;
+
+    mfxFrameSurface1 *surface_in = (mfxFrameSurface1 *)in[0];
+    mfxFrameSurface1 *surface_out = (mfxFrameSurface1 *)out[0];
+    mfxFrameSurface1 *real_surface_in = surface_in;
+    mfxFrameSurface1 *real_surface_out = surface_out;
+
+    sts = plugin->core->GetRealSurface(plugin->core->pthis, surface_in, &real_surface_in);
+    AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, MFX_ERR_MEMORY_ALLOC);
+
+    sts = plugin->core->GetRealSurface(plugin->core->pthis, surface_out, &real_surface_out);
+    AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, MFX_ERR_MEMORY_ALLOC);
+
+    int task_idx = get_free_task(plugin->tasks);
+
+    if (task_idx == -1)
+    {
+        return MFX_WRN_DEVICE_BUSY;
+    }
+
+    plugin->core->IncreaseReference(plugin->core->pthis, &(real_surface_in->Data));
+    plugin->core->IncreaseReference(plugin->core->pthis, &(real_surface_out->Data));
+
+    // to preserve timing if other filters are used in-between
+    surface_out->Data.TimeStamp  = surface_in->Data.TimeStamp;
+    surface_out->Data.FrameOrder = surface_in->Data.FrameOrder;
+
+    qsv_filter_task_t *current_task = hb_list_item(plugin->tasks,task_idx);
+    current_task->in    = real_surface_in;
+    current_task->out   = real_surface_out;
+    current_task->busy  = 1;
+    current_task->pv    = plugin->pv;
+
+    *task = (mfxThreadTask)current_task;
+
+    return sts;
+}
+mfxStatus MFX_CDECL qsv_Execute(mfxHDL pthis, mfxThreadTask task, mfxU32 uid_p, mfxU32 uid_a){
+    mfxStatus sts = MFX_ERR_NONE;
+
+    qsv_filter_task_t *current_task = (qsv_filter_task_t *)task;
+    qsv_filter_t *plugin = pthis;
+
+    sts = (current_task->processor.process)(current_task,0);
+    AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
+
+    sts =  MFX_TASK_DONE;
+    return sts;
+}
+mfxStatus MFX_CDECL qsv_FreeResources(mfxHDL pthis, mfxThreadTask task, mfxStatus sts){
+
+    qsv_filter_t *plugin = pthis;
+    qsv_filter_task_t *current_task = (qsv_filter_task_t *)task;
+
+    plugin->core->DecreaseReference(plugin->core->pthis, &(current_task->in->Data));
+    plugin->core->DecreaseReference(plugin->core->pthis, &(current_task->out->Data));
+
+    current_task->busy  = 0;
+
+    hb_lock(plugin->pv->pre_busy.frame_completed_lock);
+    plugin->pv->pre_busy.frame_go = 1;
+    hb_cond_broadcast(plugin->pv->pre_busy.frame_completed);
+    hb_unlock(plugin->pv->pre_busy.frame_completed_lock);
+
+    return MFX_ERR_NONE;
+}
+
+mfxStatus plugin_init(qsv_filter_t* plugin, mfxVideoParam *param){
+    mfxStatus sts = MFX_ERR_NONE;
+
+    if(plugin->is_init_done) return sts;
+
+    plugin->videoparam = param;
+
+    mfxExtOpaqueSurfaceAlloc* plugin_opaque_alloc = NULL;
+
+    plugin_opaque_alloc = (mfxExtOpaqueSurfaceAlloc*) get_ext_buffer(plugin->videoparam->ExtParam,
+                                    plugin->videoparam->NumExtParam, MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION);
+
+    if(!plugin_opaque_alloc || !plugin_opaque_alloc->In.Surfaces || !plugin_opaque_alloc->Out.Surfaces)
+        return MFX_ERR_INVALID_VIDEO_PARAM;
+
+    sts = plugin->core->MapOpaqueSurface(plugin->core->pthis, plugin_opaque_alloc->In.NumSurface,
+            plugin_opaque_alloc->In.Type, plugin_opaque_alloc->In.Surfaces);
+    AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
+
+
+    sts = plugin->core->MapOpaqueSurface(plugin->core->pthis, plugin_opaque_alloc->Out.NumSurface,
+            plugin_opaque_alloc->Out.Type, plugin_opaque_alloc->Out.Surfaces);
+    AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
+
+
+    plugin->tasks = hb_list_init();
+    qsv_filter_task_t *task = calloc( 1, sizeof( qsv_filter_task_t ));
+
+    task->processor.process = process_filter;
+    task->processor.alloc   = &plugin->core->FrameAllocator;
+    task->processor.core   = plugin->core;
+
+    hb_list_add(plugin->tasks,task);
+
+    plugin->is_init_done = 1;
+
+    return sts;
+}
+
+mfxStatus plugin_close(qsv_filter_t* plugin){
+    int i = 0;
+    mfxStatus sts = MFX_ERR_NONE;
+
+    if(!plugin->is_init_done) return sts;
+
+    mfxExtOpaqueSurfaceAlloc* plugin_opaque_alloc = NULL;
+
+    plugin_opaque_alloc = (mfxExtOpaqueSurfaceAlloc*) get_ext_buffer(plugin->videoparam->ExtParam,
+                                    plugin->videoparam->NumExtParam, MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION);
+
+    if(!plugin_opaque_alloc || !plugin_opaque_alloc->In.Surfaces || !plugin_opaque_alloc->Out.Surfaces)
+        return MFX_ERR_INVALID_VIDEO_PARAM;
+
+    sts = plugin->core->UnmapOpaqueSurface(plugin->core->pthis, plugin_opaque_alloc->In.NumSurface,
+            plugin_opaque_alloc->In.Type, plugin_opaque_alloc->In.Surfaces);
+    AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
+
+
+    sts = plugin->core->UnmapOpaqueSurface(plugin->core->pthis, plugin_opaque_alloc->Out.NumSurface,
+            plugin_opaque_alloc->Out.Type, plugin_opaque_alloc->Out.Surfaces);
+    AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
+
+    if(plugin->tasks){
+        for(i=hb_list_count(plugin->tasks);i>0;i--){
+            qsv_filter_task_t *task = hb_list_item(plugin->tasks,i-1);
+            hb_list_rem(plugin->tasks,task);
+            free(task);
+        }
+        hb_list_close(&plugin->tasks);
+    }
+
+    plugin->is_init_done = 0;
+
+    return sts;
+}
+
+mfxExtBuffer* get_ext_buffer(mfxExtBuffer** buffers, mfxU32 buffers_num, mfxU32 buffer_id){
+    int i = 0;
+    if(!buffers) return 0;
+    for(i=0;i<buffers_num;i++){
+        if(!buffers[i]) continue;
+        if(buffers[i]->BufferId == buffer_id)
+            return buffers[i];
+    }
+    return 0;
+}
+
+int get_free_task(hb_list_t* tasks){
+    int ret = -1;
+    int i = 0;
+    for(i=0;i<hb_list_count(tasks);i++){
+        qsv_filter_task_t* task = hb_list_item(tasks,i);
+        if(!task->busy){
+            ret = i;
+            break;
+        }
+    }
+    return ret;
+}
+
+mfxStatus lock_frame(mfxFrameAllocator *alloc,mfxFrameSurface1 *surface){
+    mfxStatus sts = MFX_ERR_NONE;
+    // prevent double lock
+    if (surface->Data.Y != 0 && surface->Data.MemId !=0){
+        return MFX_ERR_UNSUPPORTED;
+    }
+    // not allocated, therefore no lock
+    if (surface->Data.Y != 0){
+        return MFX_ERR_NONE;
+    }
+    sts = alloc->Lock(alloc->pthis,surface->Data.MemId,&surface->Data);
+    return sts;
+}
+
+mfxStatus unlock_frame(mfxFrameAllocator *alloc,mfxFrameSurface1 *surface){
+    mfxStatus sts = MFX_ERR_NONE;
+    // not allocated
+    if (surface->Data.Y != 0 && surface->Data.MemId == 0){
+        return MFX_ERR_NONE;
+    }
+    // not locked
+    if (surface->Data.Y == 0){
+        return MFX_ERR_NONE;
+    }
+    sts = alloc->Unlock(alloc->pthis,surface->Data.MemId,&surface->Data);
+    return sts;
+}
+
+
+int process_filter(qsv_filter_task_t* task, void* params){
+    mfxStatus sts = MFX_ERR_NONE;
+
+    if (MFX_ERR_NONE != (sts = lock_frame(task->processor.alloc,task->in)))return sts;
+    if (MFX_ERR_NONE != (sts = lock_frame(task->processor.alloc,task->out)))
+    {
+        unlock_frame(task->processor.alloc,task->in);
+        return sts;
+    }
+
+    qsv_nv12_to_yuv420(task->pv->sws_context_from_nv12,task->pv->pre.out, task->in, task->processor.core);
+
+    // signal: input is prepared, converted from pipeline into internal buffer
+    hb_lock(task->pv->pre.frame_completed_lock);
+    task->pv->pre.frame_go = 1;
+    hb_cond_broadcast(task->pv->pre.frame_completed);
+    hb_unlock(task->pv->pre.frame_completed_lock);
+
+    // wait: input is prepared, converted from pipeline into internal buffer
+    hb_lock(task->pv->post.frame_completed_lock);
+    while(!task->pv->post.frame_go){
+        hb_cond_timedwait(task->pv->post.frame_completed,task->pv->post.frame_completed_lock,1000);
+        if(*task->pv->job->die)
+            break;
+    }
+    task->pv->post.frame_go = 0;
+    hb_unlock(task->pv->post.frame_completed_lock);
+
+// this is just a simple fun/test case
+#if 0
+    {
+        int i = 0;
+        char *cur_line;
+        char* luma =  task->pv->post.in->plane[0].data;
+        int pitch =  task->pv->post.in->plane[0].stride;
+        int h = task->pv->post.in->plane[0].height;
+        int w = task->pv->post.in->plane[0].width;
+        for (i = 0; i < h; i++){
+
+            cur_line = luma + i * pitch;
+            if(i>h/4 && i < 3*h/4 && i % 5 == 0 )
+                memset(cur_line, 0 , w );
+        }
+    }
+#endif
+
+    if(task->pv->post.in)
+    {
+    qsv_yuv420_to_nv12(task->pv->sws_context_to_nv12, task->out, task->pv->post.in);
+    }
+
+    // signal: output is prepared, converted from internal buffer into pipeline
+    hb_lock(task->pv->post_busy.frame_completed_lock);
+    task->pv->post_busy.frame_go = 1;
+    hb_cond_broadcast(task->pv->post_busy.frame_completed);
+    hb_unlock(task->pv->post_busy.frame_completed_lock);
+
+    unlock_frame(task->processor.alloc,task->in);
+    unlock_frame(task->processor.alloc,task->out);
+
+    return sts;
+}
diff --git a/libhb/qsv_filter_pp.h b/libhb/qsv_filter_pp.h
new file mode 100644
index 000000000..e70370321
--- /dev/null
+++ b/libhb/qsv_filter_pp.h
@@ -0,0 +1,114 @@
+/* ********************************************************************* *\
+
+Copyright (C) 2013 Intel Corporation.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+- Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+- Neither the name of Intel Corporation nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL INTEL CORPORATION BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+\* ********************************************************************* */
+
+#ifndef QSV_FILTER_PP_H
+#define QSV_FILTER_PP_H
+
+#include "msdk/mfxplugin.h"
+
+extern hb_buffer_t *link_buf_list( hb_filter_private_t *pv );
+
+struct qsv_filter_task_s;
+
+typedef struct{
+        mfxFrameAllocator *alloc;
+        mfxStatus             (*process)(struct qsv_filter_task_s*,void*);
+        mfxCoreInterface    *core;
+}qsv_filter_processor_t;
+
+typedef  struct qsv_filter_task_s{
+        mfxFrameSurface1 *in;
+        mfxFrameSurface1 *out;
+        int              busy;
+        hb_filter_private_t *pv;
+        qsv_filter_processor_t processor;
+} qsv_filter_task_t;
+
+typedef struct qsv_filter_private_s{
+
+        int                 is_init_done;
+
+        mfxCoreInterface    *core;
+        mfxVideoParam       *videoparam;
+        mfxPluginParam      pluginparam;
+
+        hb_filter_private_t *pv;
+
+        mfxPlugin           plug;
+        hb_list_t           *tasks;
+} qsv_filter_t;
+
+typedef struct hb_qsv_sync_s{
+    int                 frame_go;
+    int                 status;
+    hb_cond_t           *frame_completed;
+    hb_lock_t           *frame_completed_lock;
+
+    hb_buffer_t         *in;
+    hb_buffer_t         *out;
+} hb_qsv_sync_t;
+
+typedef struct hb_filter_private_s
+{
+    hb_job_t            *job;
+    hb_list_t           *list;
+
+    hb_qsv_sync_t       pre;
+    hb_qsv_sync_t       pre_busy;
+
+    hb_qsv_sync_t       post;
+    hb_qsv_sync_t       post_busy;
+
+    av_qsv_space        *vpp_space;
+    hb_list_t           *qsv_user;
+
+    struct SwsContext* sws_context_to_nv12;
+    struct SwsContext* sws_context_from_nv12;
+} hb_filter_private_t_qsv;
+
+// methods to be called by Media SDK
+mfxStatus MFX_CDECL qsv_PluginInit(mfxHDL pthis, mfxCoreInterface *core);
+mfxStatus MFX_CDECL qsv_PluginClose (mfxHDL pthis);
+mfxStatus MFX_CDECL qsv_GetPluginParam(mfxHDL pthis, mfxPluginParam *par);
+mfxStatus MFX_CDECL qsv_Submit(mfxHDL pthis, const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxThreadTask *task);
+mfxStatus MFX_CDECL qsv_Execute(mfxHDL pthis, mfxThreadTask task, mfxU32 uid_p, mfxU32 uid_a);
+mfxStatus MFX_CDECL qsv_FreeResources(mfxHDL pthis, mfxThreadTask task, mfxStatus sts);
+
+// methods to be called by us
+mfxStatus plugin_init(qsv_filter_t*,mfxVideoParam*);
+mfxStatus plugin_close(qsv_filter_t*);
+
+//internal functions
+mfxExtBuffer* get_ext_buffer(mfxExtBuffer**, mfxU32, mfxU32);
+int get_free_task(hb_list_t*);
+mfxStatus           process_filter(qsv_filter_task_t*,void*);
+mfxStatus lock_frame(mfxFrameAllocator *,mfxFrameSurface1*);
+mfxStatus unlock_frame(mfxFrameAllocator *,mfxFrameSurface1*);
+
+
+#endif //QSV_FILTER_PP_H
diff --git a/libhb/qsv_memory.c b/libhb/qsv_memory.c
new file mode 100644
index 000000000..f04c77a76
--- /dev/null
+++ b/libhb/qsv_memory.c
@@ -0,0 +1,120 @@
+/* ********************************************************************* *\
+
+Copyright (C) 2013 Intel Corporation.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+- Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+- Neither the name of Intel Corporation nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL INTEL CORPORATION BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+\* ********************************************************************* */
+
+#include "hb.h"
+#include "hbffmpeg.h"
+#include "qsv_memory.h"
+
+int qsv_nv12_to_yuv420(struct SwsContext* sws_context,hb_buffer_t* dst, mfxFrameSurface1* src, mfxCoreInterface *core){
+    int ret = 0;
+    int i,j;
+
+    int in_pitch        = src->Data.Pitch;
+    int w               = AV_QSV_ALIGN16(src->Info.Width);
+    int h               = (MFX_PICSTRUCT_PROGRESSIVE == src->Info.PicStruct) ? AV_QSV_ALIGN16(src->Info.Height) : AV_QSV_ALIGN32(src->Info.Height);
+    uint8_t *in_luma    = 0;
+    uint8_t *in_chroma  = 0;
+    static int copyframe_in_use = 1;
+
+
+    mfxStatus sts = MFX_ERR_NONE;
+    mfxFrameSurface1 accel_dst;
+
+    if (copyframe_in_use)
+    {
+        accel_dst.Info.FourCC   = src->Info.FourCC;
+        accel_dst.Info.CropH    = src->Info.CropH;
+        accel_dst.Info.CropW    = src->Info.CropW;
+        accel_dst.Info.CropY    = src->Info.CropY;
+        accel_dst.Info.CropX    = src->Info.CropX;
+        accel_dst.Info.Width    = w;
+        accel_dst.Info.Height   = h;
+        accel_dst.Data.Pitch    = src->Data.Pitch;
+        accel_dst.Data.Y        = calloc( 1, in_pitch*h );
+        accel_dst.Data.VU       = calloc( 1, in_pitch*h/2 );
+
+        sts = core->CopyFrame(core->pthis, &accel_dst, src);
+
+        if (sts < MFX_ERR_NONE)
+        {
+            free(accel_dst.Data.Y);
+            free(accel_dst.Data.VU);
+            copyframe_in_use = 0;
+        }
+        else
+        {
+            in_luma   = accel_dst.Data.Y  + accel_dst.Info.CropY * in_pitch     + accel_dst.Info.CropX;
+            in_chroma = accel_dst.Data.VU + accel_dst.Info.CropY / 2 * in_pitch + accel_dst.Info.CropX;
+        }
+    }
+
+    if (!copyframe_in_use)
+    {
+        in_luma   = src->Data.Y  + src->Info.CropY * in_pitch     + src->Info.CropX;
+        in_chroma = src->Data.VU + src->Info.CropY / 2 * in_pitch + src->Info.CropX;
+    }
+
+    hb_video_buffer_realloc( dst, w, h );
+
+    uint8_t *srcs[]   = { in_luma, in_chroma };
+    int srcs_stride[] = { in_pitch, in_pitch };
+
+    uint8_t *dsts[]   = { dst->plane[0].data, dst->plane[1].data, dst->plane[2].data };
+    int dsts_stride[] = { dst->plane[0].stride, dst->plane[1].stride, dst->plane[2].stride };
+
+    ret = sws_scale(sws_context, srcs, srcs_stride, 0, h, dsts, dsts_stride );
+
+    if (copyframe_in_use)
+    {
+        free(accel_dst.Data.Y);
+        free(accel_dst.Data.VU);
+    }
+
+    return ret;
+}
+
+int qsv_yuv420_to_nv12(struct SwsContext* sws_context,mfxFrameSurface1* dst, hb_buffer_t* src){
+    int ret = 0;
+
+    int w = src->plane[0].width;
+    int h = src->plane[0].height;
+
+    int out_pitch       = dst->Data.Pitch;
+    uint8_t *out_luma   = dst->Data.Y;
+    uint8_t *out_chroma = dst->Data.VU;
+
+    uint8_t *srcs[]     = { src->plane[0].data, src->plane[1].data, src->plane[2].data };
+    int srcs_stride[]   = { src->plane[0].stride, src->plane[1].stride, src->plane[2].stride };
+
+    uint8_t *dsts[]     = { out_luma, out_chroma };
+    int dsts_stride[]   = { out_pitch, out_pitch };
+
+    ret = sws_scale(sws_context, srcs, srcs_stride, 0, h, dsts, dsts_stride );
+
+    return ret;
+}
diff --git a/libhb/qsv_memory.h b/libhb/qsv_memory.h
new file mode 100644
index 000000000..2d0f51208
--- /dev/null
+++ b/libhb/qsv_memory.h
@@ -0,0 +1,55 @@
+/* ********************************************************************* *\
+
+Copyright (C) 2013 Intel Corporation.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+- Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+- Neither the name of Intel Corporation nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL INTEL CORPORATION BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+\* ********************************************************************* */
+
+#ifndef QSV_MEMORY_H
+#define QSV_MEMORY_H
+
+#include "libavcodec/qsv.h"
+#include "msdk/mfxplugin.h"
+
+typedef struct{
+
+    struct{
+        // for "planes" , Y and VU
+        uint8_t     *data[2];
+        int         strides[2];
+    }               qsv_data;
+
+    struct{
+        // for each plane, Y U V
+        uint8_t     *data[3];
+        int         strides[3];
+    }               data;
+    int             width;
+    int             height;
+} qsv_memory_copy_t;
+
+int qsv_nv12_to_yuv420(struct SwsContext* sws_context,hb_buffer_t* dst, mfxFrameSurface1* src,mfxCoreInterface *core);
+int qsv_yuv420_to_nv12(struct SwsContext* sws_context,mfxFrameSurface1* dst, hb_buffer_t* src);
+
+#endif // QSV_MEMORY_H