[FFmpeg-cvslog] Merge commit '59e7361cc791e5103be1712dc59a2055f118d0da'

James Almer git at videolan.org
Wed Sep 28 19:32:08 EEST 2016


ffmpeg | branch: master | James Almer <jamrial at gmail.com> | Wed Sep 28 13:30:27 2016 -0300| [eba041476879fc46a49fa36fca03f1565ecaefca] | committer: James Almer

Merge commit '59e7361cc791e5103be1712dc59a2055f118d0da'

* commit '59e7361cc791e5103be1712dc59a2055f118d0da':
  hwcontext: add a QSV implementation

Conflicts:
    doc/APIchanges
    libavutil/version.h

Merged-by: James Almer <jamrial at gmail.com>

> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=eba041476879fc46a49fa36fca03f1565ecaefca
---

 doc/APIchanges                 |   4 +
 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      |  53 +++
 libavutil/version.h            |   2 +-
 8 files changed, 857 insertions(+), 1 deletion(-)

diff --git a/doc/APIchanges b/doc/APIchanges
index 7acfc3e..7869629 100644
--- a/doc/APIchanges
+++ b/doc/APIchanges
@@ -15,6 +15,10 @@ libavutil:     2015-08-28
 
 API changes, most recent first:
 
+2016-09-xx - xxxxxxx - lavu 55.32.100 / 55.16.0 - hwcontext.h hwcontext_qsv.h
+  Add AV_HWDEVICE_TYPE_QSV and a new installed header with QSV-specific
+  hwcontext definitions.
+
 2016-09-xx - xxxxxxx - lavc 57.59.100/ 57.23.0 - avcodec.h
   AVCodecContext.hw_frames_ctx now may be used by decoders.
 
diff --git a/libavutil/Makefile b/libavutil/Makefile
index 1e06176..7385ec2 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_LIBMFX)                   += 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_LIBMFX)           += 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..8af7afa 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_LIBMFX
+    &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..b98d611
--- /dev/null
+++ b/libavutil/hwcontext_qsv.h
@@ -0,0 +1,53 @@
+/*
+ * 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
+ * contain 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 */
+
diff --git a/libavutil/version.h b/libavutil/version.h
index 42adf4f..787ba58 100644
--- a/libavutil/version.h
+++ b/libavutil/version.h
@@ -79,7 +79,7 @@
  */
 
 #define LIBAVUTIL_VERSION_MAJOR  55
-#define LIBAVUTIL_VERSION_MINOR  31
+#define LIBAVUTIL_VERSION_MINOR  32
 #define LIBAVUTIL_VERSION_MICRO 100
 
 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \


======================================================================

diff --cc doc/APIchanges
index 7acfc3e,74316ed..7869629
--- a/doc/APIchanges
+++ b/doc/APIchanges
@@@ -15,66 -13,23 +15,70 @@@ libavutil:     2015-08-2
  
  API changes, most recent first:
  
 -2016-xx-xx - xxxxxxx - lavu 55.16.0 - hwcontext.h hwcontext_qsv.h
++2016-09-xx - xxxxxxx - lavu 55.32.100 / 55.16.0 - hwcontext.h hwcontext_qsv.h
+   Add AV_HWDEVICE_TYPE_QSV and a new installed header with QSV-specific
+   hwcontext definitions.
+ 
 -2016-xx-xx - xxxxxxx - lavc 57.23.0 - avcodec.h
 +2016-09-xx - xxxxxxx - lavc 57.59.100/ 57.23.0 - avcodec.h
    AVCodecContext.hw_frames_ctx now may be used by decoders.
  
 -2016-xx-xx - xxxxxxx - lavc 57.20.0 - avcodec.h
 +2016-09-27 - xxxxxxx - lavf 57.51.100 - avformat.h
 +  Add av_stream_get_codec_timebase()
 +
 +2016-09-27 - 23c0779 - lswr 2.2.100 - swresample.h
 +  Add swr_build_matrix().
 +
 +2016-09-xx - xxxxxxx - lavc 57.58.100 - avcodec.h
 +  Add AV_CODEC_CAP_AVOID_PROBING codec capability flag.
 +
 +2016-09-xx - xxxxxxx - lavf 57.49.100 - avformat.h
 +  Add avformat_transfer_internal_stream_timing_info helper to help with stream
 +  copy.
 +
 +2016-08-29 - 4493390 - lavfi 6.58.100 - avfilter.h
 +  Add AVFilterContext.nb_threads.
 +
 +2016-08-15 - c3c4c72 - lavc 57.53.100 - avcodec.h
 +  Add trailing_padding to AVCodecContext to match the corresponding
 +  field in AVCodecParameters.
 +
 +2016-08-15 - b746ed7 - lavc 57.52.100 - avcodec.h
 +  Add a new API for chained BSF filters and passthrough (null) BSF --
 +  av_bsf_list_alloc(), av_bsf_list_free(), av_bsf_list_append(),
 +  av_bsf_list_append2(), av_bsf_list_finalize(), av_bsf_list_parse_str()
 +  and av_bsf_get_null_filter().
 +
 +2016-08-04 - 82a33c8 - lavf 57.46.100 - avformat.h
 +  Add av_get_frame_filename2()
 +
 +2016-07-09 - 775389f / 90f469a - lavc 57.50.100 / 57.20.0 - avcodec.h
    Add FF_PROFILE_H264_MULTIVIEW_HIGH and FF_PROFILE_H264_STEREO_HIGH.
  
 -2016-xx-xx - xxxxxxx - lavu 55.13.0 - hwcontext.h
 +2016-06-30 - c1c7e0ab - lavf 57.41.100 - avformat.h
 +  Moved codecpar field from AVStream to the end of the struct, so that
 +  the following private fields are in the same location as in FFmpeg 3.0 (lavf 57.25.100).
 +
 +2016-06-30 - 042fb69d - lavu 55.28.100 - frame.h
 +  Moved hw_frames_ctx field from AVFrame to the end of the struct, so that
 +  the following private fields are in the same location as in FFmpeg 3.0 (lavu 55.17.103).
 +
 +2016-06-29 - 1a751455 - lavfi 6.47.100 - avfilter.h
 +  Fix accidental ABI breakage in AVFilterContext.
 +  ABI was broken in 8688d3a, lavfi 6.42.100 and released as ffmpeg 3.1.
 +
 +  Because of this, ffmpeg and ffplay built against lavfi>=6.42.100 will not be
 +  compatible with lavfi>=6.47.100. Potentially also affects other users of
 +  libavfilter if they are using one of the affected fields.
 +
 +-------- 8< --------- FFmpeg 3.1 was cut here -------- 8< ---------
 +
 +2016-06-26 - 481f320 / 1c9e861 - lavu 55.27.100 / 55.13.0 - hwcontext.h
    Add av_hwdevice_ctx_create().
  
 -2016-xx-xx - xxxxxxx - lavc 57.19.1 - avcodec.h
 +2016-06-26 - b95534b / e47b8bb - lavc 57.48.101 / 57.19.1 - avcodec.h
    Adjust values for JPEG 2000 profiles.
  
 -2016-xx-xx - xxxxxxx - lavf 57.7.0 - avio.h
 +2016-06-23 - 5d75e46 / db7968b - lavf 57.40.100 / 57.7.0 - avio.h
    Add AVIODataMarkerType, write_data_type, ignore_boundary_point and
    avio_write_marker.
  
diff --cc libavutil/Makefile
index 1e06176,b10b4d2..7385ec2
--- a/libavutil/Makefile
+++ b/libavutil/Makefile
@@@ -154,18 -111,16 +155,20 @@@ OBJS-$(!HAVE_ATOMICS_NATIVE
  
  OBJS-$(CONFIG_CUDA)                     += hwcontext_cuda.o
  OBJS-$(CONFIG_DXVA2)                    += hwcontext_dxva2.o
+ OBJS-$(CONFIG_LIBMFX)                   += hwcontext_qsv.o
  OBJS-$(CONFIG_LZO)                      += lzo.o
 +OBJS-$(CONFIG_OPENCL)                   += opencl.o opencl_internal.o
  OBJS-$(CONFIG_VAAPI)                    += hwcontext_vaapi.o
  OBJS-$(CONFIG_VDPAU)                    += hwcontext_vdpau.o
  
  OBJS += $(COMPAT_OBJS:%=../compat/%)
  
 +# Windows resource file
 +SLIBOBJS-$(HAVE_GNU_WINDRES)            += avutilres.o
 +
  SKIPHEADERS-$(CONFIG_CUDA)             += hwcontext_cuda.h
  SKIPHEADERS-$(CONFIG_DXVA2)            += hwcontext_dxva2.h
+ SKIPHEADERS-$(CONFIG_LIBMFX)           += hwcontext_qsv.h
  SKIPHEADERS-$(CONFIG_VAAPI)            += hwcontext_vaapi.h
  SKIPHEADERS-$(CONFIG_VDPAU)            += hwcontext_vdpau.h
  SKIPHEADERS-$(HAVE_ATOMICS_GCC)        += atomic_gcc.h
diff --cc libavutil/hwcontext_qsv.c
index 0000000,b222da2..13be5b0
mode 000000,100644..100644
--- a/libavutil/hwcontext_qsv.c
+++ b/libavutil/hwcontext_qsv.c
@@@ -1,0 -1,791 +1,791 @@@
+ /*
 - * This file is part of Libav.
++ * This file is part of FFmpeg.
+  *
 - * Libav is free software; you can redistribute it and/or
++ * 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.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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 Libav; if not, write to the Free Software
++ * 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 --cc libavutil/hwcontext_qsv.h
index 0000000,8f9d3d2..b98d611
mode 000000,100644..100644
--- a/libavutil/hwcontext_qsv.h
+++ b/libavutil/hwcontext_qsv.h
@@@ -1,0 -1,53 +1,53 @@@
+ /*
 - * This file is part of Libav.
++ * This file is part of FFmpeg.
+  *
 - * Libav is free software; you can redistribute it and/or
++ * 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.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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 Libav; if not, write to the Free Software
++ * 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
+  * contain 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 */
+ 
diff --cc libavutil/version.h
index 42adf4f,d13794c..787ba58
--- a/libavutil/version.h
+++ b/libavutil/version.h
@@@ -78,9 -53,9 +78,9 @@@
   * @{
   */
  
 -#define LIBAVUTIL_VERSION_MAJOR 55
 -#define LIBAVUTIL_VERSION_MINOR 16
 -#define LIBAVUTIL_VERSION_MICRO  0
 +#define LIBAVUTIL_VERSION_MAJOR  55
- #define LIBAVUTIL_VERSION_MINOR  31
++#define LIBAVUTIL_VERSION_MINOR  32
 +#define LIBAVUTIL_VERSION_MICRO 100
  
  #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
                                                 LIBAVUTIL_VERSION_MINOR, \



More information about the ffmpeg-cvslog mailing list