Hello nablet, Saturday, September 17, 2016, 11:32:26 AM, you wrote:
> From: Anton Khirnov <an...@khirnov.net> > Signed-off-by: nablet developer <s...@nablet.com> > --- > libavutil/Makefile | 3 + > libavutil/hwcontext.c | 3 + > libavutil/hwcontext.h | 1 + > libavutil/hwcontext_internal.h | 1 + > libavutil/hwcontext_qsv.c | 791 > +++++++++++++++++++++++++++++++++++++++++ > libavutil/hwcontext_qsv.h | 52 +++ > 6 files changed, 851 insertions(+) > create mode 100644 libavutil/hwcontext_qsv.c > create mode 100644 libavutil/hwcontext_qsv.h > diff --git a/libavutil/Makefile b/libavutil/Makefile > index 1e06176..76da7d4 100644 > --- a/libavutil/Makefile > +++ b/libavutil/Makefile > @@ -35,6 +35,7 @@ HEADERS = adler32.h > hwcontext.h \ > hwcontext_cuda.h \ > hwcontext_dxva2.h \ > + hwcontext_qsv.h \ > hwcontext_vaapi.h \ > hwcontext_vdpau.h \ > imgutils.h \ > @@ -154,6 +155,7 @@ OBJS-$(!HAVE_ATOMICS_NATIVE) += atomic.o > > OBJS-$(CONFIG_CUDA) += hwcontext_cuda.o > OBJS-$(CONFIG_DXVA2) += hwcontext_dxva2.o > +OBJS-$(CONFIG_QSV) += hwcontext_qsv.o > OBJS-$(CONFIG_LZO) += lzo.o > OBJS-$(CONFIG_OPENCL) += opencl.o opencl_internal.o > OBJS-$(CONFIG_VAAPI) += hwcontext_vaapi.o > @@ -166,6 +168,7 @@ SLIBOBJS-$(HAVE_GNU_WINDRES) += avutilres.o > > SKIPHEADERS-$(CONFIG_CUDA) += hwcontext_cuda.h > SKIPHEADERS-$(CONFIG_DXVA2) += hwcontext_dxva2.h > +SKIPHEADERS-$(CONFIG_QSV) += hwcontext_qsv.h > SKIPHEADERS-$(CONFIG_VAAPI) += hwcontext_vaapi.h > SKIPHEADERS-$(CONFIG_VDPAU) += hwcontext_vdpau.h > SKIPHEADERS-$(HAVE_ATOMICS_GCC) += atomic_gcc.h > diff --git a/libavutil/hwcontext.c b/libavutil/hwcontext.c > index 1e9e913..be1d73e 100644 > --- a/libavutil/hwcontext.c > +++ b/libavutil/hwcontext.c > @@ -35,6 +35,9 @@ static const HWContextType *hw_table[] = { > #if CONFIG_DXVA2 > &ff_hwcontext_type_dxva2, > #endif > +#if CONFIG_QSV > + &ff_hwcontext_type_qsv, > +#endif > #if CONFIG_VAAPI > &ff_hwcontext_type_vaapi, > #endif > diff --git a/libavutil/hwcontext.h b/libavutil/hwcontext.h > index 4e9da02..5e2af09 100644 > --- a/libavutil/hwcontext.h > +++ b/libavutil/hwcontext.h > @@ -29,6 +29,7 @@ enum AVHWDeviceType { > AV_HWDEVICE_TYPE_CUDA, > AV_HWDEVICE_TYPE_VAAPI, > AV_HWDEVICE_TYPE_DXVA2, > + AV_HWDEVICE_TYPE_QSV, > }; > > typedef struct AVHWDeviceInternal AVHWDeviceInternal; > diff --git a/libavutil/hwcontext_internal.h b/libavutil/hwcontext_internal.h > index cf832fe..079e42b 100644 > --- a/libavutil/hwcontext_internal.h > +++ b/libavutil/hwcontext_internal.h > @@ -101,6 +101,7 @@ struct AVHWFramesInternal { > > extern const HWContextType ff_hwcontext_type_cuda; > extern const HWContextType ff_hwcontext_type_dxva2; > +extern const HWContextType ff_hwcontext_type_qsv; > extern const HWContextType ff_hwcontext_type_vaapi; > extern const HWContextType ff_hwcontext_type_vdpau; > > diff --git a/libavutil/hwcontext_qsv.c b/libavutil/hwcontext_qsv.c > new file mode 100644 > index 0000000..13be5b0 > --- /dev/null > +++ b/libavutil/hwcontext_qsv.c > @@ -0,0 +1,791 @@ > +/* > + * This file is part of FFmpeg. > + * > + * FFmpeg is free software; you can redistribute it and/or > + * modify it under the terms of the GNU Lesser General Public > + * License as published by the Free Software Foundation; either > + * version 2.1 of the License, or (at your option) any later version. > + * > + * FFmpeg is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + * Lesser General Public License for more details. > + * > + * You should have received a copy of the GNU Lesser General Public > + * License along with FFmpeg; if not, write to the Free Software > + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 > USA > + */ > + > +#include <stdint.h> > +#include <string.h> > + > +#include <mfx/mfxvideo.h> > + > +#include "config.h" > + > +#if CONFIG_VAAPI > +#include "hwcontext_vaapi.h" > +#endif > +#if CONFIG_DXVA2 > +#include "hwcontext_dxva2.h" > +#endif > + > +#include "buffer.h" > +#include "common.h" > +#include "hwcontext.h" > +#include "hwcontext_internal.h" > +#include "hwcontext_qsv.h" > +#include "mem.h" > +#include "pixfmt.h" > +#include "pixdesc.h" > +#include "time.h" > + > +typedef struct QSVDevicePriv { > + AVBufferRef *child_device_ctx; > +} QSVDevicePriv; > + > +typedef struct QSVDeviceContext { > + mfxHDL handle; > + mfxHandleType handle_type; > + mfxVersion ver; > + mfxIMPL impl; > + > + enum AVHWDeviceType child_device_type; > + enum AVPixelFormat child_pix_fmt; > +} QSVDeviceContext; > + > +typedef struct QSVFramesContext { > + mfxSession session_download; > + mfxSession session_upload; > + > + AVBufferRef *child_frames_ref; > + mfxFrameSurface1 *surfaces_internal; > + int nb_surfaces_used; > + > + // used in the frame allocator for non-opaque surfaces > + mfxMemId *mem_ids; > + // used in the opaque alloc request for opaque surfaces > + mfxFrameSurface1 **surface_ptrs; > + > + mfxExtOpaqueSurfaceAlloc opaque_alloc; > + mfxExtBuffer *ext_buffers[1]; > +} QSVFramesContext; > + > +static const struct { > + mfxHandleType handle_type; > + enum AVHWDeviceType device_type; > + enum AVPixelFormat pix_fmt; > +} supported_handle_types[] = { > +#if CONFIG_VAAPI > + { MFX_HANDLE_VA_DISPLAY, AV_HWDEVICE_TYPE_VAAPI, > AV_PIX_FMT_VAAPI }, > +#endif > +#if CONFIG_DXVA2 > + { MFX_HANDLE_D3D9_DEVICE_MANAGER, AV_HWDEVICE_TYPE_DXVA2, > AV_PIX_FMT_DXVA2_VLD }, > +#endif > + { 0 }, > +}; > + > +static const struct { > + enum AVPixelFormat pix_fmt; > + uint32_t fourcc; > +} supported_pixel_formats[] = { > + { AV_PIX_FMT_NV12, MFX_FOURCC_NV12 }, > +}; > + > +static int qsv_device_init(AVHWDeviceContext *ctx) > +{ > + AVQSVDeviceContext *hwctx = ctx->hwctx; > + QSVDeviceContext *s = ctx->internal->priv; > + > + mfxStatus err; > + int i; > + > + for (i = 0; supported_handle_types[i].handle_type; i++) { > + err = MFXVideoCORE_GetHandle(hwctx->session, > supported_handle_types[i].handle_type, > + &s->handle); > + if (err == MFX_ERR_NONE) { + s->>handle_type = supported_handle_types[i].handle_type; + s->>child_device_type = supported_handle_types[i].device_type; + s->>child_pix_fmt = supported_handle_types[i].pix_fmt; > + break; > + } > + } + if (!s->>handle) { > + av_log(ctx, AV_LOG_VERBOSE, "No supported hw handle could be > retrieved " > + "from the session\n"); > + } > + > + err = MFXQueryIMPL(hwctx->session, &s->impl); > + if (err == MFX_ERR_NONE) > + err = MFXQueryVersion(hwctx->session, &s->ver); > + if (err != MFX_ERR_NONE) { > + av_log(ctx, AV_LOG_ERROR, "Error querying the session attributes\n"); > + return AVERROR_UNKNOWN; > + } > + > + return 0; > +} > + > +static void qsv_frames_uninit(AVHWFramesContext *ctx) > +{ > + QSVFramesContext *s = ctx->internal->priv; > + + if (s->>session_download) { > + MFXVideoVPP_Close(s->session_download); > + MFXClose(s->session_download); > + } + s->>session_download = NULL; > + + if (s->>session_upload) { > + MFXVideoVPP_Close(s->session_upload); > + MFXClose(s->session_upload); > + } + s->>session_upload = NULL; > + + av_freep(&s->>mem_ids); + av_freep(&s->>surface_ptrs); + av_freep(&s->>surfaces_internal); > + av_buffer_unref(&s->child_frames_ref); > +} > + > +static void qsv_pool_release_dummy(void *opaque, uint8_t *data) > +{ > +} > + > +static AVBufferRef *qsv_pool_alloc(void *opaque, int size) > +{ > + AVHWFramesContext *ctx = (AVHWFramesContext*)opaque; > + QSVFramesContext *s = ctx->internal->priv; > + AVQSVFramesContext *hwctx = ctx->hwctx; > + + if (s->>nb_surfaces_used < hwctx->nb_surfaces) { + s->>nb_surfaces_used++; > + return av_buffer_create((uint8_t*)(s->surfaces_internal + > s->nb_surfaces_used - 1), > + sizeof(*hwctx->surfaces), > qsv_pool_release_dummy, NULL, 0); > + } > + > + return NULL; > +} > + > +static int qsv_init_child_ctx(AVHWFramesContext *ctx) > +{ > + AVQSVFramesContext *hwctx = ctx->hwctx; > + QSVFramesContext *s = ctx->internal->priv; > + QSVDeviceContext *device_priv = ctx->device_ctx->internal->priv; > + > + AVBufferRef *child_device_ref = NULL; > + AVBufferRef *child_frames_ref = NULL; > + > + AVHWDeviceContext *child_device_ctx; > + AVHWFramesContext *child_frames_ctx; > + > + int i, ret = 0; > + > + if (!device_priv->handle) { > + av_log(ctx, AV_LOG_ERROR, > + "Cannot create a non-opaque internal surface pool without " > + "a hardware handle\n"); > + return AVERROR(EINVAL); > + } > + > + child_device_ref = > av_hwdevice_ctx_alloc(device_priv->child_device_type); > + if (!child_device_ref) > + return AVERROR(ENOMEM); > + child_device_ctx = (AVHWDeviceContext*)child_device_ref->data; > + > +#if CONFIG_VAAPI > + if (child_device_ctx->type == AV_HWDEVICE_TYPE_VAAPI) { > + AVVAAPIDeviceContext *child_device_hwctx = child_device_ctx->hwctx; > + child_device_hwctx->display = (VADisplay)device_priv->handle; > + } > +#endif > +#if CONFIG_DXVA2 > + if (child_device_ctx->type == AV_HWDEVICE_TYPE_DXVA2) { > + AVDXVA2DeviceContext *child_device_hwctx = child_device_ctx->hwctx; > + child_device_hwctx->devmgr = > (IDirect3DDeviceManager9*)device_priv->handle; > + } > +#endif > + > + ret = av_hwdevice_ctx_init(child_device_ref); > + if (ret < 0) { > + av_log(ctx, AV_LOG_ERROR, "Error initializing a child device > context\n"); > + goto fail; > + } > + > + child_frames_ref = av_hwframe_ctx_alloc(child_device_ref); > + if (!child_frames_ref) { > + ret = AVERROR(ENOMEM); > + goto fail; > + } > + child_frames_ctx = (AVHWFramesContext*)child_frames_ref->data; > + > + child_frames_ctx->format = device_priv->child_pix_fmt; > + child_frames_ctx->sw_format = ctx->sw_format; > + child_frames_ctx->initial_pool_size = ctx->initial_pool_size; > + child_frames_ctx->width = ctx->width; > + child_frames_ctx->height = ctx->height; > + > +#if CONFIG_DXVA2 > + if (child_device_ctx->type == AV_HWDEVICE_TYPE_DXVA2) { > + AVDXVA2FramesContext *child_frames_hwctx = child_frames_ctx->hwctx; + if (hwctx->>frame_type & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET) > + child_frames_hwctx->surface_type = > DXVA2_VideoProcessorRenderTarget; > + else > + child_frames_hwctx->surface_type = > DXVA2_VideoDecoderRenderTarget; > + } > +#endif > + > + ret = av_hwframe_ctx_init(child_frames_ref); > + if (ret < 0) { > + av_log(ctx, AV_LOG_ERROR, "Error initializing a child frames > context\n"); > + goto fail; > + } > + > +#if CONFIG_VAAPI > + if (child_device_ctx->type == AV_HWDEVICE_TYPE_VAAPI) { > + AVVAAPIFramesContext *child_frames_hwctx = child_frames_ctx->hwctx; > + for (i = 0; i < ctx->initial_pool_size; i++) + s->>surfaces_internal[i].Data.MemId = child_frames_hwctx->surface_ids + i; + hwctx->>frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET; > + } > +#endif > +#if CONFIG_DXVA2 > + if (child_device_ctx->type == AV_HWDEVICE_TYPE_DXVA2) { > + AVDXVA2FramesContext *child_frames_hwctx = child_frames_ctx->hwctx; > + for (i = 0; i < ctx->initial_pool_size; i++) + s->>surfaces_internal[i].Data.MemId = (mfxMemId)child_frames_hwctx->surfaces[i]; > + if (child_frames_hwctx->surface_type == > DXVA2_VideoProcessorRenderTarget) + hwctx->>frame_type = MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET; > + else + hwctx->>frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET; > + } > +#endif > + + s->>child_frames_ref = child_frames_ref; > + child_frames_ref = NULL; > + > +fail: > + av_buffer_unref(&child_device_ref); > + av_buffer_unref(&child_frames_ref); > + return ret; > +} > + > +static int qsv_init_pool(AVHWFramesContext *ctx, uint32_t fourcc) > +{ > + QSVFramesContext *s = ctx->internal->priv; > + AVQSVFramesContext *frames_hwctx = ctx->hwctx; > + const AVPixFmtDescriptor *desc; > + > + int i, ret = 0; > + > + desc = av_pix_fmt_desc_get(ctx->sw_format); > + if (!desc) > + return AVERROR_BUG; > + + if (ctx->>initial_pool_size <= 0) { > + av_log(ctx, AV_LOG_ERROR, "QSV requires a fixed frame pool size\n"); > + return AVERROR(EINVAL); > + } > + + s->>surfaces_internal = av_mallocz_array(ctx->initial_pool_size, > + sizeof(*s->surfaces_internal)); + if (!s->>surfaces_internal) > + return AVERROR(ENOMEM); > + > + for (i = 0; i < ctx->initial_pool_size; i++) { > + mfxFrameSurface1 *surf = &s->surfaces_internal[i]; > + + surf->>Info.BitDepthLuma = desc->comp[0].depth; + surf->>Info.BitDepthChroma = desc->comp[0].depth; + surf->>Info.Shift = desc->comp[0].depth > 8; > + + if (desc->>log2_chroma_w && desc->log2_chroma_h) + surf->>Info.ChromaFormat = MFX_CHROMAFORMAT_YUV420; > + else if (desc->log2_chroma_w) + surf->>Info.ChromaFormat = MFX_CHROMAFORMAT_YUV422; > + else + surf->>Info.ChromaFormat = MFX_CHROMAFORMAT_YUV444; > + + surf->>Info.FourCC = fourcc; + surf->>Info.Width = ctx->width; + surf->>Info.CropW = ctx->width; + surf->>Info.Height = ctx->height; + surf->>Info.CropH = ctx->height; + surf->>Info.FrameRateExtN = 25; + surf->>Info.FrameRateExtD = 1; > + } > + > + if (!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)) { > + ret = qsv_init_child_ctx(ctx); > + if (ret < 0) > + return ret; > + } > + + ctx->>internal->pool_internal = av_buffer_pool_init2(sizeof(mfxFrameSurface1), > + ctx, qsv_pool_alloc, > NULL); + if (!ctx->>internal->pool_internal) > + return AVERROR(ENOMEM); > + + frames_hwctx->>surfaces = s->surfaces_internal; + frames_hwctx->>nb_surfaces = ctx->initial_pool_size; > + > + return 0; > +} > + > +static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req, > + mfxFrameAllocResponse *resp) > +{ > + AVHWFramesContext *ctx = pthis; > + QSVFramesContext *s = ctx->internal->priv; > + AVQSVFramesContext *hwctx = ctx->hwctx; > + mfxFrameInfo *i = &req->Info; > + mfxFrameInfo *i1 = &hwctx->surfaces[0].Info; > + + if (!(req->>Type & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET) || + !(req->>Type & (MFX_MEMTYPE_FROM_VPPIN | MFX_MEMTYPE_FROM_VPPOUT)) || + !(req->>Type & MFX_MEMTYPE_EXTERNAL_FRAME)) > + return MFX_ERR_UNSUPPORTED; + if (i->>Width != i1->Width || i->Height != i1->Height || + i->>FourCC != i1->FourCC || i->ChromaFormat != i1->ChromaFormat) { > + av_log(ctx, AV_LOG_ERROR, "Mismatching surface properties in an " > + "allocation request: %dx%d %d %d vs %dx%d %d %d\n", + i->>Width, i->Height, i->FourCC, i->ChromaFormat, + i1->>Width, i1->Height, i1->FourCC, i1->ChromaFormat); > + return MFX_ERR_UNSUPPORTED; > + } > + + resp->>mids = s->mem_ids; + resp->>NumFrameActual = hwctx->nb_surfaces; > + > + return MFX_ERR_NONE; > +} > + > +static mfxStatus frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp) > +{ > + return MFX_ERR_NONE; > +} > + > +static mfxStatus frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr) > +{ > + return MFX_ERR_UNSUPPORTED; > +} > + > +static mfxStatus frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr) > +{ > + return MFX_ERR_UNSUPPORTED; > +} > + > +static mfxStatus frame_get_hdl(mfxHDL pthis, mfxMemId mid, mfxHDL *hdl) > +{ > + *hdl = mid; > + return MFX_ERR_NONE; > +} > + > +static int qsv_init_internal_session(AVHWFramesContext *ctx, > + mfxSession *session, int upload) > +{ > + QSVFramesContext *s = ctx->internal->priv; > + AVQSVFramesContext *frames_hwctx = ctx->hwctx; > + QSVDeviceContext *device_priv = ctx->device_ctx->internal->priv; > + int opaque = !!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME); > + > + mfxFrameAllocator frame_allocator = { > + .pthis = ctx, > + .Alloc = frame_alloc, > + .Lock = frame_lock, > + .Unlock = frame_unlock, > + .GetHDL = frame_get_hdl, > + .Free = frame_free, > + }; > + > + mfxVideoParam par; > + mfxStatus err; > + > + err = MFXInit(device_priv->impl, &device_priv->ver, session); > + if (err != MFX_ERR_NONE) { > + av_log(ctx, AV_LOG_ERROR, "Error initializing an internal > session\n"); > + return AVERROR_UNKNOWN; > + } > + > + if (device_priv->handle) { > + err = MFXVideoCORE_SetHandle(*session, device_priv->handle_type, > + device_priv->handle); > + if (err != MFX_ERR_NONE) > + return AVERROR_UNKNOWN; > + } > + > + if (!opaque) { > + err = MFXVideoCORE_SetFrameAllocator(*session, &frame_allocator); > + if (err != MFX_ERR_NONE) > + return AVERROR_UNKNOWN; > + } > + > + memset(&par, 0, sizeof(par)); > + > + if (opaque) { > + par.ExtParam = s->ext_buffers; > + par.NumExtParam = FF_ARRAY_ELEMS(s->ext_buffers); > + par.IOPattern = upload ? MFX_IOPATTERN_OUT_OPAQUE_MEMORY : > + MFX_IOPATTERN_IN_OPAQUE_MEMORY; > + } else { > + par.IOPattern = upload ? MFX_IOPATTERN_OUT_VIDEO_MEMORY : > + MFX_IOPATTERN_IN_VIDEO_MEMORY; > + } > + > + par.IOPattern |= upload ? MFX_IOPATTERN_IN_SYSTEM_MEMORY : > + MFX_IOPATTERN_OUT_SYSTEM_MEMORY; > + par.AsyncDepth = 1; > + > + par.vpp.In = frames_hwctx->surfaces[0].Info; > + > + /* Apparently VPP requires the frame rate to be set to some value, > otherwise > + * init will fail (probably for the framerate conversion filter). Since > we > + * are only doing data upload/download here, we just invent an arbitrary > + * value */ > + par.vpp.In.FrameRateExtN = 25; > + par.vpp.In.FrameRateExtD = 1; > + par.vpp.Out = par.vpp.In; > + > + err = MFXVideoVPP_Init(*session, &par); > + if (err != MFX_ERR_NONE) { > + av_log(ctx, AV_LOG_ERROR, "Error opening the internal VPP > session\n"); > + return AVERROR_UNKNOWN; > + } > + > + return 0; > +} > + > +static int qsv_frames_init(AVHWFramesContext *ctx) > +{ > + QSVFramesContext *s = ctx->internal->priv; > + AVQSVFramesContext *frames_hwctx = ctx->hwctx; > + > + int opaque = !!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME); > + > + uint32_t fourcc = 0; > + int i, ret; > + > + for (i = 0; i < FF_ARRAY_ELEMS(supported_pixel_formats); i++) { > + if (supported_pixel_formats[i].pix_fmt == ctx->sw_format) { > + fourcc = supported_pixel_formats[i].fourcc; > + break; > + } > + } > + if (!fourcc) { > + av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format\n"); > + return AVERROR(ENOSYS); > + } > + + if (!ctx->>pool) { > + ret = qsv_init_pool(ctx, fourcc); > + if (ret < 0) { > + av_log(ctx, AV_LOG_ERROR, "Error creating an internal frame > pool\n"); > + return ret; > + } > + } > + > + if (opaque) { + s->>surface_ptrs = av_mallocz_array(frames_hwctx->nb_surfaces, > + sizeof(*s->surface_ptrs)); + if (!s->>surface_ptrs) > + return AVERROR(ENOMEM); > + > + for (i = 0; i < frames_hwctx->nb_surfaces; i++) + s->>surface_ptrs[i] = frames_hwctx->surfaces + i; > + + s->>opaque_alloc.In.Surfaces = s->surface_ptrs; + s->>opaque_alloc.In.NumSurface = frames_hwctx->nb_surfaces; + s->>opaque_alloc.In.Type = frames_hwctx->frame_type; > + + s->>opaque_alloc.Out = s->opaque_alloc.In; > + + s->>opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION; + s->>opaque_alloc.Header.BufferSz = sizeof(s->opaque_alloc); > + + s->>ext_buffers[0] = (mfxExtBuffer*)&s->opaque_alloc; > + } else { + s->>mem_ids = av_mallocz_array(frames_hwctx->nb_surfaces, sizeof(*s->mem_ids)); + if (!s->>mem_ids) > + return AVERROR(ENOMEM); > + > + for (i = 0; i < frames_hwctx->nb_surfaces; i++) + s->>mem_ids[i] = frames_hwctx->surfaces[i].Data.MemId; > + } > + > + ret = qsv_init_internal_session(ctx, &s->session_download, 0); > + if (ret < 0) > + return ret; > + > + ret = qsv_init_internal_session(ctx, &s->session_upload, 1); > + if (ret < 0) > + return ret; > + > + return 0; > +} > + > +static int qsv_get_buffer(AVHWFramesContext *ctx, AVFrame *frame) > +{ + frame->>buf[0] = av_buffer_pool_get(ctx->pool); + if (!frame->>buf[0]) > + return AVERROR(ENOMEM); > + + frame->>data[3] = frame->buf[0]->data; + frame->>format = AV_PIX_FMT_QSV; + frame->>width = ctx->width; + frame->>height = ctx->height; > + > + return 0; > +} > + > +static int qsv_transfer_get_formats(AVHWFramesContext *ctx, > + enum AVHWFrameTransferDirection dir, > + enum AVPixelFormat **formats) > +{ > + enum AVPixelFormat *fmts; > + > + fmts = av_malloc_array(2, sizeof(*fmts)); > + if (!fmts) > + return AVERROR(ENOMEM); > + + fmts[0] = ctx->>sw_format; > + fmts[1] = AV_PIX_FMT_NONE; > + > + *formats = fmts; > + > + return 0; > +} > + > +static int qsv_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst, > + const AVFrame *src) > +{ > + QSVFramesContext *s = ctx->internal->priv; > + mfxFrameSurface1 out = {{ 0 }}; > + mfxFrameSurface1 *in = (mfxFrameSurface1*)src->data[3]; > + > + mfxSyncPoint sync = NULL; > + mfxStatus err; > + + out.Info = in->>Info; > + out.Data.PitchLow = dst->linesize[0]; > + out.Data.Y = dst->data[0]; > + out.Data.U = dst->data[1]; > + out.Data.V = dst->data[2]; > + out.Data.A = dst->data[3]; > + > + do { > + err = MFXVideoVPP_RunFrameVPPAsync(s->session_download, in, &out, > NULL, &sync); > + if (err == MFX_WRN_DEVICE_BUSY) > + av_usleep(1); > + } while (err == MFX_WRN_DEVICE_BUSY); > + > + if (err < 0 || !sync) { > + av_log(ctx, AV_LOG_ERROR, "Error downloading the surface\n"); > + return AVERROR_UNKNOWN; > + } > + > + do { > + err = MFXVideoCORE_SyncOperation(s->session_download, sync, 1000); > + } while (err == MFX_WRN_IN_EXECUTION); > + if (err < 0) { > + av_log(ctx, AV_LOG_ERROR, "Error synchronizing the operation: %d\n", > err); > + return AVERROR_UNKNOWN; > + } > + > + return 0; > +} > + > +static int qsv_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst, > + const AVFrame *src) > +{ > + QSVFramesContext *s = ctx->internal->priv; > + mfxFrameSurface1 in = {{ 0 }}; > + mfxFrameSurface1 *out = (mfxFrameSurface1*)dst->data[3]; > + > + mfxSyncPoint sync = NULL; > + mfxStatus err; > + + in.Info = out->>Info; > + in.Data.PitchLow = src->linesize[0]; > + in.Data.Y = src->data[0]; > + in.Data.U = src->data[1]; > + in.Data.V = src->data[2]; > + in.Data.A = src->data[3]; > + > + do { > + err = MFXVideoVPP_RunFrameVPPAsync(s->session_upload, &in, out, > NULL, &sync); > + if (err == MFX_WRN_DEVICE_BUSY) > + av_usleep(1); > + } while (err == MFX_WRN_DEVICE_BUSY); > + > + if (err < 0 || !sync) { > + av_log(ctx, AV_LOG_ERROR, "Error uploading the surface\n"); > + return AVERROR_UNKNOWN; > + } > + > + do { > + err = MFXVideoCORE_SyncOperation(s->session_upload, sync, 1000); > + } while (err == MFX_WRN_IN_EXECUTION); > + if (err < 0) { > + av_log(ctx, AV_LOG_ERROR, "Error synchronizing the operation\n"); > + return AVERROR_UNKNOWN; > + } > + > + return 0; > +} > + > +static int qsv_frames_get_constraints(AVHWDeviceContext *ctx, > + const void *hwconfig, > + AVHWFramesConstraints *constraints) > +{ > + int i; > + + constraints->>valid_sw_formats = av_malloc_array(FF_ARRAY_ELEMS(supported_pixel_formats) + 1, > + > sizeof(*constraints->valid_sw_formats)); > + if (!constraints->valid_sw_formats) > + return AVERROR(ENOMEM); > + > + for (i = 0; i < FF_ARRAY_ELEMS(supported_pixel_formats); i++) > + constraints->valid_sw_formats[i] = > supported_pixel_formats[i].pix_fmt; + constraints->>valid_sw_formats[FF_ARRAY_ELEMS(supported_pixel_formats)] = AV_PIX_FMT_NONE; > + + constraints->>valid_hw_formats = av_malloc_array(2, sizeof(*constraints->valid_hw_formats)); > + if (!constraints->valid_hw_formats) > + return AVERROR(ENOMEM); > + + constraints->>valid_hw_formats[0] = AV_PIX_FMT_QSV; + constraints->>valid_hw_formats[1] = AV_PIX_FMT_NONE; > + > + return 0; > +} > + > +static void qsv_device_free(AVHWDeviceContext *ctx) > +{ > + AVQSVDeviceContext *hwctx = ctx->hwctx; > + QSVDevicePriv *priv = ctx->user_opaque; > + + if (hwctx->>session) > + MFXClose(hwctx->session); > + > + av_buffer_unref(&priv->child_device_ctx); > + av_freep(&priv); > +} > + > +static mfxIMPL choose_implementation(const char *device) > +{ > + static const struct { > + const char *name; > + mfxIMPL impl; > + } impl_map[] = { > + { "auto", MFX_IMPL_AUTO }, > + { "sw", MFX_IMPL_SOFTWARE }, > + { "hw", MFX_IMPL_HARDWARE }, > + { "auto_any", MFX_IMPL_AUTO_ANY }, > + { "hw_any", MFX_IMPL_HARDWARE_ANY }, > + { "hw2", MFX_IMPL_HARDWARE2 }, > + { "hw3", MFX_IMPL_HARDWARE3 }, > + { "hw4", MFX_IMPL_HARDWARE4 }, > + }; > + > + mfxIMPL impl = MFX_IMPL_AUTO_ANY; > + int i; > + > + if (device) { > + for (i = 0; i < FF_ARRAY_ELEMS(impl_map); i++) > + if (!strcmp(device, impl_map[i].name)) { > + impl = impl_map[i].impl; > + break; > + } > + if (i == FF_ARRAY_ELEMS(impl_map)) > + impl = strtol(device, NULL, 0); > + } > + > + return impl; > +} > + > +static int qsv_device_create(AVHWDeviceContext *ctx, const char *device, > + AVDictionary *opts, int flags) > +{ > + AVQSVDeviceContext *hwctx = ctx->hwctx; > + QSVDevicePriv *priv; > + enum AVHWDeviceType child_device_type; > + AVDictionaryEntry *e; > + > + mfxVersion ver = { { 3, 1 } }; > + mfxIMPL impl; > + mfxHDL handle; > + mfxHandleType handle_type; > + mfxStatus err; > + int ret; > + > + priv = av_mallocz(sizeof(*priv)); > + if (!priv) > + return AVERROR(ENOMEM); > + + ctx->>user_opaque = priv; + ctx->>free = qsv_device_free; > + > + e = av_dict_get(opts, "child_device", NULL, 0); > + > + if (CONFIG_VAAPI) > + child_device_type = AV_HWDEVICE_TYPE_VAAPI; > + else if (CONFIG_DXVA2) > + child_device_type = AV_HWDEVICE_TYPE_DXVA2; > + else { > + av_log(ctx, AV_LOG_ERROR, "No supported child device type is > enabled\n"); > + return AVERROR(ENOSYS); > + } > + > + ret = av_hwdevice_ctx_create(&priv->child_device_ctx, child_device_type, > + e ? e->value : NULL, NULL, 0); > + if (ret < 0) > + return ret; > + > + { > + AVHWDeviceContext *child_device_ctx = > (AVHWDeviceContext*)priv->child_device_ctx->data; > +#if CONFIG_VAAPI > + AVVAAPIDeviceContext *child_device_hwctx = child_device_ctx->hwctx; > + handle_type = MFX_HANDLE_VA_DISPLAY; > + handle = (mfxHDL)child_device_hwctx->display; > +#elif CONFIG_DXVA2 > + AVDXVA2DeviceContext *child_device_hwctx = child_device_ctx->hwctx; > + handle_type = MFX_HANDLE_D3D9_DEVICE_MANAGER; > + handle = (mfxHDL)child_device_hwctx->devmgr; > +#endif > + } > + > + impl = choose_implementation(device); > + > + err = MFXInit(impl, &ver, &hwctx->session); > + if (err != MFX_ERR_NONE) { > + av_log(ctx, AV_LOG_ERROR, "Error initializing an MFX session\n"); > + return AVERROR_UNKNOWN; > + } > + > + err = MFXVideoCORE_SetHandle(hwctx->session, handle_type, handle); > + if (err != MFX_ERR_NONE) > + return AVERROR_UNKNOWN; > + > + return 0; > +} > + > +const HWContextType ff_hwcontext_type_qsv = { > + .type = AV_HWDEVICE_TYPE_QSV, > + .name = "QSV", > + > + .device_hwctx_size = sizeof(AVQSVDeviceContext), > + .device_priv_size = sizeof(QSVDeviceContext), > + .frames_hwctx_size = sizeof(AVQSVFramesContext), > + .frames_priv_size = sizeof(QSVFramesContext), > + > + .device_create = qsv_device_create, > + .device_init = qsv_device_init, > + .frames_get_constraints = qsv_frames_get_constraints, > + .frames_init = qsv_frames_init, > + .frames_uninit = qsv_frames_uninit, > + .frames_get_buffer = qsv_get_buffer, > + .transfer_get_formats = qsv_transfer_get_formats, > + .transfer_data_to = qsv_transfer_data_to, > + .transfer_data_from = qsv_transfer_data_from, > + > + .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_QSV, > AV_PIX_FMT_NONE }, > +}; > diff --git a/libavutil/hwcontext_qsv.h b/libavutil/hwcontext_qsv.h > new file mode 100644 > index 0000000..0cd6285 > --- /dev/null > +++ b/libavutil/hwcontext_qsv.h > @@ -0,0 +1,52 @@ > +/* > + * This file is part of FFmpeg. > + * > + * FFmpeg is free software; you can redistribute it and/or > + * modify it under the terms of the GNU Lesser General Public > + * License as published by the Free Software Foundation; either > + * version 2.1 of the License, or (at your option) any later version. > + * > + * FFmpeg is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + * Lesser General Public License for more details. > + * > + * You should have received a copy of the GNU Lesser General Public > + * License along with FFmpeg; if not, write to the Free Software > + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 > USA > + */ > + > +#ifndef AVUTIL_HWCONTEXT_QSV_H > +#define AVUTIL_HWCONTEXT_QSV_H > + > +#include <mfx/mfxvideo.h> > + > +/** > + * @file > + * An API-specific header for AV_HWDEVICE_TYPE_QSV. > + * > + * This API does not support dynamic frame pools. AVHWFramesContext.pool must > + * return AVBufferRefs whose data pointer points to an mfxFrameSurface1 > struct. > + */ > + > +/** > + * This struct is allocated as AVHWDeviceContext.hwctx > + */ > +typedef struct AVQSVDeviceContext { > + mfxSession session; > +} AVQSVDeviceContext; > + > +/** > + * This struct is allocated as AVHWFramesContext.hwctx > + */ > +typedef struct AVQSVFramesContext { > + mfxFrameSurface1 *surfaces; > + int nb_surfaces; > + > + /** > + * A combination of MFX_MEMTYPE_* describing the frame pool. > + */ > + int frame_type; > +} AVQSVFramesContext; > + > +#endif /* AVUTIL_HWCONTEXT_QSV_H */ This should be a good step to make qsv branches of ffmpeg and libav closer. LGTM. -- Best regards, Ivan mailto:ivan.us...@nablet.com _______________________________________________ ffmpeg-devel mailing list ffmpeg-devel@ffmpeg.org http://ffmpeg.org/mailman/listinfo/ffmpeg-devel