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

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

1 files changed, 2285 insertions, 0 deletions

diff --git a/contrib/ffmpeg/A00-qsv.patch b/contrib/ffmpeg/A00-qsv.patch
new file mode 100644
index 000000000..908033617
--- /dev/null
+++ b/contrib/ffmpeg/A00-qsv.patch
@@ -0,0 +1,2285 @@
+diff -Naur ../../libav-v9.6/configure ./configure
+--- ../../libav-v9.6/configure	2013-05-12 08:39:07.000000000 +0200
++++ ./configure	2013-08-14 10:48:00.520497159 +0200
+@@ -133,6 +133,7 @@
+   --enable-vaapi           enable VAAPI code
+   --enable-vda             enable VDA code
+   --enable-vdpau           enable VDPAU code
++  --enable-qsv             enable QSV code
+ 
+ Individual component options:
+   --disable-everything     disable all components listed below
+@@ -1076,6 +1077,7 @@
+     vaapi
+     vda
+     vdpau
++    qsv
+     version3
+     xmm_clobber_test
+     x11grab
+@@ -1629,6 +1631,7 @@
+ wmv3_dxva2_hwaccel_select="vc1_dxva2_hwaccel"
+ wmv3_vaapi_hwaccel_select="vc1_vaapi_hwaccel"
+ wmv3_vdpau_decoder_select="vc1_vdpau_decoder"
++h264_qsv_decoder_select="qsv h264_decoder"
+ 
+ # parsers
+ h264_parser_select="error_resilience golomb h264dsp h264pred mpegvideo"
+@@ -3584,6 +3587,12 @@
+     check_cpp_condition vdpau/vdpau.h "defined VDP_DECODER_PROFILE_MPEG4_PART2_ASP" ||
+         { echolog "Please upgrade to libvdpau >= 0.2 if you would like vdpau support." && disable vdpau; }
+ fi
++if enabled qsv; then
++    disable qsv
++    check_header msdk/mfxvideo.h && enable qsv 
++else
++    disable qsv
++fi
+ 
+ enabled debug && add_cflags -g"$debuglevel" && add_asflags -g"$debuglevel"
+ 
+@@ -3795,6 +3804,7 @@
+ echo "libdxva2 enabled          ${dxva2-no}"
+ echo "libva enabled             ${vaapi-no}"
+ echo "libvdpau enabled          ${vdpau-no}"
++echo "libqsv enabled            ${qsv-no}"
+ echo "AVISynth enabled          ${avisynth-no}"
+ echo "frei0r enabled            ${frei0r-no}"
+ echo "gnutls enabled            ${gnutls-no}"
+diff -Naur ../../libav-v9.6/libavcodec/allcodecs.c ./libavcodec/allcodecs.c
+--- ../../libav-v9.6/libavcodec/allcodecs.c	2013-05-12 08:39:07.000000000 +0200
++++ ./libavcodec/allcodecs.c	2013-08-14 10:48:00.520497159 +0200
+@@ -143,6 +143,7 @@
+     REGISTER_DECODER(H263I,             h263i);
+     REGISTER_ENCODER(H263P,             h263p);
+     REGISTER_DECODER(H264,              h264);
++    REGISTER_DECODER(H264_QSV, 		h264_qsv);
+     REGISTER_DECODER(H264_VDPAU,        h264_vdpau);
+     REGISTER_ENCDEC (HUFFYUV,           huffyuv);
+     REGISTER_DECODER(IDCIN,             idcin);
+diff -Naur ../../libav-v9.6/libavcodec/Makefile ./libavcodec/Makefile
+--- ../../libav-v9.6/libavcodec/Makefile	2013-05-12 08:39:07.000000000 +0200
++++ ./libavcodec/Makefile	2013-08-14 10:48:00.521497282 +0200
+@@ -10,6 +10,7 @@
+           vdpau.h                                                       \
+           version.h                                                     \
+           xvmc.h                                                        \
++	  qsv.h								\
+ 
+ OBJS = allcodecs.o                                                      \
+        audioconvert.o                                                   \
+@@ -196,6 +197,7 @@
+                                           h264_loopfilter.o h264_direct.o      \
+                                           cabac.o h264_sei.o h264_ps.o         \
+                                           h264_refs.o h264_cavlc.o h264_cabac.o
++OBJS-$(CONFIG_H264_QSV_DECODER)        += qsv_h264.o qsv.o
+ OBJS-$(CONFIG_H264_DXVA2_HWACCEL)      += dxva2_h264.o
+ OBJS-$(CONFIG_H264_VAAPI_HWACCEL)      += vaapi_h264.o
+ OBJS-$(CONFIG_H264_VDA_HWACCEL)        += vda_h264.o
+diff -Naur ../../libav-v9.6/libavcodec/qsv.c ./libavcodec/qsv.c
+--- ../../libav-v9.6/libavcodec/qsv.c	1970-01-01 01:00:00.000000000 +0100
++++ ./libavcodec/qsv.c	2013-08-19 21:32:01.704244071 +0200
+@@ -0,0 +1,646 @@
++/* ********************************************************************* *\
++
++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 "qsv.h"
++
++#include "avcodec.h"
++#include "internal.h"
++
++int av_qsv_get_free_encode_task(av_qsv_list * tasks)
++{
++    int ret = MFX_ERR_NOT_FOUND;
++    int i = 0;
++    if (tasks)
++        for (i = 0; i < av_qsv_list_count(tasks); i++) {
++            av_qsv_task *task = av_qsv_list_item(tasks, i);
++            if (task->stage && task->stage->out.sync)
++                if (!(*task->stage->out.sync->p_sync)) {
++                    ret = i;
++                    break;
++                }
++        }
++    return ret;
++}
++
++int av_qsv_get_free_sync(av_qsv_space * space, av_qsv_context * qsv)
++{
++    int ret = -1;
++    int counter = 0;
++
++    while (1) {
++        for (int i = 0; i < space->sync_num; i++) {
++            if (!(*(space->p_syncp[i]->p_sync)) &&
++                0 == space->p_syncp[i]->in_use ) {
++                if (i > space->sync_num_max_used)
++                    space->sync_num_max_used = i;
++                ff_qsv_atomic_inc(&space->p_syncp[i]->in_use);
++                return i;
++            }
++        }
++#if HAVE_THREADS
++        if (++counter >= AV_QSV_REPEAT_NUM_DEFAULT) {
++#endif
++            av_log(NULL, AV_LOG_FATAL, "not enough to have %d sync point(s) allocated\n",
++                   space->sync_num);
++            break;
++#if HAVE_THREADS
++        }
++        av_qsv_sleep(5);
++#endif
++    }
++    return ret;
++}
++
++int av_qsv_get_free_surface(av_qsv_space * space, av_qsv_context * qsv,
++                     mfxFrameInfo * info, av_qsv_split part)
++{
++    int ret = -1;
++    int from = 0;
++    int up = space->surface_num;
++    int counter = 0;
++
++    while (1) {
++        from = 0;
++        up = space->surface_num;
++        if (part == QSV_PART_LOWER)
++            up /= 2;
++        if (part == QSV_PART_UPPER)
++            from = up / 2;
++
++        for (int i = from; i < up; i++) {
++            if (0 == space->p_surfaces[i]->Data.Locked) {
++                memcpy(&(space->p_surfaces[i]->Info), info,
++                       sizeof(mfxFrameInfo));
++                if (i > space->surface_num_max_used)
++                    space->surface_num_max_used = i;
++                return i;
++            }
++        }
++#if HAVE_THREADS
++        if (++counter >= AV_QSV_REPEAT_NUM_DEFAULT) {
++#endif
++            av_log(NULL, AV_LOG_FATAL,
++                   "not enough to have %d surface(s) allocated\n", up);
++            break;
++#if HAVE_THREADS
++        }
++        av_qsv_sleep(5);
++#endif
++    }
++    return ret;
++}
++
++int ff_qsv_is_surface_in_pipe(mfxFrameSurface1 * p_surface, av_qsv_context * qsv)
++{
++    int ret = 0;
++    int a, b,i;
++    av_qsv_list *list = 0;
++    av_qsv_stage *stage = 0;
++
++    if (!p_surface)
++        return ret;
++    if (!qsv->pipes)
++        return ret;
++
++    for (a = 0; a < av_qsv_list_count(qsv->pipes); a++) {
++        list = av_qsv_list_item(qsv->pipes, a);
++        for (b = 0; b < av_qsv_list_count(list); b++) {
++            stage = av_qsv_list_item(list, b);
++            if (p_surface == stage->out.p_surface)
++                return (stage->type << 16) | 2;
++            if (p_surface == stage->in.p_surface)
++                return (stage->type << 16) | 1;
++        }
++    }
++    return ret;
++}
++
++int ff_qsv_is_sync_in_pipe(mfxSyncPoint * sync, av_qsv_context * qsv)
++{
++    int ret = 0;
++    int a, b;
++    av_qsv_list *list = 0;
++    av_qsv_stage *stage = 0;
++
++    if (!sync)
++        return ret;
++    if (!qsv->pipes)
++        return ret;
++
++    for (a = 0; a < av_qsv_list_count(qsv->pipes); a++) {
++        list = av_qsv_list_item(qsv->pipes, a);
++        for (b = 0; b < av_qsv_list_count(list); b++) {
++            stage = av_qsv_list_item(list, b);
++            if (sync == stage->out.sync->p_sync) {
++                return 1;
++            }
++        }
++    }
++    return ret;
++}
++
++av_qsv_stage *av_qsv_stage_init(void)
++{
++    av_qsv_stage *stage = av_mallocz(sizeof(av_qsv_stage));
++    return stage;
++}
++
++void av_qsv_stage_clean(av_qsv_stage ** stage)
++{
++    if ((*stage)->out.sync) {
++        if ((*stage)->out.sync->p_sync)
++            *(*stage)->out.sync->p_sync = 0;
++        if ((*stage)->out.sync->in_use > 0)
++            ff_qsv_atomic_dec(&(*stage)->out.sync->in_use);
++        (*stage)->out.sync = 0;
++    }
++    if ((*stage)->out.p_surface) {
++        (*stage)->out.p_surface = 0;
++
++    }
++    if ((*stage)->in.p_surface) {
++        (*stage)->in.p_surface = 0;
++    }
++
++    av_freep(stage);
++}
++
++void av_qsv_add_context_usage(av_qsv_context * qsv, int is_threaded)
++{
++    int is_active = 0;
++#if HAVE_THREADS
++    int mut_ret = 0;
++#endif
++
++    is_active = ff_qsv_atomic_inc(&qsv->is_context_active);
++    if (is_active == 1) {
++        memset(&qsv->mfx_session, 0, sizeof(mfxSession));
++        av_qsv_pipe_list_create(&qsv->pipes, is_threaded);
++
++        qsv->dts_seq = av_qsv_list_init(is_threaded);
++
++#if HAVE_THREADS
++        if (is_threaded) {
++            qsv->qts_seq_mutex = av_mallocz(sizeof(pthread_mutex_t));
++            if (qsv->qts_seq_mutex){
++                mut_ret = pthread_mutex_init(qsv->qts_seq_mutex, NULL);
++                if(mut_ret)
++                    av_log(NULL, AV_LOG_ERROR, "pthread_mutex_init issue[%d] at %s\n",mut_ret,__FUNCTION__);
++            }
++
++        } else
++#endif
++            qsv->qts_seq_mutex = 0;
++    }
++}
++
++int av_qsv_context_clean(av_qsv_context * qsv)
++{
++    int is_active = 0;
++    mfxStatus sts = MFX_ERR_NONE;
++#if HAVE_THREADS
++    int mut_ret = 0;
++#endif
++
++    is_active = ff_qsv_atomic_dec(&qsv->is_context_active);
++
++    // spaces would have to be cleaned on the own,
++    // here we care about the rest, common stuff
++    if (is_active == 0) {
++
++        if (qsv->dts_seq) {
++            while (av_qsv_list_count(qsv->dts_seq))
++                av_qsv_dts_pop(qsv);
++
++            av_qsv_list_close(&qsv->dts_seq);
++        }
++#if HAVE_THREADS
++        if (qsv->qts_seq_mutex) {
++            mut_ret = pthread_mutex_destroy(qsv->qts_seq_mutex);
++            if(mut_ret)
++                av_log(NULL, AV_LOG_ERROR, "pthread_mutex_destroy issue[%d] at %s\n", mut_ret,__FUNCTION__);
++#endif
++            qsv->qts_seq_mutex = 0;
++#if HAVE_THREADS
++        }
++#endif
++
++        if (qsv->pipes)
++            av_qsv_pipe_list_clean(&qsv->pipes);
++
++        if (qsv->mfx_session) {
++            sts = MFXClose(qsv->mfx_session);
++            AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
++            qsv->mfx_session = 0;
++        }
++    }
++    return 0;
++}
++
++void av_qsv_pipe_list_create(av_qsv_list ** list, int is_threaded)
++{
++    if (!*list)
++        *list = av_qsv_list_init(is_threaded);
++}
++
++void av_qsv_pipe_list_clean(av_qsv_list ** list)
++{
++    av_qsv_list *stage;
++    int i = 0;
++    if (*list) {
++        for (i = av_qsv_list_count(*list); i > 0; i--) {
++            stage = av_qsv_list_item(*list, i - 1);
++            av_qsv_flush_stages(*list, &stage);
++        }
++        av_qsv_list_close(list);
++    }
++}
++
++void av_qsv_add_stagee(av_qsv_list ** list, av_qsv_stage * stage, int is_threaded)
++{
++    if (!*list)
++        *list = av_qsv_list_init(is_threaded);
++    av_qsv_list_add(*list, stage);
++}
++
++av_qsv_stage *av_qsv_get_last_stage(av_qsv_list * list)
++{
++    av_qsv_stage *stage = 0;
++    int size = 0;
++
++    av_qsv_list_lock(list);
++    size = av_qsv_list_count(list);
++    if (size > 0)
++        stage = av_qsv_list_item(list, size - 1);
++    av_qsv_list_unlock(list);
++
++    return stage;
++}
++
++void av_qsv_flush_stages(av_qsv_list * list, av_qsv_list ** item)
++{
++    int i = 0;
++    int x = 0;
++    av_qsv_stage *stage = 0;
++    av_qsv_list *to_remove_list = 0;
++    av_qsv_list *to_remove_atom_list = 0;
++    av_qsv_list *to_remove_atom = 0;
++
++    for (i = 0; i < av_qsv_list_count(*item); i++) {
++        stage = av_qsv_list_item(*item, i);
++        if(stage->pending){
++            if(!to_remove_list)
++                to_remove_list = av_qsv_list_init(0);
++            av_qsv_list_add(to_remove_list, stage->pending);
++        }
++        av_qsv_stage_clean(&stage);
++        // should actually remove from the list but ok...
++    }
++    av_qsv_list_rem(list, *item);
++    av_qsv_list_close(item);
++
++    if(to_remove_list){
++        for (i = av_qsv_list_count(to_remove_list); i > 0; i--){
++            to_remove_atom_list = av_qsv_list_item(to_remove_list, i-1);
++            for (x = av_qsv_list_count(to_remove_atom_list); x > 0; x--){
++                to_remove_atom = av_qsv_list_item(to_remove_atom_list, x-1);
++                av_qsv_flush_stages(list,&to_remove_atom);
++            }
++        }
++        av_qsv_list_close(&to_remove_list);
++    }
++}
++
++av_qsv_list *av_qsv_pipe_by_stage(av_qsv_list * list, av_qsv_stage * stage)
++{
++    av_qsv_list *item = 0;
++    av_qsv_stage *cur_stage = 0;
++    int i = 0;
++    int a = 0;
++    for (i = 0; i < av_qsv_list_count(list); i++) {
++        item = av_qsv_list_item(list, i);
++        for (a = 0; a < av_qsv_list_count(item); a++) {
++            cur_stage = av_qsv_list_item(item, a);
++            if (cur_stage == stage)
++                return item;
++        }
++    }
++    return 0;
++}
++
++// no duplicate of the same value, if end == 0 : working over full length
++void av_qsv_dts_ordered_insert(av_qsv_context * qsv, int start, int end,
++                            int64_t dts, int iter)
++{
++    av_qsv_dts *cur_dts = 0;
++    av_qsv_dts *new_dts = 0;
++    int i = 0;
++#if HAVE_THREADS
++    int mut_ret = 0;
++#endif
++
++
++#if HAVE_THREADS
++    if (iter == 0 && qsv->qts_seq_mutex){
++        mut_ret = pthread_mutex_lock(qsv->qts_seq_mutex);
++        if(mut_ret)
++            av_log(NULL, AV_LOG_ERROR, "pthread_mutex_lock issue[%d] at %s\n",mut_ret, __FUNCTION__);
++    }
++#endif
++
++    if (end == 0)
++        end = av_qsv_list_count(qsv->dts_seq);
++
++    if (end <= start) {
++        new_dts = av_mallocz(sizeof(av_qsv_dts));
++        if( new_dts ) {
++            new_dts->dts = dts;
++            av_qsv_list_add(qsv->dts_seq, new_dts);
++        }
++    } else
++        for (i = end; i > start; i--) {
++            cur_dts = av_qsv_list_item(qsv->dts_seq, i - 1);
++            if (cur_dts->dts < dts) {
++                new_dts = av_mallocz(sizeof(av_qsv_dts));
++                if( new_dts ) {
++                    new_dts->dts = dts;
++                    av_qsv_list_insert(qsv->dts_seq, i, new_dts);
++                }
++                break;
++            } else if (cur_dts->dts == dts)
++                break;
++        }
++#if HAVE_THREADS
++    if (iter == 0 && qsv->qts_seq_mutex){
++        mut_ret = pthread_mutex_unlock(qsv->qts_seq_mutex);
++        if(mut_ret)
++            av_log(NULL, AV_LOG_ERROR, "pthread_mutex_unlock issue[%d] at %s\n",mut_ret, __FUNCTION__);
++    }
++#endif
++}
++
++void av_qsv_dts_pop(av_qsv_context * qsv)
++{
++    av_qsv_dts *item = 0;
++#if HAVE_THREADS
++    int mut_ret = 0;
++#endif
++
++#if HAVE_THREADS
++    if (qsv && qsv->qts_seq_mutex){
++        mut_ret = pthread_mutex_lock(qsv->qts_seq_mutex);
++        if(mut_ret)
++            av_log(NULL, AV_LOG_ERROR, "pthread_mutex_lock issue[%d] at %s\n",mut_ret, __FUNCTION__);
++    }
++#endif
++
++    if (av_qsv_list_count(qsv->dts_seq)) {
++        item = av_qsv_list_item(qsv->dts_seq, 0);
++        av_qsv_list_rem(qsv->dts_seq, item);
++        av_free(item);
++    }
++#if HAVE_THREADS
++    if (qsv && qsv->qts_seq_mutex){
++        mut_ret = pthread_mutex_unlock(qsv->qts_seq_mutex);
++        if(mut_ret)
++            av_log(NULL, AV_LOG_ERROR, "pthread_mutex_lock issue[%d] at %s\n",mut_ret, __FUNCTION__);
++        }
++#endif
++}
++
++
++av_qsv_list *av_qsv_list_init(int is_threaded)
++{
++    av_qsv_list *l;
++#if HAVE_THREADS
++    int mut_ret;
++#endif
++
++    l = av_mallocz(sizeof(av_qsv_list));
++    if (!l)
++        return 0;
++    l->items = av_mallocz(AV_QSV_JOB_SIZE_DEFAULT * sizeof(void *));
++    if (!l->items)
++        return 0;
++    l->items_alloc = AV_QSV_JOB_SIZE_DEFAULT;
++
++#if HAVE_THREADS
++    if (is_threaded) {
++        l->mutex = av_mallocz(sizeof(pthread_mutex_t));
++        if (l->mutex){
++            mut_ret = pthread_mutexattr_init(&l->mta);
++            if( mut_ret )
++                av_log(NULL, AV_LOG_ERROR, "pthread_mutexattr_init issue[%d] at %s\n",mut_ret, __FUNCTION__);
++            mut_ret = pthread_mutexattr_settype(&l->mta, PTHREAD_MUTEX_RECURSIVE /*PTHREAD_MUTEX_ERRORCHECK*/);
++            if( mut_ret )
++                av_log(NULL, AV_LOG_ERROR, "pthread_mutexattr_settype issue[%d] at %s\n",mut_ret, __FUNCTION__);
++            mut_ret = pthread_mutex_init(l->mutex, &l->mta);
++            if( mut_ret )
++                av_log(NULL, AV_LOG_ERROR, "pthread_mutex_init issue[%d] at %s\n",mut_ret, __FUNCTION__);
++        }
++    } else
++#endif
++        l->mutex = 0;
++    return l;
++}
++
++int av_qsv_list_count(av_qsv_list * l)
++{
++    int count;
++
++    av_qsv_list_lock(l);
++    count = l->items_count;
++    av_qsv_list_unlock(l);
++    return count;
++}
++
++int av_qsv_list_add(av_qsv_list * l, void *p)
++{
++    int pos = -1;
++
++    if (!p) {
++        return pos;
++    }
++
++    av_qsv_list_lock(l);
++
++    if (l->items_count == l->items_alloc) {
++        /* We need a bigger boat */
++        l->items_alloc += AV_QSV_JOB_SIZE_DEFAULT;
++        l->items = av_realloc(l->items, l->items_alloc * sizeof(void *));
++    }
++
++    l->items[l->items_count] = p;
++    pos = (l->items_count);
++    l->items_count++;
++
++    av_qsv_list_unlock(l);
++
++    return pos;
++}
++
++void av_qsv_list_rem(av_qsv_list * l, void *p)
++{
++    int i;
++
++    av_qsv_list_lock(l);
++
++    /* Find the item in the list */
++    for (i = 0; i < l->items_count; i++) {
++        if (l->items[i] == p) {
++            /* Shift all items after it sizeof( void * ) bytes earlier */
++            memmove(&l->items[i], &l->items[i + 1],
++                    (l->items_count - i - 1) * sizeof(void *));
++
++            l->items_count--;
++            break;
++        }
++    }
++
++    av_qsv_list_unlock(l);
++}
++
++void *av_qsv_list_item(av_qsv_list * l, int i)
++{
++    void *ret = NULL;
++
++    if (i < 0)
++        return NULL;
++
++    av_qsv_list_lock(l);
++    if( i < l->items_count)
++        ret = l->items[i];
++    av_qsv_list_unlock(l);
++    return ret;
++}
++
++void av_qsv_list_insert(av_qsv_list * l, int pos, void *p)
++{
++
++    if (!p)
++        return;
++
++    av_qsv_list_lock(l);
++
++    if (l->items_count == l->items_alloc) {
++        l->items_alloc += AV_QSV_JOB_SIZE_DEFAULT;
++        l->items = av_realloc(l->items, l->items_alloc * sizeof(void *));
++    }
++
++    if (l->items_count != pos) {
++        memmove(&l->items[pos + 1], &l->items[pos],
++                (l->items_count - pos) * sizeof(void *));
++    }
++
++    l->items[pos] = p;
++    l->items_count--;
++
++    av_qsv_list_unlock(l);
++}
++
++void av_qsv_list_close(av_qsv_list ** _l)
++{
++    av_qsv_list *l = *_l;
++#if HAVE_THREADS
++    int mut_ret;
++#endif
++
++    av_qsv_list_lock(l);
++
++    av_free(l->items);
++
++#if HAVE_THREADS
++    if (l->mutex){
++        mut_ret = pthread_mutex_unlock(l->mutex);
++        if( mut_ret )
++            av_log(NULL, AV_LOG_ERROR, "pthread_mutex_unlock issue[%d] at %s\n",mut_ret, __FUNCTION__);
++        mut_ret = pthread_mutex_destroy(&l->mutex);
++        mut_ret = pthread_mutexattr_destroy(&l->mta);
++    }
++#endif
++    av_freep(_l);
++}
++
++int av_qsv_list_lock(av_qsv_list *l){
++    int ret = 0;
++#if HAVE_THREADS
++    if (l->mutex){
++        ret = pthread_mutex_lock(l->mutex);
++        if( ret )
++            av_log(NULL, AV_LOG_ERROR, "pthread_mutex_lock issue[%d] at %s\n",ret, __FUNCTION__);
++    }
++#endif
++    return ret;
++}
++
++int av_qsv_list_unlock(av_qsv_list *l){
++    int ret = 0;
++#if HAVE_THREADS
++    if (l->mutex){
++        ret = pthread_mutex_unlock(l->mutex);
++        if( ret )
++            av_log(NULL, AV_LOG_ERROR, "pthread_mutex_unlock issue[%d] at %s\n",ret, __FUNCTION__);
++    }
++#endif
++    return ret;
++}
++
++int av_is_qsv_available(mfxIMPL impl, mfxVersion * ver)
++{
++    mfxStatus sts = MFX_ERR_NONE;
++    mfxSession mfx_session;
++
++    memset(&mfx_session, 0, sizeof(mfxSession));
++    sts = MFXInit(impl, ver, &mfx_session);
++    if (sts >= 0)
++        MFXClose(mfx_session);
++    return sts;
++}
++
++void av_qsv_wait_on_sync(av_qsv_context *qsv, av_qsv_stage *stage)
++{
++    int iter = 0;
++    mfxStatus sts = MFX_ERR_NONE;
++    if( stage )
++        if(*stage->out.sync->p_sync){
++            while(1){
++                iter++;
++                sts = MFXVideoCORE_SyncOperation(qsv->mfx_session,*stage->out.sync->p_sync, AV_QSV_SYNC_TIME_DEFAULT);
++                if(MFX_WRN_IN_EXECUTION == sts){
++
++                    if(iter>20)
++                        AV_QSV_DEBUG_ASSERT(1, "Sync failed");
++
++                    av_qsv_sleep(10);
++                    continue;
++                }
++                AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
++                break;
++            }
++        }
++}
+\ No newline at end of file
+diff -Naur ../../libav-v9.6/libavcodec/qsv.h ./libavcodec/qsv.h
+--- ../../libav-v9.6/libavcodec/qsv.h	1970-01-01 01:00:00.000000000 +0100
++++ ./libavcodec/qsv.h	2013-08-19 21:32:01.709244686 +0200
+@@ -0,0 +1,494 @@
++/* ********************************************************************* *\
++
++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 AVCODEC_QSV_H
++#define AVCODEC_QSV_H
++
++/**
++ * @file
++ * @ingroup lavc_codec_hwaccel_qsv
++ * Common header for QSV/MediaSDK acceleration
++ */
++
++/**
++ * @defgroup lavc_codec_hwaccel_qsv QSV/MediaSDK based Decode/Encode and VPP
++ * @ingroup lavc_codec_hwaccel
++ *
++ *  As Intel Quick Sync Video (QSV) can decode/preprocess/encode with HW
++ *  acceleration.
++ *
++ *  Supported features:
++ *    - access:
++ *      - format AV_PIX_FMT_QSV_H264, AVCodec decoder based implementation
++ *      - name "h264_qsv", avcodec_find_decoder_by_name( "h264_qsv")
++ *    - IO Pattern:
++ *      - Opaque memory: MFX_IOPATTERN_OUT_OPAQUE_MEMORY // Video memory is
++ *                       MFX_IMPL_HARDWARE or MFX_IMPL_AUTO and runtime support,
++ *                       otherwise: System Memory
++ *      - System memory: MFX_IOPATTERN_OUT_SYSTEM_MEMORY
++ *    - Allocators:
++ *      - default allocator for System memory: MFX_MEMTYPE_SYSTEM_MEMORY
++ *    - details:
++ *      implementation as "per frame"
++ *
++ *  TODO list:
++ *    - access:
++ *      - format AV_PIX_FMT_QSV_MPEG2
++ *      - format AV_PIX_FMT_QSV_VC1
++ *      - format AV_PIX_FMT_QSV, see "details" below
++ *    - IO Pattern:
++ *      - VIDEO_MEMORY  // MFX_IOPATTERN_OUT_VIDEO_MEMORY
++ *    - Allocators:
++ *      - Video memory: MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET /
++ *                      MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET
++ *    - details:
++ *      "per slice" support: AV_PIX_FMT_QSV with AVHWAccel based implementation
++ *
++ *  Note av_qsv_config struct required to fill in via
++ *  AVCodecContext.hwaccel_context
++ *
++ *  As per frame, note AVFrame.data[2] (qsv_atom) used for frame atom id,
++ *  data/linesize should be used together with SYSTEM_MEMORY and tested
++ *
++ *  Note: Compilation would require:
++ *   - Intel MediaSDK headers, Full SDK is avaialble from the original web site:
++ *                     http://software.intel.com/en-us/vcsource/tools/media-SDK
++ *     Will be referenced as msdk/*.h (mfxdefs.h, mfxstructures.h, ... )
++ *  and
++ *  - Final application has to link against Intel MediaSDK dispatcher, available
++ *     at MediaSDK as well
++ *
++ *  Target OS: as per available dispatcher and driver support
++ *
++ *  Implementation details:
++ *   Provided struct av_qsv_context contain several struct av_qsv_space(s) for decode,
++ *   VPP and encode.
++ *   av_qsv_space just contain needed environment for the appropriate action.
++ *   Based on this - pipeline (see pipes) will be build to pass details such as
++ *   mfxFrameSurface1* and mfxSyncPoint* from one action to the next.
++ *
++ *  Resources re-usage (av_qsv_flush_stages):
++ *     av_qsv_context *qsv = (av_qsv_context *)video_codec_ctx->priv_data;
++ *     av_qsv_list *pipe = (av_qsv_list *)video_frame->data[2];
++ *     av_qsv_flush_stages( qsv->pipes, &pipe );
++ *
++ *  DTS re-usage:
++ *     av_qsv_dts_pop(qsv);
++ *
++ *   for video,DX9/11 memory it has to be Unlock'ed as well
++ *
++ *  Implementation is thread aware and uses synchronization point(s) from MediaSDK
++ *  as per configuration.
++ *
++ *  For the details of MediaSDK usage and options available - please refer to the
++ *  available documentation at MediaSDK.
++ *
++ *  Feature set used from MSDK is defined by AV_QSV_MSDK_VERSION_MAJOR and
++ *  AV_QSV_MSDK_VERSION_MINOR
++ *
++ * @{
++ */
++
++#include <stdint.h>
++#include <string.h>
++#include "msdk/mfxvideo.h"
++#include "libavutil/mem.h"
++#include "libavutil/time.h"
++
++#ifdef HAVE_AV_CONFIG_H
++#include "config.h"
++#endif
++
++#if HAVE_THREADS
++#if defined (__GNUC__)
++#include <pthread.h>
++#define ff_qsv_atomic_inc(ptr) __sync_add_and_fetch(ptr,1)
++#define ff_qsv_atomic_dec(ptr) __sync_sub_and_fetch (ptr,1)
++#elif HAVE_WINDOWS_H            // MSVC case
++#include <windows.h>
++#if HAVE_PTHREADS
++#include <pthread.h>
++#elif HAVE_W32THREADS
++#include "w32pthreads.h"
++#endif
++#define ff_qsv_atomic_inc(ptr) InterlockedIncrement(ptr)
++#define ff_qsv_atomic_dec(ptr) InterlockedDecrement (ptr)
++#else
++// targeting only for MinGW or MSVC
++#endif
++
++#else
++#define ff_qsv_atomic_inc(ptr) ((*ptr)++)
++#define ff_qsv_atomic_dec(ptr) ((*ptr)--)
++#endif
++
++
++// sleep is defined in milliseconds
++#define av_qsv_sleep(x) av_usleep((x)*1000)
++
++#define AV_QSV_ZERO_MEMORY(VAR)                    {memset(&VAR, 0, sizeof(VAR));}
++#define AV_QSV_ALIGN32(X)                      (((mfxU32)((X)+31)) & (~ (mfxU32)31))
++#define AV_QSV_ALIGN16(value)                  (((value + 15) >> 4) << 4)
++#ifndef AV_QSV_PRINT_RET_MSG
++#define AV_QSV_PRINT_RET_MSG(ERR)              { av_log(NULL, AV_LOG_FATAL,"Error code %d,\t%s\t%d\n", ERR, __FUNCTION__, __LINE__); }
++#endif
++
++#ifndef AV_QSV_DEBUG_ASSERT
++#define AV_QSV_DEBUG_ASSERT(x,y)               {if ((x)) {av_log(NULL, AV_LOG_FATAL,"\nASSERT: %s\n",y);};}
++#endif
++
++#define AV_QSV_CHECK_RESULT(P, X, ERR)             {if ((X) > (P)) {AV_QSV_PRINT_RET_MSG(ERR); return ERR;}}
++#define AV_QSV_CHECK_POINTER(P, ERR)               {if (!(P)) {AV_QSV_PRINT_RET_MSG(ERR); return ERR;}}
++#define AV_QSV_IGNORE_MFX_STS(P, X)                {if ((X) == (P)) {P = MFX_ERR_NONE;}}
++
++#define AV_QSV_ID_BUFFER MFX_MAKEFOURCC('B','U','F','F')
++#define AV_QSV_ID_FRAME  MFX_MAKEFOURCC('F','R','M','E')
++
++#define AV_QSV_SURFACE_NUM              80
++#define AV_QSV_SYNC_NUM                 AV_QSV_SURFACE_NUM*3/4
++#define AV_QSV_BUF_SIZE_DEFAULT         4096*2160*10
++#define AV_QSV_JOB_SIZE_DEFAULT         10
++#define AV_QSV_SYNC_TIME_DEFAULT        10000
++// see av_qsv_get_free_sync, av_qsv_get_free_surface , 100 if usleep(10*1000)(10ms) == 1 sec
++#define AV_QSV_REPEAT_NUM_DEFAULT      100
++#define AV_QSV_ASYNC_DEPTH_DEFAULT     4
++
++// version of MSDK/QSV API currently used
++#define AV_QSV_MSDK_VERSION_MAJOR  1
++#define AV_QSV_MSDK_VERSION_MINOR  3
++
++typedef enum AV_QSV_STAGE_TYPE {
++
++#define AV_QSV_DECODE_MASK   0x001
++    AV_QSV_DECODE   = 0x001,
++
++#define AV_QSV_VPP_MASK      0x0F0
++    // "Mandatory VPP filter" , might be with "Hint-based VPP filters"
++    AV_QSV_VPP_DEFAULT = 0x010,
++    // "User Modules" etc
++    AV_QSV_VPP_USER = 0x020,
++
++#define av_QSV_ENCODE_MASK   0x100
++    AV_QSV_ENCODE   = 0x100
++#define AV_QSV_ANY_MASK      0xFFF
++} AV_QSV_STAGE_TYPE;
++
++
++typedef struct av_qsv_list {
++    // practically pthread_mutex_t
++    void *mutex;
++#if HAVE_THREADS
++    pthread_mutexattr_t   mta;
++#endif
++
++    void **items;
++    int items_alloc;
++
++    int items_count;
++} av_qsv_list;
++
++typedef struct av_qsv_sync {
++    mfxSyncPoint*   p_sync;
++    int             in_use;
++} av_qsv_sync;
++
++typedef struct av_qsv_stage {
++    AV_QSV_STAGE_TYPE type;
++    struct {
++        mfxBitstream *p_bs;
++        mfxFrameSurface1 *p_surface;
++    } in;
++    struct {
++        mfxBitstream *p_bs;
++        mfxFrameSurface1 *p_surface;
++        av_qsv_sync *sync;
++    } out;
++    av_qsv_list *pending;
++} av_qsv_stage;
++
++typedef struct av_qsv_task {
++    mfxBitstream *bs;
++    av_qsv_stage *stage;
++} av_qsv_task;
++
++
++typedef struct av_qsv_space {
++
++    uint8_t is_init_done;
++
++    AV_QSV_STAGE_TYPE type;
++
++    mfxVideoParam m_mfxVideoParam;
++
++    mfxFrameAllocResponse response;
++    mfxFrameAllocRequest request[2];    // [0] - in, [1] - out, if needed
++
++    mfxExtOpaqueSurfaceAlloc ext_opaque_alloc;
++    mfxExtBuffer **p_ext_params;
++    uint16_t p_ext_param_num;
++
++    uint16_t surface_num_max_used;
++    uint16_t surface_num;
++    mfxFrameSurface1 *p_surfaces[AV_QSV_SURFACE_NUM];
++
++    uint16_t sync_num_max_used;
++    uint16_t sync_num;
++    av_qsv_sync *p_syncp[AV_QSV_SYNC_NUM];
++
++    mfxBitstream bs;
++    uint8_t *p_buf;
++    size_t p_buf_max_size;
++
++    // only for encode and tasks
++    av_qsv_list *tasks;
++
++    av_qsv_list *pending;
++
++    // storage for allocations/mfxMemId*
++    mfxMemId *mids;
++} av_qsv_space;
++
++typedef struct av_qsv_context {
++    volatile int is_context_active;
++
++    mfxIMPL impl;
++    mfxSession mfx_session;
++    mfxVersion ver;
++
++    // decode
++    av_qsv_space *dec_space;
++    // encode
++    av_qsv_space *enc_space;
++    // vpp
++    av_qsv_list *vpp_space;
++
++    av_qsv_list *pipes;
++
++    // MediaSDK starting from API version 1.6 includes DecodeTimeStamp
++    // in addition to TimeStamp
++    // see also AV_QSV_MSDK_VERSION_MINOR , AV_QSV_MSDK_VERSION_MAJOR
++    av_qsv_list *dts_seq;
++
++    // practically pthread_mutex_t
++    void *qts_seq_mutex;
++
++    int is_anex;
++
++    void *qsv_config;
++
++} av_qsv_context;
++
++typedef enum {
++    QSV_PART_ANY = 0,
++    QSV_PART_LOWER,
++    QSV_PART_UPPER
++} av_qsv_split;
++
++typedef struct {
++    int64_t dts;
++} av_qsv_dts;
++
++typedef struct av_qsv_alloc_frame {
++    mfxU32 id;
++    mfxFrameInfo info;
++} av_qsv_alloc_frame;
++
++typedef struct av_qsv_alloc_buffer {
++    mfxU32 id;
++    mfxU32 nbytes;
++    mfxU16 type;
++} av_qsv_alloc_buffer;
++
++typedef struct av_qsv_allocators_space {
++    av_qsv_space *space;
++    mfxFrameAllocator frame_alloc;
++    mfxBufferAllocator buffer_alloc;
++} av_qsv_allocators_space;
++
++typedef struct av_qsv_config {
++    /**
++     * Set asynch depth of processing with QSV
++     * Format: 0 and more
++     *
++     * - encoding: Set by user.
++     * - decoding: Set by user.
++     */
++    int async_depth;
++
++    /**
++     * Range of numbers that indicate trade-offs between quality and speed.
++     * Format: from 1/MFX_TARGETUSAGE_BEST_QUALITY to 7/MFX_TARGETUSAGE_BEST_SPEED inclusive
++     *
++     * - encoding: Set by user.
++     * - decoding: unused
++     */
++    int target_usage;
++
++    /**
++     * Number of reference frames; if NumRefFrame = 0, this parameter is not specified.
++     * Format: 0 and more
++     *
++     * - encoding: Set by user.
++     * - decoding: unused
++     */
++    int num_ref_frame;
++
++    /**
++     * Distance between I- or P- key frames; if it is zero, the GOP structure is unspecified.
++     * Note: If GopRefDist = 1, there are no B-frames used.
++     *
++     * - encoding: Set by user.
++     * - decoding: unused
++     */
++     int gop_ref_dist;
++
++    /**
++     * Number of pictures within the current GOP (Group of Pictures); if GopPicSize=0,
++     * then the GOP size is unspecified. If GopPicSize=1, only I-frames are used.
++     *
++     * - encoding: Set by user.
++     * - decoding: unused
++     */
++     int gop_pic_size;
++
++    /**
++     * Set type of surfaces used with QSV
++     * Format: "IOPattern enum" of Media SDK
++     *
++     * - encoding: Set by user.
++     * - decoding: Set by user.
++     */
++    int io_pattern;
++
++    /**
++     * Set amount of additional surfaces might be needed
++     * Format: ammount of additional buffers(surfaces+syncs)
++     * to allocate in advance
++     *
++     * - encoding: Set by user.
++     * - decoding: Set by user.
++     */
++    int additional_buffers;
++
++    /**
++     * If pipeline should be sync.
++     * Format: wait time in milliseconds,
++     *         AV_QSV_SYNC_TIME_DEFAULT/10000 might be a good value
++     *
++     * - encoding: Set by user.
++     * - decoding: Set by user.
++     */
++    int sync_need;
++
++    /**
++     * Type of implementation needed
++     *
++     * - encoding: Set by user.
++     * - decoding: Set by user.
++     */
++    int impl_requested;
++
++    /**
++     * if QSV usage is multithreaded.
++     * Format: Yes/No, 1/0
++     *
++     * - encoding: Set by user.
++     * - decoding: Set by user.
++     */
++    int usage_threaded;
++
++    /**
++     * if QSV use an external allocation (valid per session/mfxSession)
++     * Format: pointer to allocators, if default: 0
++     *
++     * note that:
++     * System Memory:   can be used without provided and external allocator,
++     *  meaning MediaSDK will use an internal one
++     * Video Memory:    in this case - we must provide an external allocator
++     * Also, Media SDK session doesn't require external allocator if the application
++     *  uses opaque memory
++     *
++     * Calls SetFrameAllocator/SetBufferAllocator
++     * (MFXVideoCORE_SetFrameAllocator/MFXVideoCORE_SetBufferAllocator)
++     * are to pass allocators to Media SDK
++     *
++     * - encoding: Set by user.
++     * - decoding: Set by user.
++     */
++    av_qsv_allocators_space *allocators;
++
++} av_qsv_config;
++
++#define ANEX_UNKNOWN    0
++#define ANEX_PREFIX     1
++#define ANEX_NO_PREFIX  2
++
++static const uint8_t ff_prefix_code[] = { 0x00, 0x00, 0x00, 0x01 };
++
++int av_qsv_get_free_sync(av_qsv_space *, av_qsv_context *);
++int av_qsv_get_free_surface(av_qsv_space *, av_qsv_context *, mfxFrameInfo *,
++                     av_qsv_split);
++int av_qsv_get_free_encode_task(av_qsv_list *);
++
++int av_is_qsv_available(mfxIMPL, mfxVersion *);
++void av_qsv_wait_on_sync(av_qsv_context *, av_qsv_stage *);
++
++void av_qsv_add_context_usage(av_qsv_context *, int);
++
++void av_qsv_pipe_list_create(av_qsv_list **, int);
++void av_qsv_pipe_list_clean(av_qsv_list **);
++
++void av_qsv_add_stagee(av_qsv_list **, av_qsv_stage *, int);
++av_qsv_stage *av_qsv_get_last_stage(av_qsv_list *);
++av_qsv_list *av_qsv_pipe_by_stage(av_qsv_list *, av_qsv_stage *);
++void av_qsv_flush_stages(av_qsv_list *, av_qsv_list **);
++
++void av_qsv_dts_ordered_insert(av_qsv_context *, int, int, int64_t, int);
++void av_qsv_dts_pop(av_qsv_context *);
++
++av_qsv_stage *av_qsv_stage_init(void);
++void av_qsv_stage_clean(av_qsv_stage **);
++int av_qsv_context_clean(av_qsv_context *);
++
++int ff_qsv_is_sync_in_pipe(mfxSyncPoint *, av_qsv_context *);
++int ff_qsv_is_surface_in_pipe(mfxFrameSurface1 *, av_qsv_context *);
++
++av_qsv_list *av_qsv_list_init(int);
++int av_qsv_list_lock(av_qsv_list *);
++int av_qsv_list_unlock(av_qsv_list *);
++int av_qsv_list_add(av_qsv_list *, void *);
++void av_qsv_list_rem(av_qsv_list *, void *);
++void av_qsv_list_insert(av_qsv_list *, int, void *);
++void av_qsv_list_close(av_qsv_list **);
++
++int av_qsv_list_count(av_qsv_list *);
++void *av_qsv_list_item(av_qsv_list *, int);
++
++/* @} */
++
++#endif                          //AVCODEC_QSV_H
+diff -Naur ../../libav-v9.6/libavcodec/qsv_h264.c ./libavcodec/qsv_h264.c
+--- ../../libav-v9.6/libavcodec/qsv_h264.c	1970-01-01 01:00:00.000000000 +0100
++++ ./libavcodec/qsv_h264.c	2013-08-19 21:32:01.705244194 +0200
+@@ -0,0 +1,974 @@
++/* ********************************************************************* *\
++
++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 "h264.h"
++#include "h264data.h"
++#include "qsv_h264.h"
++
++static av_qsv_config av_qsv_default_config = {
++    .async_depth        = AV_QSV_ASYNC_DEPTH_DEFAULT,
++    .target_usage       = MFX_TARGETUSAGE_BALANCED,
++    .num_ref_frame      = 0,
++    .gop_ref_dist       = 0,
++    .gop_pic_size       = 0,
++    .io_pattern         = MFX_IOPATTERN_OUT_OPAQUE_MEMORY,
++    .additional_buffers = 0,
++    .sync_need          = 0,
++    .impl_requested     = MFX_IMPL_HARDWARE,
++    .usage_threaded     = 0,
++    .allocators         = 0,
++};
++
++static av_qsv_allocators_space av_qsv_default_system_allocators = {
++    // fill to access mids
++    .space = 0,
++
++    .frame_alloc = {
++                    .pthis      = &av_qsv_default_system_allocators,
++                    .Alloc      = ff_qsv_mem_frame_alloc,
++                    .Lock       = ff_qsv_mem_frame_lock,
++                    .Unlock     = ff_qsv_mem_frame_unlock,
++                    .GetHDL     = ff_qsv_mem_frame_getHDL,
++                    .Free       = ff_qsv_mem_frame_free,
++                    },
++    .buffer_alloc = {
++                     .pthis     = &av_qsv_default_system_allocators,
++                     .Alloc     = ff_qsv_mem_buffer_alloc,
++                     .Lock      = ff_qsv_mem_buffer_lock,
++                     .Unlock    = ff_qsv_mem_buffer_unlock,
++                     .Free      = ff_qsv_mem_buffer_free,
++                     },
++};
++
++static const uint8_t ff_slice_code[] = { 0x00, 0x00, 0x01, 0x65 };
++
++int ff_qsv_nal_find_start_code(uint8_t * pb, size_t size)
++{
++    if ((int) size < 4)
++        return 0;
++
++    while ((4 <= size) && ((0 != pb[0]) || (0 != pb[1]) || (0 != pb[2]) || (1 != pb[3]))) {
++        pb += 1;
++        size -= 1;
++    }
++
++    if (4 <= size)
++        return 1;
++
++    return 0;
++}
++
++int ff_qsv_dec_init_clean(AVCodecContext *avctx)
++{
++     mfxStatus sts = MFX_ERR_NONE;
++     av_qsv_context *qsv = avctx->priv_data;
++     av_qsv_space *qsv_decode = qsv->dec_space;
++     av_qsv_context_clean(qsv);
++     av_freep(&avctx->priv_data);
++}
++int ff_qsv_dec_init(AVCodecContext * avctx)
++{
++    int ret = 0;
++    mfxStatus sts = MFX_ERR_NONE;
++    size_t current_offset = 6;
++    int header_size = 0;
++    unsigned char *current_position;
++    size_t current_size;
++
++    av_qsv_context *qsv = avctx->priv_data;
++    av_qsv_space *qsv_decode = qsv->dec_space;
++    av_qsv_config *qsv_config_context = avctx->hwaccel_context;
++
++    qsv->impl = qsv_config_context->impl_requested;
++
++    memset(&qsv->mfx_session, 0, sizeof(mfxSession));
++    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);
++    AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
++
++    AV_QSV_ZERO_MEMORY(qsv_decode->m_mfxVideoParam);
++    AV_QSV_ZERO_MEMORY(qsv_decode->m_mfxVideoParam.mfx);
++    qsv_decode->m_mfxVideoParam.mfx.CodecId = MFX_CODEC_AVC;
++    qsv_decode->m_mfxVideoParam.IOPattern =
++        qsv_config_context->io_pattern;
++
++    qsv_decode->m_mfxVideoParam.AsyncDepth =
++        qsv_config_context->async_depth;
++
++    AV_QSV_ZERO_MEMORY(qsv_decode->bs);
++    {
++        current_position    = avctx->extradata;
++        current_size        = avctx->extradata_size;
++
++        if (!ff_qsv_nal_find_start_code(current_position, current_size)) {
++
++            while (current_offset <= current_size) {
++                int current_nal_size =
++                    (unsigned char) current_position[current_offset] << 8 |
++                    (unsigned char) current_position[current_offset + 1];
++                unsigned char nal_type =
++                    (unsigned char) current_position[current_offset + 2] & 0x1F;
++
++                if (nal_type == NAL_SPS || nal_type == NAL_PPS) {
++                    memcpy(&qsv_decode->p_buf[header_size], ff_prefix_code,
++                           sizeof(ff_prefix_code));
++                    header_size += sizeof(ff_prefix_code);
++                    memcpy(&qsv_decode->p_buf[header_size],
++                           &current_position[current_offset + 2],
++                           current_nal_size);
++
++                    // fix for PPS as it comes after SPS, so - last
++                    if (nal_type == NAL_PPS) {
++                        // fix of MFXVideoDECODE_DecodeHeader: needs one SLICE to find, any SLICE
++                        memcpy(&qsv_decode->p_buf
++                               [header_size + current_nal_size],
++                               ff_slice_code, current_nal_size);
++                        header_size += sizeof(ff_slice_code);
++                    }
++                }
++
++                header_size += current_nal_size;
++                current_offset += current_nal_size + 3;
++            }
++        } else {
++            memcpy(&qsv_decode->p_buf[0], avctx->extradata,
++                   avctx->extradata_size);
++            header_size = avctx->extradata_size;
++            memcpy(&qsv_decode->p_buf
++                   [header_size], ff_slice_code, sizeof(ff_slice_code));
++            header_size += sizeof(ff_slice_code);
++        }
++    }
++
++    qsv_decode->bs.Data         = qsv_decode->p_buf;
++    qsv_decode->bs.DataLength   = header_size;
++    qsv_decode->bs.MaxLength    = qsv_decode->p_buf_max_size;
++
++    if (qsv_decode->bs.DataLength > qsv_decode->bs.MaxLength) {
++        av_log(avctx, AV_LOG_FATAL, "DataLength > MaxLength\n");
++        return -1;
++    }
++
++    sts = MFXVideoDECODE_DecodeHeader(qsv->mfx_session, &qsv_decode->bs,
++                                    &qsv_decode->m_mfxVideoParam);
++
++    AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
++
++    qsv_decode->bs.DataLength   -= sizeof(ff_slice_code);
++
++    memset(&qsv_decode->request, 0, sizeof(mfxFrameAllocRequest) * 2);
++    sts = MFXVideoDECODE_QueryIOSurf(qsv->mfx_session,
++                                   &qsv_decode->m_mfxVideoParam,
++                                   &qsv_decode->request);
++
++    AV_QSV_IGNORE_MFX_STS(sts, MFX_WRN_PARTIAL_ACCELERATION);
++    AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
++
++    qsv_decode->surface_num =
++        FFMIN(qsv_decode->request[0].NumFrameSuggested +
++            qsv_config_context->async_depth +
++            qsv_config_context->additional_buffers, AV_QSV_SURFACE_NUM);
++
++    if (qsv_decode->surface_num <= 0)
++        qsv_decode->surface_num = AV_QSV_SURFACE_NUM;
++
++    if (qsv_decode->m_mfxVideoParam.IOPattern ==
++        MFX_IOPATTERN_OUT_SYSTEM_MEMORY) {
++
++        // as per non-opaque memory:
++        if (!qsv_config_context->allocators) {
++            av_log(avctx, AV_LOG_INFO,
++                   "Using default allocators for QSV decode\n");
++            ((av_qsv_config *) avctx->hwaccel_context)->allocators =
++                &av_qsv_default_system_allocators;
++        }
++
++        qsv_config_context->allocators->space = qsv_decode;
++
++        qsv_decode->request[0].NumFrameMin       = qsv_decode->surface_num;
++        qsv_decode->request[0].NumFrameSuggested = qsv_decode->surface_num;
++
++        qsv_decode->request[0].Type = MFX_MEMTYPE_EXTERNAL_FRAME | MFX_MEMTYPE_FROM_DECODE;
++        // qsv_decode->request[0].Type |= m_bd3dAlloc ? MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET : MFX_MEMTYPE_SYSTEM_MEMORY;
++        qsv_decode->request[0].Type |= MFX_MEMTYPE_SYSTEM_MEMORY;
++
++        qsv_config_context->allocators->
++            frame_alloc.Alloc(qsv_config_context->allocators,
++                              &qsv_decode->request[0],
++                              &qsv_decode->response);
++    }
++
++    for (int i = 0; i < qsv_decode->surface_num; i++) {
++        qsv_decode->p_surfaces[i] = av_mallocz(sizeof(mfxFrameSurface1));
++        AV_QSV_CHECK_POINTER(qsv_decode->p_surfaces[i],
++                           AVERROR(ENOMEM));
++        memcpy(&(qsv_decode->p_surfaces[i]->Info),
++               &(qsv_decode->request[0].Info), sizeof(mfxFrameInfo));
++
++        // for an external(like DX9/11) based allocation:
++        // we bind:
++        //    m_pmfxSurfaces[i].Data.MemId = m_mfxResponse.mids[i];
++        // else, System memory:
++        if (qsv_decode->m_mfxVideoParam.IOPattern ==
++            MFX_IOPATTERN_OUT_SYSTEM_MEMORY) {
++            sts =
++                qsv_config_context->allocators->
++                frame_alloc.Lock(qsv_config_context->allocators,
++                                 qsv_decode->response.mids[i],
++                                 &(qsv_decode->p_surfaces[i]->Data));
++            AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
++        }
++    }
++
++    qsv_decode->sync_num = FFMIN(qsv_decode->surface_num, AV_QSV_SYNC_NUM);
++    for (int i = 0; i < qsv_decode->sync_num; i++) {
++        qsv_decode->p_syncp[i] = av_mallocz(sizeof(av_qsv_sync));
++        AV_QSV_CHECK_POINTER(qsv_decode->p_syncp[i], AVERROR(ENOMEM));
++        qsv_decode->p_syncp[i]->p_sync = av_mallocz(sizeof(mfxSyncPoint));
++        AV_QSV_CHECK_POINTER(qsv_decode->p_syncp[i]->p_sync, AVERROR(ENOMEM));
++    }
++
++    memset(&qsv_decode->ext_opaque_alloc, 0,
++           sizeof(mfxExtOpaqueSurfaceAlloc));
++
++    if (qsv_decode->m_mfxVideoParam.IOPattern ==
++        MFX_IOPATTERN_OUT_OPAQUE_MEMORY) {
++        qsv_decode->m_mfxVideoParam.NumExtParam     = qsv_decode->p_ext_param_num = 1;
++
++        qsv_decode->p_ext_params = av_mallocz(sizeof(mfxExtBuffer *)*qsv_decode->p_ext_param_num);
++        AV_QSV_CHECK_POINTER(qsv_decode->p_ext_params, AVERROR(ENOMEM));
++
++        qsv_decode->m_mfxVideoParam.ExtParam        = qsv_decode->p_ext_params;
++
++        qsv_decode->ext_opaque_alloc.Out.Surfaces   = qsv_decode->p_surfaces;
++        qsv_decode->ext_opaque_alloc.Out.NumSurface = qsv_decode->surface_num;
++        qsv_decode->ext_opaque_alloc.Out.Type       = qsv_decode->request[0].Type;
++
++        qsv_decode->ext_opaque_alloc.Header.BufferId    = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
++        qsv_decode->ext_opaque_alloc.Header.BufferSz    = sizeof(mfxExtOpaqueSurfaceAlloc);
++        qsv_decode->p_ext_params[0]                     = (mfxExtBuffer *) &qsv_decode->ext_opaque_alloc;
++    }
++
++    sts =
++        MFXVideoDECODE_Init(qsv->mfx_session,
++                            &qsv_decode->m_mfxVideoParam);
++
++    AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
++
++    qsv_decode->is_init_done = 1;
++    return ret;
++}
++
++av_cold int ff_qsv_decode_init(AVCodecContext * avctx)
++{
++    av_qsv_context *qsv;
++    av_qsv_space *qsv_decode;
++    av_qsv_config **qsv_config_context =
++        (av_qsv_config **) & avctx->hwaccel_context;
++
++    qsv = avctx->priv_data;
++
++    if (qsv && qsv->dec_space && qsv->dec_space->is_init_done || !avctx->extradata_size)
++        return 0;
++
++    if(!qsv)
++    qsv = av_mallocz(sizeof(av_qsv_context));
++    if (!qsv)
++        return AVERROR(ENOMEM);
++
++    if(!qsv_decode)
++    qsv_decode = av_mallocz(sizeof(av_qsv_space));
++    if (!qsv_decode){
++        free(qsv);
++        return AVERROR(ENOMEM);
++    }
++    avctx->priv_data = qsv;
++    qsv->dec_space = qsv_decode;
++
++    qsv_decode->p_buf_max_size = AV_QSV_BUF_SIZE_DEFAULT;
++    if(!qsv_decode->p_buf)
++    qsv_decode->p_buf = av_malloc(qsv_decode->p_buf_max_size * sizeof(uint8_t));
++    if (!qsv_decode->p_buf)
++        return AVERROR(ENOMEM);
++
++    if (!(*qsv_config_context)) {
++        av_log(avctx, AV_LOG_INFO,
++               "Using default config for QSV decode\n");
++        avctx->hwaccel_context = &av_qsv_default_config;
++    } else {
++        if ((*qsv_config_context)->io_pattern !=
++            MFX_IOPATTERN_OUT_OPAQUE_MEMORY
++            && (*qsv_config_context)->io_pattern !=
++            MFX_IOPATTERN_OUT_SYSTEM_MEMORY) {
++            av_log_missing_feature( avctx,"Only MFX_IOPATTERN_OUT_OPAQUE_MEMORY and MFX_IOPATTERN_OUT_SYSTEM_MEMORY are currently supported\n",0);
++            return AVERROR_PATCHWELCOME;
++        }
++    }
++
++    qsv->qsv_config = avctx->hwaccel_context;
++
++    av_qsv_add_context_usage(qsv,
++                          HAVE_THREADS
++                          ? (*qsv_config_context)->usage_threaded :
++                          HAVE_THREADS);
++
++    // allocation of p_syncp and p_surfaces inside of ff_qsv_dec_init
++    return ff_qsv_dec_init(avctx);
++}
++
++static av_cold int qsv_decode_end(AVCodecContext * avctx)
++{
++    mfxStatus sts       = MFX_ERR_NONE;
++    av_qsv_context *qsv    = avctx->priv_data;
++    av_qsv_config *qsv_config_context = avctx->hwaccel_context;
++
++    if (qsv) {
++        av_qsv_space *qsv_decode = qsv->dec_space;
++        if (qsv_decode && qsv_decode->is_init_done) {
++            // todo: change to AV_LOG_INFO
++            av_log(avctx, AV_LOG_QUIET,
++                   "qsv_decode report done, max_surfaces: %u/%u , max_syncs: %u/%u\n",
++                   qsv_decode->surface_num_max_used,
++                   qsv_decode->surface_num, qsv_decode->sync_num_max_used,
++                   qsv_decode->sync_num);
++        }
++
++        if (qsv_config_context
++            && qsv_config_context->io_pattern ==
++            MFX_IOPATTERN_OUT_SYSTEM_MEMORY) {
++            if (qsv_config_context->allocators) {
++                sts =
++                    qsv_config_context->allocators->
++                    frame_alloc.Free(qsv_config_context->allocators,
++                                     &qsv_decode->response);
++                AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
++            } else {
++                av_log(avctx, AV_LOG_FATAL,
++                       "No QSV allocators found for clean up\n");
++            }
++        }
++        // closing the own resources
++        av_freep(&qsv_decode->p_buf);
++
++        for (int i = 0; i < qsv_decode->surface_num; i++) {
++            av_freep(&qsv_decode->p_surfaces[i]);
++        }
++        qsv_decode->surface_num = 0;
++
++        if( qsv_decode->p_ext_param_num || qsv_decode->p_ext_params )
++            av_freep(&qsv_decode->p_ext_params);
++        qsv_decode->p_ext_param_num = 0;
++
++        for (int i = 0; i < qsv_decode->sync_num; i++) {
++            av_freep(&qsv_decode->p_syncp[i]->p_sync);
++            av_freep(&qsv_decode->p_syncp[i]);
++        }
++        qsv_decode->sync_num = 0;
++        qsv_decode->is_init_done = 0;
++
++        av_freep(&qsv->dec_space);
++
++        // closing commong stuff
++        av_qsv_context_clean(qsv);
++    }
++
++    return 0;
++}
++
++static int qsv_decode_frame(AVCodecContext * avctx, void *data,
++                            int *data_size, AVPacket * avpkt)
++{
++    mfxStatus sts = MFX_ERR_NONE;
++    av_qsv_context *qsv = avctx->priv_data;
++    av_qsv_space *qsv_decode;
++    av_qsv_config *qsv_config_context = avctx->hwaccel_context;
++    int *got_picture_ptr = data_size;
++    int ret_value = 1;
++    uint8_t *current_position = avpkt->data;
++    int current_size = avpkt->size;
++    int frame_processed = 0;
++    size_t frame_length = 0;
++    int surface_idx = 0;
++    int extra_data_workaround = 0;
++
++    int sync_idx = 0;
++    int current_nal_size;
++    unsigned char nal_type;
++    av_qsv_stage *new_stage = 0;
++    mfxBitstream *input_bs = NULL;
++    size_t current_offset = 2;
++    av_qsv_list *qsv_atom = 0;
++    av_qsv_list *pipe = 0;
++
++    AVFrame *picture = (AVFrame *) data;
++
++    *got_picture_ptr = 0;
++
++    qsv = avctx->priv_data;
++    if(!qsv){
++        extra_data_workaround = !avctx->extradata_size;
++        if(extra_data_workaround){
++            avctx->extradata = avpkt->data;
++            avctx->extradata_size = avpkt->size;
++        }
++        sts = ff_qsv_decode_init(avctx);
++        qsv = avctx->priv_data;
++        if(extra_data_workaround){
++            avctx->extradata = 0;
++            avctx->extradata_size = 0;
++        }
++        if(sts<0){
++             ff_qsv_dec_init_clean(avctx);
++             *got_picture_ptr = 0;
++             return sts;
++   	    }
++    }
++    qsv_decode = qsv->dec_space;
++
++    if (qsv_decode->bs.DataOffset + qsv_decode->bs.DataLength +
++        current_size > qsv_decode->bs.MaxLength) {
++        memmove(&qsv_decode->bs.Data[0],
++                qsv_decode->bs.Data + qsv_decode->bs.DataOffset,
++                qsv_decode->bs.DataLength);
++        qsv_decode->bs.DataOffset = 0;
++    }
++
++    if (current_size) {
++        if(qsv->is_anex == ANEX_UNKNOWN){
++            if (ff_qsv_nal_find_start_code(current_position, current_size) && current_position == avpkt->data)
++               qsv->is_anex = ANEX_PREFIX;
++            else
++               qsv->is_anex = ANEX_NO_PREFIX;
++        }
++        if (qsv->is_anex == ANEX_PREFIX){
++            memcpy(&qsv_decode->bs.Data[0] +
++                   qsv_decode->bs.DataLength +
++                   qsv_decode->bs.DataOffset,
++                   avpkt->data,
++                   avpkt->size);
++            qsv_decode->bs.DataLength += avpkt->size;
++            frame_length += avpkt->size;
++        }
++        else
++            while (current_offset <= current_size) {
++                current_nal_size =
++                    ((unsigned char) current_position[current_offset - 2] << 24 |
++                     (unsigned char) current_position[current_offset -  1] << 16 |
++                     (unsigned char) current_position[current_offset] << 8 |
++                     (unsigned char) current_position[current_offset + 1]) - 1;
++                nal_type =
++                    (unsigned char) current_position[current_offset + 2] & 0x1F;
++                {
++                    frame_length += current_nal_size;
++                    memcpy(&qsv_decode->bs.Data[0] +
++                           qsv_decode->bs.DataLength +
++                           qsv_decode->bs.DataOffset, ff_prefix_code,
++                           sizeof(ff_prefix_code));
++                    qsv_decode->bs.DataLength += sizeof(ff_prefix_code);
++                    memcpy(&qsv_decode->bs.Data[0] +
++                           qsv_decode->bs.DataLength +
++                           qsv_decode->bs.DataOffset,
++                           &current_position[current_offset + 2],
++                           current_nal_size + 1);
++                    qsv_decode->bs.DataLength += current_nal_size + 1;
++                }
++                current_offset += current_nal_size + 5;
++            }
++
++        if (qsv_decode->bs.DataLength > qsv_decode->bs.MaxLength) {
++            av_log(avctx, AV_LOG_FATAL, "DataLength > MaxLength\n");
++            return -1;
++        }
++    }
++
++    if (frame_length || current_size == 0) {
++
++        qsv_decode->bs.TimeStamp = avpkt->pts;
++
++        //not a drain
++        if ((current_size || qsv_decode->bs.DataLength))
++            av_qsv_dts_ordered_insert(qsv, 0, 0, qsv_decode->bs.TimeStamp, 0);
++
++        sts = MFX_ERR_NONE;
++        // ignore warnings, where warnings >0 , and not error codes <0
++        while (MFX_ERR_NONE <= sts || MFX_ERR_MORE_SURFACE == sts
++               || MFX_WRN_DEVICE_BUSY == sts) {
++
++            if (MFX_ERR_MORE_SURFACE == sts || MFX_ERR_NONE == sts) {
++                surface_idx =
++                    av_qsv_get_free_surface(qsv_decode, qsv,
++                                     &qsv_decode->request[0].Info,
++                                     QSV_PART_ANY);
++
++                if (surface_idx == -1) {
++                    *got_picture_ptr = 0;
++                    return 0;
++                }
++            }
++
++            if (MFX_WRN_DEVICE_BUSY == sts)
++                av_qsv_sleep(10);
++
++            sync_idx = av_qsv_get_free_sync(qsv_decode, qsv);
++
++            if (sync_idx == -1) {
++                *got_picture_ptr = 0;
++                return 0;
++            }
++            new_stage = av_qsv_stage_init();
++            input_bs = NULL;
++            // if to drain last ones
++            if (current_size || qsv_decode->bs.DataLength)
++                input_bs = &qsv_decode->bs;
++            // Decode a frame asynchronously (returns immediately)
++            // very first IDR / SLICE should be with SPS/PPS
++            sts = MFXVideoDECODE_DecodeFrameAsync(qsv->mfx_session, input_bs,
++                                                qsv_decode->p_surfaces
++                                                [surface_idx],
++                                                &new_stage->out.p_surface,
++                                                qsv_decode->p_syncp[sync_idx]->p_sync);
++
++            new_stage->out.sync = qsv_decode->p_syncp[sync_idx];
++            // have some results
++            if (MFX_ERR_NONE <= sts && MFX_WRN_DEVICE_BUSY != sts &&
++                MFX_WRN_VIDEO_PARAM_CHANGED != sts) {
++
++                ff_qsv_atomic_inc(&(new_stage->out.p_surface->Data.Locked));
++
++                new_stage->type         = AV_QSV_DECODE;
++                new_stage->in.p_bs      = input_bs;
++                new_stage->in.p_surface = qsv_decode->p_surfaces[surface_idx];
++
++                pipe = av_qsv_list_init(HAVE_THREADS ? qsv_config_context->usage_threaded : HAVE_THREADS);
++                av_qsv_add_stagee(&pipe, new_stage,
++                              HAVE_THREADS ?
++                              qsv_config_context->usage_threaded :
++                              HAVE_THREADS);
++
++                av_qsv_list_add(qsv->pipes, pipe);
++                qsv_atom = pipe;
++
++                // usage for forced decode sync and results, can be avoided if sync done by next stage
++                // also note wait time for Sync and possible usage with MFX_WRN_IN_EXECUTION check
++                if (qsv_config_context->sync_need) {
++                    sts =
++                        MFXVideoCORE_SyncOperation(qsv->mfx_session,
++                                                   qsv_decode->p_syncp[sync_idx]->p_sync,
++                                                   qsv_config_context->sync_need);
++                    AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
++
++                    // no need to wait more -> force off
++                    ff_qsv_atomic_dec(&qsv_decode->p_syncp[sync_idx]->in_use);
++                    new_stage->out.sync   = 0;
++                }
++
++                sts = MFX_ERR_NONE;
++                break;
++            }
++            av_qsv_stage_clean(&new_stage);
++
++            /*
++               Can be because of:
++               - runtime situation:
++               - drain procedure:
++               At the end of the bitstream, the application continuously calls the MFXVideoDECODE_DecodeFrameAsync function with a
++               NULL bitstream pointer to drain any remaining frames cached within the Intel
++               Media SDK decoder, until the function returns MFX_ERR_MORE_DATA.
++             */
++            if (MFX_ERR_MORE_DATA == sts) {
++                // not a drain
++                if (current_size) {
++                    *got_picture_ptr = 0;
++                    return avpkt->size;
++                }
++                // drain
++                break;
++            }
++            if (MFX_ERR_MORE_SURFACE == sts  ){
++                continue;
++            }
++
++            AV_QSV_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
++        }
++
++        frame_processed = 1;
++    }
++
++    if (frame_processed) {
++
++        if (current_size) {
++            *got_picture_ptr    = 1;
++            ret_value           = avpkt->size;
++        } else {
++            if (MFX_ERR_MORE_DATA != sts) {
++                *got_picture_ptr    = 1;
++                ret_value           = avpkt->size;
++            } else {
++                *got_picture_ptr = 0;
++                return 0;
++            }
++        }
++
++        picture->pkt_pts            = new_stage->out.p_surface->Data.TimeStamp;
++        picture->pts                = new_stage->out.p_surface->Data.TimeStamp;
++
++        picture->repeat_pict        = (qsv_decode->m_mfxVideoParam.mfx.FrameInfo.PicStruct & MFX_PICSTRUCT_FIELD_REPEATED);
++        picture->interlaced_frame   = !(qsv_decode->m_mfxVideoParam.mfx.FrameInfo.PicStruct & MFX_PICSTRUCT_PROGRESSIVE);
++        picture->top_field_first    = (qsv_decode->m_mfxVideoParam.mfx.FrameInfo.PicStruct & MFX_PICSTRUCT_FIELD_TFF);
++
++        // since we do not know it yet from MSDK, let's do just a simple way for now
++        picture->key_frame          = (avctx->frame_number == 0) ? 1 : 0;
++
++        if (qsv_decode->m_mfxVideoParam.IOPattern == MFX_IOPATTERN_OUT_SYSTEM_MEMORY) {
++            picture->data[0]        = new_stage->out.p_surface->Data.Y;
++            picture->data[1]        = new_stage->out.p_surface->Data.VU;
++            picture->linesize[0]    = new_stage->out.p_surface->Info.Width;
++            picture->linesize[1]    = new_stage->out.p_surface->Info.Width;
++        } else {
++            picture->data[0]        = 0;
++            picture->data[1]        = 0;
++            picture->linesize[0]    = 0;
++            picture->linesize[1]    = 0;
++        }
++
++        picture->data[2]            = qsv_atom;
++        picture->linesize[2]        = 0;
++    }
++
++    return ret_value;
++}
++
++// Will be called when seeking
++static void qsv_flush_dpb(AVCodecContext * avctx)
++{
++    av_qsv_context *qsv = avctx->priv_data;
++    av_qsv_space *qsv_decode = qsv->dec_space;
++
++    qsv_decode->bs.DataOffset = 0;
++    qsv_decode->bs.DataLength = 0;
++    qsv_decode->bs.MaxLength = qsv_decode->p_buf_max_size;
++}
++
++
++mfxStatus ff_qsv_mem_frame_alloc(mfxHDL pthis,
++                                 mfxFrameAllocRequest * request,
++                                 mfxFrameAllocResponse * response)
++{
++    mfxStatus sts = MFX_ERR_NONE;
++
++    mfxU32 numAllocated = 0;
++
++    mfxU32 width = AV_QSV_ALIGN32(request->Info.Width);
++    mfxU32 height = AV_QSV_ALIGN32(request->Info.Height);
++    mfxU32 nbytes;
++
++    av_qsv_allocators_space *this_alloc = (av_qsv_allocators_space *) pthis;
++    av_qsv_alloc_frame *fs;
++
++    if (!this_alloc->space)
++        return MFX_ERR_NOT_INITIALIZED;
++
++    switch (request->Info.FourCC) {
++    case MFX_FOURCC_YV12:
++    case MFX_FOURCC_NV12:
++        nbytes =
++            width * height + (width >> 1) * (height >> 1) +
++            (width >> 1) * (height >> 1);
++        break;
++    case MFX_FOURCC_RGB3:
++        nbytes = width * height + width * height + width * height;
++        break;
++    case MFX_FOURCC_RGB4:
++        nbytes =
++            width * height + width * height + width * height +
++            width * height;
++        break;
++    case MFX_FOURCC_YUY2:
++        nbytes =
++            width * height + (width >> 1) * (height) +
++            (width >> 1) * (height);
++        break;
++    default:
++        return MFX_ERR_UNSUPPORTED;
++    }
++
++    this_alloc->space->mids =
++        av_malloc(sizeof(mfxMemId) * request->NumFrameSuggested);
++    if (!this_alloc->space->mids)
++        return MFX_ERR_MEMORY_ALLOC;
++
++    // allocate frames
++    for (numAllocated = 0; numAllocated < request->NumFrameSuggested;
++         numAllocated++) {
++        sts =
++            this_alloc->buffer_alloc.Alloc(this_alloc->buffer_alloc.pthis,
++                                           nbytes +
++                                           AV_QSV_ALIGN32(sizeof
++                                                       (av_qsv_alloc_frame)),
++                                           request->Type,
++                                           &(this_alloc->
++                                             space->mids[numAllocated]));
++
++        if (MFX_ERR_NONE != sts)
++            break;
++
++        sts =
++            this_alloc->buffer_alloc.Lock(this_alloc->buffer_alloc.pthis,
++                                          this_alloc->
++                                          space->mids[numAllocated],
++                                          (mfxU8 **) & fs);
++
++        if (MFX_ERR_NONE != sts)
++            break;
++
++        fs->id = AV_QSV_ID_FRAME;
++        fs->info = request->Info;
++        this_alloc->buffer_alloc.Unlock(this_alloc->buffer_alloc.pthis,
++                                        this_alloc->
++                                        space->mids[numAllocated]);
++    }
++
++    // check the number of allocated frames
++    if (numAllocated < request->NumFrameMin)
++        return MFX_ERR_MEMORY_ALLOC;
++
++    response->NumFrameActual = (mfxU16) numAllocated;
++    response->mids = this_alloc->space->mids;
++
++    return MFX_ERR_NONE;
++}
++
++mfxStatus ff_qsv_mem_frame_lock(mfxHDL pthis, mfxMemId mid,
++                                mfxFrameData * ptr)
++{
++    mfxStatus sts = MFX_ERR_NONE;
++    av_qsv_alloc_frame *fs = 0;
++    mfxU16 width;
++    mfxU16 height;
++
++    av_qsv_allocators_space *this_alloc = (av_qsv_allocators_space *) pthis;
++
++    if (!this_alloc->space)
++        return MFX_ERR_NOT_INITIALIZED;
++    if (!ptr)
++        return MFX_ERR_NULL_PTR;
++
++
++    sts =
++        this_alloc->buffer_alloc.Lock(this_alloc->buffer_alloc.pthis, mid,
++                                      (mfxU8 **) & fs);
++
++    if (MFX_ERR_NONE != sts)
++        return sts;
++
++    if (AV_QSV_ID_FRAME != fs->id) {
++        this_alloc->buffer_alloc.Unlock(this_alloc->buffer_alloc.pthis,
++                                        mid);
++        return MFX_ERR_INVALID_HANDLE;
++    }
++
++    width = (mfxU16) AV_QSV_ALIGN32(fs->info.Width);
++    height = (mfxU16) AV_QSV_ALIGN32(fs->info.Height);
++    ptr->B = ptr->Y =
++        (mfxU8 *) fs + AV_QSV_ALIGN32(sizeof(av_qsv_allocators_space));
++
++    switch (fs->info.FourCC) {
++    case MFX_FOURCC_NV12:
++        ptr->U = ptr->Y + width * height;
++        ptr->V = ptr->U + 1;
++        ptr->Pitch = width;
++        break;
++    case MFX_FOURCC_YV12:
++        ptr->V = ptr->Y + width * height;
++        ptr->U = ptr->V + (width >> 1) * (height >> 1);
++        ptr->Pitch = width;
++        break;
++    case MFX_FOURCC_YUY2:
++        ptr->U = ptr->Y + 1;
++        ptr->V = ptr->Y + 3;
++        ptr->Pitch = 2 * width;
++        break;
++    case MFX_FOURCC_RGB3:
++        ptr->G = ptr->B + 1;
++        ptr->R = ptr->B + 2;
++        ptr->Pitch = 3 * width;
++        break;
++    case MFX_FOURCC_RGB4:
++        ptr->G = ptr->B + 1;
++        ptr->R = ptr->B + 2;
++        ptr->A = ptr->B + 3;
++        ptr->Pitch = 4 * width;
++        break;
++    default:
++        return MFX_ERR_UNSUPPORTED;
++    }
++
++    return MFX_ERR_NONE;
++}
++
++mfxStatus ff_qsv_mem_frame_unlock(mfxHDL pthis, mfxMemId mid,
++                                  mfxFrameData * ptr)
++{
++    mfxStatus sts = MFX_ERR_NONE;
++    av_qsv_allocators_space *this_alloc = (av_qsv_allocators_space *) pthis;
++
++    sts =
++        this_alloc->buffer_alloc.Unlock(this_alloc->buffer_alloc.pthis,
++                                        mid);
++
++    if (MFX_ERR_NONE != sts)
++        return sts;
++
++    if (NULL != ptr) {
++        ptr->Pitch = 0;
++        ptr->Y = 0;
++        ptr->U = 0;
++        ptr->V = 0;
++    }
++
++    return MFX_ERR_NONE;
++}
++
++mfxStatus ff_qsv_mem_frame_getHDL(mfxHDL pthis, mfxMemId mid,
++                                  mfxHDL * handle)
++{
++    return MFX_ERR_UNSUPPORTED;
++}
++
++mfxStatus ff_qsv_mem_frame_free(mfxHDL pthis,
++                                mfxFrameAllocResponse * response)
++{
++    mfxStatus sts = MFX_ERR_NONE;
++    av_qsv_allocators_space *this_alloc = (av_qsv_allocators_space *) pthis;
++    mfxU32 i;
++
++    if (!response)
++        return MFX_ERR_NULL_PTR;
++
++    if (!this_alloc->space)
++        return MFX_ERR_NOT_INITIALIZED;
++
++    if (response->mids)
++        for (i = 0; i < response->NumFrameActual; i++) {
++            if (response->mids[i]) {
++                sts =
++                    this_alloc->buffer_alloc.Free(this_alloc->
++                                                  buffer_alloc.pthis,
++                                                  response->mids[i]);
++                if (MFX_ERR_NONE != sts)
++                    return sts;
++            }
++        }
++
++    av_freep(&response->mids);
++
++    return sts;
++}
++
++
++mfxStatus ff_qsv_mem_buffer_alloc(mfxHDL pthis, mfxU32 nbytes, mfxU16 type,
++                                  mfxMemId * mid)
++{
++    av_qsv_alloc_buffer *bs;
++    mfxU32 header_size;
++    mfxU8 *buffer_ptr;
++
++    if (!mid)
++        return MFX_ERR_NULL_PTR;
++
++    if (0 == (type & MFX_MEMTYPE_SYSTEM_MEMORY))
++        return MFX_ERR_UNSUPPORTED;
++
++    header_size = AV_QSV_ALIGN32(sizeof(av_qsv_alloc_buffer));
++    buffer_ptr = (mfxU8 *) av_malloc(header_size + nbytes);
++
++    if (!buffer_ptr)
++        return MFX_ERR_MEMORY_ALLOC;
++
++    bs = (av_qsv_alloc_buffer *) buffer_ptr;
++    bs->id = AV_QSV_ID_BUFFER;
++    bs->type = type;
++    bs->nbytes = nbytes;
++    *mid = (mfxHDL) bs;
++    return MFX_ERR_NONE;
++}
++
++mfxStatus ff_qsv_mem_buffer_lock(mfxHDL pthis, mfxMemId mid, mfxU8 ** ptr)
++{
++    av_qsv_alloc_buffer *bs;
++
++    if (!ptr)
++        return MFX_ERR_NULL_PTR;
++
++    bs = (av_qsv_alloc_buffer *) mid;
++
++    if (!bs)
++        return MFX_ERR_INVALID_HANDLE;
++    if (AV_QSV_ID_BUFFER != bs->id)
++        return MFX_ERR_INVALID_HANDLE;
++
++    *ptr = (mfxU8 *) bs + AV_QSV_ALIGN32(sizeof(av_qsv_alloc_buffer));
++    return MFX_ERR_NONE;
++}
++
++mfxStatus ff_qsv_mem_buffer_unlock(mfxHDL pthis, mfxMemId mid)
++{
++    av_qsv_alloc_buffer *bs = (av_qsv_alloc_buffer *) mid;
++
++    if (!bs || AV_QSV_ID_BUFFER != bs->id)
++        return MFX_ERR_INVALID_HANDLE;
++
++    return MFX_ERR_NONE;
++}
++
++mfxStatus ff_qsv_mem_buffer_free(mfxHDL pthis, mfxMemId mid)
++{
++    av_qsv_alloc_buffer *bs = (av_qsv_alloc_buffer *) mid;
++    if (!bs || AV_QSV_ID_BUFFER != bs->id)
++        return MFX_ERR_INVALID_HANDLE;
++
++    av_freep(&bs);
++    return MFX_ERR_NONE;
++}
++
++
++AVCodec ff_h264_qsv_decoder = {
++    .name           = "h264_qsv",
++    .type           = AVMEDIA_TYPE_VIDEO,
++    .id             = AV_CODEC_ID_H264,
++    .init           = ff_qsv_decode_init,
++    .close          = qsv_decode_end,
++    .decode         = qsv_decode_frame,
++    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
++    .flush          = qsv_flush_dpb,
++    .long_name      = NULL_IF_CONFIG_SMALL("H.264 / AVC / Intel QSV"),
++    .pix_fmts       = (const enum PixelFormat[]) {AV_PIX_FMT_QSV_H264,
++                                                  AV_PIX_FMT_NONE},
++};
+diff -Naur ../../libav-v9.6/libavcodec/qsv_h264.h ./libavcodec/qsv_h264.h
+--- ../../libav-v9.6/libavcodec/qsv_h264.h	1970-01-01 01:00:00.000000000 +0100
++++ ./libavcodec/qsv_h264.h	2013-08-19 21:32:01.710244809 +0200
+@@ -0,0 +1,65 @@
++/* ********************************************************************* *\
++
++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 AVCODEC_QSV_H264_H
++#define AVCODEC_QSV_H264_H
++
++#include "qsv.h"
++
++int ff_qsv_dec_init(AVCodecContext *);
++int ff_qsv_nal_find_start_code(uint8_t * pb, size_t size);
++
++int ff_qsv_dec_init_clean(AVCodecContext *avctx);
++av_cold int ff_qsv_decode_init(AVCodecContext * avctx);
++static av_cold int qsv_decode_end(AVCodecContext * avctx);
++static int qsv_decode_frame(AVCodecContext * avctx, void *data,
++                            int *data_size, AVPacket * avpkt);
++static void qsv_flush_dpb(AVCodecContext * avctx);
++
++
++// Default for SYSTEM MEMORY
++// as from MFXFrameAllocator
++mfxStatus ff_qsv_mem_frame_alloc(mfxHDL pthis,
++                                 mfxFrameAllocRequest * request,
++                                 mfxFrameAllocResponse * response);
++mfxStatus ff_qsv_mem_frame_lock(mfxHDL pthis, mfxMemId mid,
++                                mfxFrameData * ptr);
++mfxStatus ff_qsv_mem_frame_unlock(mfxHDL pthis, mfxMemId mid,
++                                  mfxFrameData * ptr);
++mfxStatus ff_qsv_mem_frame_getHDL(mfxHDL pthis, mfxMemId mid,
++                                  mfxHDL * handle);
++mfxStatus ff_qsv_mem_frame_free(mfxHDL pthis,
++                                mfxFrameAllocResponse * response);
++// as from mfxBufferAllocator
++mfxStatus ff_qsv_mem_buffer_alloc(mfxHDL pthis, mfxU32 nbytes, mfxU16 type,
++                                  mfxMemId * mid);
++mfxStatus ff_qsv_mem_buffer_lock(mfxHDL pthis, mfxMemId mid, mfxU8 ** ptr);
++mfxStatus ff_qsv_mem_buffer_unlock(mfxHDL pthis, mfxMemId mid);
++mfxStatus ff_qsv_mem_buffer_free(mfxHDL pthis, mfxMemId mid);
++
++#endif                          //AVCODEC_QSV_H264_H
+diff -Naur ../../libav-v9.6/libavutil/pixfmt.h ./libavutil/pixfmt.h
+--- ../../libav-v9.6/libavutil/pixfmt.h	2013-05-12 08:39:07.000000000 +0200
++++ ./libavutil/pixfmt.h	2013-08-14 10:48:00.522497405 +0200
+@@ -178,6 +178,7 @@
+     AV_PIX_FMT_YUVA422P16LE, ///< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
+     AV_PIX_FMT_YUVA444P16BE, ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
+     AV_PIX_FMT_YUVA444P16LE, ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
++    AV_PIX_FMT_QSV_H264,  ///< H.264 HW decoding with QSV, data[2] contains qsv_atom information for MFX_IOPATTERN_OUT_OPAQUE_MEMORY, MFX_IOPATTERN_OUT_VIDEO_MEMORY
+     AV_PIX_FMT_NB,        ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
+ 
+ #if FF_API_PIX_FMT