From 3326f988806a5decae025727784a19c8cc223833 Mon Sep 17 00:00:00 2001 From: Rodeo Date: Thu, 22 Aug 2013 20:34:44 +0000 Subject: Big merge, QSV to trunk: part 2 (new files). git-svn-id: svn://svn.handbrake.fr/HandBrake/trunk@5738 b64f7644-9d1e-0410-96f1-a4d463321fa5 --- contrib/ffmpeg/A00-qsv.patch | 2285 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2285 insertions(+) create mode 100644 contrib/ffmpeg/A00-qsv.patch (limited to 'contrib/ffmpeg') 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 ++#include ++#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 ++#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 ++#if HAVE_PTHREADS ++#include ++#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], ++ ¤t_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, ++ ¤t_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 -- cgit v1.2.3