@@ -14,6 +14,7 @@ version <next>:

 - native aptX encoder and decoder

 - Raw aptX muxer and demuxer

 - NVIDIA NVDEC-accelerated H.264 and HEVC hwaccel decoding

+- Intel QSV-accelerated overlay filter

 version 3.4:

@@ -2196,6 +2196,7 @@ CONFIG_EXTRA="

     qsv

     qsvdec

     qsvenc

+    qsvvpp

     rangecoder

     riffdec

     riffenc

@@ -2783,6 +2784,7 @@ omx_rpi_select="omx"

 qsv_deps="libmfx"

 qsvdec_select="qsv"

 qsvenc_select="qsv"

+qsvvpp_select="qsv"

 vaapi_encode_deps="vaapi"

 v4l2_m2m_deps_any="linux_videodev2_h"

@@ -3228,6 +3230,8 @@ negate_filter_deps="lut_filter"

 nnedi_filter_deps="gpl"

 ocr_filter_deps="libtesseract"

 ocv_filter_deps="libopencv"

+overlay_qsv_filter_deps="libmfx"

+overlay_qsv_filter_select="qsvvpp"

 owdenoise_filter_deps="gpl"

 pan_filter_deps="swresample"

 perspective_filter_deps="gpl"

@@ -3279,6 +3283,8 @@ zmq_filter_deps="libzmq"

 zoompan_filter_deps="swscale"

 zscale_filter_deps="libzimg const_nan"

 scale_vaapi_filter_deps="vaapi VAProcPipelineParameterBuffer"

+vpp_qsv_filter_deps="libmfx"

+vpp_qsv_filter_select="qsvvpp"

 # examples

 avio_dir_cmd_deps="avformat avutil"

@@ -25,6 +25,9 @@ OBJS = allfilters.o                                                     \

 OBJS-$(HAVE_THREADS)                         += pthread.o

+# subsystems

+OBJS-$(CONFIG_QSVVPP)                        += qsvvpp.o

+

 # audio filters

 OBJS-$(CONFIG_ABENCH_FILTER)                 += f_bench.o

 OBJS-$(CONFIG_ACOMPRESSOR_FILTER)            += af_sidechaincompress.o

@@ -248,6 +251,7 @@ OBJS-$(CONFIG_OCV_FILTER)                    += vf_libopencv.o

 OBJS-$(CONFIG_OPENCL)                        += deshake_opencl.o unsharp_opencl.o

 OBJS-$(CONFIG_OSCILLOSCOPE_FILTER)           += vf_datascope.o

 OBJS-$(CONFIG_OVERLAY_FILTER)                += vf_overlay.o framesync.o

+OBJS-$(CONFIG_OVERLAY_QSV_FILTER)            += vf_overlay_qsv.o

 OBJS-$(CONFIG_OWDENOISE_FILTER)              += vf_owdenoise.o

 OBJS-$(CONFIG_PAD_FILTER)                    += vf_pad.o

 OBJS-$(CONFIG_PALETTEGEN_FILTER)             += vf_palettegen.o

@@ -331,6 +335,7 @@ OBJS-$(CONFIG_VIDSTABDETECT_FILTER)          += vidstabutils.o vf_vidstabdetect.

 OBJS-$(CONFIG_VIDSTABTRANSFORM_FILTER)       += vidstabutils.o vf_vidstabtransform.o

 OBJS-$(CONFIG_VIGNETTE_FILTER)               += vf_vignette.o

 OBJS-$(CONFIG_VMAFMOTION_FILTER)             += vf_vmafmotion.o framesync.o

+OBJS-$(CONFIG_VPP_QSV_FILTER)                += vf_vpp_qsv.o

 OBJS-$(CONFIG_VSTACK_FILTER)                 += vf_stack.o framesync.o

 OBJS-$(CONFIG_W3FDIF_FILTER)                 += vf_w3fdif.o

 OBJS-$(CONFIG_WAVEFORM_FILTER)               += vf_waveform.o

@@ -389,6 +394,8 @@ SKIPHEADERS-$(CONFIG_OPENCL)                 += opencl_internal.h deshake_opencl

 OBJS-$(CONFIG_SHARED)                        += log2_tab.o

+SKIPHEADERS-$(CONFIG_QSVVPP)                 += qsvvpp.h

+

 TOOLS     = graph2dot

 TESTPROGS = drawutils filtfmts formats integral

@@ -260,6 +260,7 @@ static void register_all(void)

     REGISTER_FILTER(OCV,            ocv,            vf);

     REGISTER_FILTER(OSCILLOSCOPE,   oscilloscope,   vf);

     REGISTER_FILTER(OVERLAY,        overlay,        vf);

+    REGISTER_FILTER(OVERLAY_QSV,    overlay_qsv,    vf);

     REGISTER_FILTER(OWDENOISE,      owdenoise,      vf);

     REGISTER_FILTER(PAD,            pad,            vf);

     REGISTER_FILTER(PALETTEGEN,     palettegen,     vf);

@@ -343,6 +344,7 @@ static void register_all(void)

     REGISTER_FILTER(VIDSTABTRANSFORM, vidstabtransform, vf);

     REGISTER_FILTER(VIGNETTE,       vignette,       vf);

     REGISTER_FILTER(VMAFMOTION,     vmafmotion,     vf);

+    REGISTER_FILTER(VPP_QSV,        vpp_qsv,        vf);

     REGISTER_FILTER(VSTACK,         vstack,         vf);

     REGISTER_FILTER(W3FDIF,         w3fdif,         vf);

     REGISTER_FILTER(WAVEFORM,       waveform,       vf);

new file mode 100644

@@ -0,0 +1,727 @@

+/*

+ * 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

+ */

+

+/**

+ * @file

+ * Intel Quick Sync Video VPP base function

+ */

+

+#include "libavutil/common.h"

+#include "libavutil/mathematics.h"

+#include "libavutil/hwcontext.h"

+#include "libavutil/hwcontext_qsv.h"

+#include "libavutil/time.h"

+#include "libavutil/pixdesc.h"

+

+#include "internal.h"

+#include "qsvvpp.h"

+#include "video.h"

+

+#define IS_VIDEO_MEMORY(mode)  (mode & (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | \

+                                        MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))

+#define IS_OPAQUE_MEMORY(mode) (mode & MFX_MEMTYPE_OPAQUE_FRAME)

+#define IS_SYSTEM_MEMORY(mode) (mode & MFX_MEMTYPE_SYSTEM_MEMORY)

+

+typedef struct QSVFrame {

+    AVFrame          *frame;

+    mfxFrameSurface1 *surface;

+    mfxFrameSurface1  surface_internal;  /* for system memory */

+    struct QSVFrame  *next;

+} QSVFrame;

+

+/* abstract struct for all QSV filters */

+struct QSVVPPContext {

+    mfxSession          session;

+    int (*filter_frame) (AVFilterLink *outlink, AVFrame *frame);/* callback */

+    enum AVPixelFormat  out_sw_format;   /* Real output format */

+    mfxVideoParam       vpp_param;

+    mfxFrameInfo       *frame_infos;     /* frame info for each input */

+

+    /* members related to the input/output surface */

+    int                 in_mem_mode;

+    int                 out_mem_mode;

+    QSVFrame           *in_frame_list;

+    QSVFrame           *out_frame_list;

+    int                 nb_surface_ptrs_in;

+    int                 nb_surface_ptrs_out;

+    mfxFrameSurface1  **surface_ptrs_in;

+    mfxFrameSurface1  **surface_ptrs_out;

+

+    /* MFXVPP extern parameters */

+    mfxExtOpaqueSurfaceAlloc opaque_alloc;

+    mfxExtBuffer      **ext_buffers;

+    int                 nb_ext_buffers;

+};

+

+static const mfxHandleType handle_types[] = {

+    MFX_HANDLE_VA_DISPLAY,

+    MFX_HANDLE_D3D9_DEVICE_MANAGER,

+    MFX_HANDLE_D3D11_DEVICE,

+};

+

+static const AVRational default_tb = { 1, 90000 };

+

+/* functions for frameAlloc */

+static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req,

+                             mfxFrameAllocResponse *resp)

+{

+    QSVVPPContext *s = pthis;

+    int i;

+

+    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 (req->Type & MFX_MEMTYPE_FROM_VPPIN) {

+        resp->mids = av_mallocz(s->nb_surface_ptrs_in * sizeof(*resp->mids));

+        if (!resp->mids)

+            return AVERROR(ENOMEM);

+

+        for (i = 0; i < s->nb_surface_ptrs_in; i++)

+            resp->mids[i] = s->surface_ptrs_in[i]->Data.MemId;

+

+        resp->NumFrameActual = s->nb_surface_ptrs_in;

+    } else {

+        resp->mids = av_mallocz(s->nb_surface_ptrs_out * sizeof(*resp->mids));

+        if (!resp->mids)

+            return AVERROR(ENOMEM);

+

+        for (i = 0; i < s->nb_surface_ptrs_out; i++)

+            resp->mids[i] = s->surface_ptrs_out[i]->Data.MemId;

+

+        resp->NumFrameActual = s->nb_surface_ptrs_out;

+    }

+

+    return MFX_ERR_NONE;

+}

+

+static mfxStatus frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)

+{

+    av_freep(&resp->mids);

+    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 pix_fmt_to_mfx_fourcc(int format)

+{

+    switch (format) {

+    case AV_PIX_FMT_YUV420P:

+        return MFX_FOURCC_YV12;

+    case AV_PIX_FMT_NV12:

+        return MFX_FOURCC_NV12;

+    case AV_PIX_FMT_YUYV422:

+        return MFX_FOURCC_YUY2;

+    case AV_PIX_FMT_RGB32:

+        return MFX_FOURCC_RGB4;

+    }

+

+    return MFX_FOURCC_NV12;

+}

+

+static int map_frame_to_surface(AVFrame *frame, mfxFrameSurface1 *surface)

+{

+    switch (frame->format) {

+    case AV_PIX_FMT_NV12:

+        surface->Data.Y  = frame->data[0];

+        surface->Data.UV = frame->data[1];

+        break;

+    case AV_PIX_FMT_YUV420P:

+        surface->Data.Y = frame->data[0];

+        surface->Data.U = frame->data[1];

+        surface->Data.V = frame->data[2];

+        break;

+    case AV_PIX_FMT_YUYV422:

+        surface->Data.Y = frame->data[0];

+        surface->Data.U = frame->data[0] + 1;

+        surface->Data.V = frame->data[0] + 3;

+        break;

+    case AV_PIX_FMT_RGB32:

+        surface->Data.B = frame->data[0];

+        surface->Data.G = frame->data[0] + 1;

+        surface->Data.R = frame->data[0] + 2;

+        surface->Data.A = frame->data[0] + 3;

+        break;

+    default:

+        return MFX_ERR_UNSUPPORTED;

+    }

+    surface->Data.Pitch = frame->linesize[0];

+

+    return 0;

+}

+

+/* fill the surface info */

+static int fill_frameinfo_by_link(mfxFrameInfo *frameinfo, AVFilterLink *link)

+{

+    enum AVPixelFormat        pix_fmt;

+    AVHWFramesContext        *frames_ctx;

+    AVQSVFramesContext       *frames_hwctx;

+    const AVPixFmtDescriptor *desc;

+

+    if (link->format == AV_PIX_FMT_QSV) {

+        if (!link->hw_frames_ctx)

+            return AVERROR(EINVAL);

+

+        frames_ctx   = (AVHWFramesContext *)link->hw_frames_ctx->data;

+        frames_hwctx = frames_ctx->hwctx;

+        *frameinfo   = frames_hwctx->surfaces[0].Info;

+    } else {

+        pix_fmt = link->format;

+        desc = av_pix_fmt_desc_get(pix_fmt);

+        if (!desc)

+            return AVERROR_BUG;

+

+        frameinfo->CropX          = 0;

+        frameinfo->CropY          = 0;

+        frameinfo->Width          = FFALIGN(link->w, 32);

+        frameinfo->Height         = FFALIGN(link->h, 32);

+        frameinfo->PicStruct      = MFX_PICSTRUCT_PROGRESSIVE;

+        frameinfo->FourCC         = pix_fmt_to_mfx_fourcc(pix_fmt);

+        frameinfo->BitDepthLuma   = desc->comp[0].depth;

+        frameinfo->BitDepthChroma = desc->comp[0].depth;

+        frameinfo->Shift          = desc->comp[0].depth > 8;

+        if (desc->log2_chroma_w && desc->log2_chroma_h)

+            frameinfo->ChromaFormat = MFX_CHROMAFORMAT_YUV420;

+        else if (desc->log2_chroma_w)

+            frameinfo->ChromaFormat = MFX_CHROMAFORMAT_YUV422;

+        else

+            frameinfo->ChromaFormat = MFX_CHROMAFORMAT_YUV444;

+    }

+

+    frameinfo->CropW          = link->w;

+    frameinfo->CropH          = link->h;

+    frameinfo->FrameRateExtN  = link->frame_rate.num;

+    frameinfo->FrameRateExtD  = link->frame_rate.den;

+    frameinfo->AspectRatioW   = link->sample_aspect_ratio.num ? link->sample_aspect_ratio.num : 1;

+    frameinfo->AspectRatioH   = link->sample_aspect_ratio.den ? link->sample_aspect_ratio.den : 1;

+

+    return 0;

+}

+

+static void clear_unused_frames(QSVFrame *list)

+{

+    while (list) {

+        if (list->surface && !list->surface->Data.Locked) {

+            list->surface = NULL;

+            av_frame_free(&list->frame);

+        }

+        list = list->next;

+    }

+}

+

+static void clear_frame_list(QSVFrame **list)

+{

+    while (*list) {

+        QSVFrame *frame;

+

+        frame = *list;

+        *list = (*list)->next;

+        av_frame_free(&frame->frame);

+        av_freep(&frame);

+    }

+}

+

+static QSVFrame *get_free_frame(QSVFrame **list)

+{

+    QSVFrame *out = *list;

+

+    for (; out; out = out->next) {

+        if (!out->surface)

+            break;

+    }

+

+    if (!out) {

+        out = av_mallocz(sizeof(*out));

+        if (!out) {

+            av_log(NULL, AV_LOG_ERROR, "Can't alloc new output frame.\n");

+            return NULL;

+        }

+        out->next  = *list;

+        *list      = out;

+    }

+

+    return out;

+}

+

+/* get the input surface */

+static QSVFrame *submit_frame(QSVVPPContext *s, AVFilterLink *inlink, AVFrame *picref)

+{

+    QSVFrame        *qsv_frame;

+    AVFilterContext *ctx = inlink->dst;

+

+    clear_unused_frames(s->in_frame_list);

+

+    qsv_frame = get_free_frame(&s->in_frame_list);

+    if (!qsv_frame)

+        return NULL;

+

+    /* Turn AVFrame into mfxFrameSurface1.

+     * For video/opaque memory mode, pix_fmt is AV_PIX_FMT_QSV, and

+     * mfxFrameSurface1 is stored in AVFrame->data[3];

+     * for system memory mode, raw video data is stored in

+     * AVFrame, we should map it into mfxFrameSurface1.

+     */

+    if (!IS_SYSTEM_MEMORY(s->in_mem_mode)) {

+        if (picref->format != AV_PIX_FMT_QSV) {

+            av_log(ctx, AV_LOG_ERROR, "QSVVPP gets a wrong frame.\n");

+            return NULL;

+        }

+        qsv_frame->frame   = picref;

+        qsv_frame->surface = (mfxFrameSurface1 *)qsv_frame->frame->data[3];

+    } else {

+        /* make a copy if the input is not padded as libmfx requires */

+        if (picref->height & 31 || picref->linesize[0] & 31) {

+            qsv_frame->frame = ff_get_video_buffer(inlink,

+                                                   FFALIGN(inlink->w, 32),

+                                                   FFALIGN(inlink->h, 32));

+            if (!qsv_frame->frame)

+                return NULL;

+

+            qsv_frame->frame->width   = picref->width;

+            qsv_frame->frame->height  = picref->height;

+

+            if (av_frame_copy(qsv_frame->frame, picref) < 0) {

+                av_frame_free(&qsv_frame->frame);

+                return NULL;

+            }

+

+            av_frame_copy_props(qsv_frame->frame, picref);

+            av_frame_free(&picref);

+        } else

+            qsv_frame->frame = picref;

+

+        if (map_frame_to_surface(qsv_frame->frame,

+                                &qsv_frame->surface_internal) < 0) {

+            av_log(ctx, AV_LOG_ERROR, "Unsupported frame.\n");

+            return NULL;

+        }

+        qsv_frame->surface = &qsv_frame->surface_internal;

+    }

+

+    qsv_frame->surface->Info           = s->frame_infos[FF_INLINK_IDX(inlink)];

+    qsv_frame->surface->Data.TimeStamp = av_rescale_q(qsv_frame->frame->pts,

+                                                      inlink->time_base, default_tb);

+

+    qsv_frame->surface->Info.PicStruct =

+            !qsv_frame->frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :

+            (qsv_frame->frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF :

+                                                 MFX_PICSTRUCT_FIELD_BFF);

+    if (qsv_frame->frame->repeat_pict == 1)

+        qsv_frame->surface->Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;

+    else if (qsv_frame->frame->repeat_pict == 2)

+        qsv_frame->surface->Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;

+    else if (qsv_frame->frame->repeat_pict == 4)

+        qsv_frame->surface->Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;

+

+    return qsv_frame;

+}

+

+/* get the output surface */

+static QSVFrame *query_frame(QSVVPPContext *s, AVFilterLink *outlink)

+{

+    AVFilterContext *ctx = outlink->src;

+    QSVFrame        *out_frame;

+    int              ret;

+

+    clear_unused_frames(s->out_frame_list);

+

+    out_frame = get_free_frame(&s->out_frame_list);

+    if (!out_frame)

+        return NULL;

+

+    /* For video memory, get a hw frame;

+     * For system memory, get a sw frame and map it into a mfx_surface. */

+    if (!IS_SYSTEM_MEMORY(s->out_mem_mode)) {

+        out_frame->frame = av_frame_alloc();

+        if (!out_frame->frame)

+            return NULL;

+

+        ret = av_hwframe_get_buffer(outlink->hw_frames_ctx, out_frame->frame, 0);

+        if (ret < 0) {

+            av_log(ctx, AV_LOG_ERROR, "Can't allocate a surface.\n");

+            return NULL;

+        }

+

+        out_frame->surface = (mfxFrameSurface1 *)out_frame->frame->data[3];

+    } else {

+        /* Get a frame with aligned dimensions.

+         * Libmfx need system memory being 128x64 aligned */

+        out_frame->frame = ff_get_video_buffer(outlink,

+                                               FFALIGN(outlink->w, 128),

+                                               FFALIGN(outlink->h, 64));

+        if (!out_frame->frame)

+            return NULL;

+

+        out_frame->frame->width  = outlink->w;

+        out_frame->frame->height = outlink->h;

+

+        ret = map_frame_to_surface(out_frame->frame,

+                                  &out_frame->surface_internal);

+        if (ret < 0)

+            return NULL;

+

+        out_frame->surface = &out_frame->surface_internal;

+    }

+

+    out_frame->surface->Info = s->vpp_param.vpp.Out;

+

+    return out_frame;

+}

+

+/* create the QSV session */

+static int init_vpp_session(AVFilterContext *avctx, QSVVPPContext *s)

+{

+    AVFilterLink                 *inlink = avctx->inputs[0];

+    AVFilterLink                *outlink = avctx->outputs[0];

+    AVQSVFramesContext  *in_frames_hwctx = NULL;

+    AVQSVFramesContext *out_frames_hwctx = NULL;

+

+    AVBufferRef *device_ref;

+    AVHWDeviceContext *device_ctx;

+    AVQSVDeviceContext *device_hwctx;

+    mfxHDL handle;

+    mfxHandleType handle_type;

+    mfxVersion ver;

+    mfxIMPL impl;

+    int ret, i;

+

+    if (inlink->hw_frames_ctx) {

+        AVHWFramesContext *frames_ctx = (AVHWFramesContext *)inlink->hw_frames_ctx->data;

+

+        device_ref      = frames_ctx->device_ref;

+        in_frames_hwctx = frames_ctx->hwctx;

+

+        s->in_mem_mode = in_frames_hwctx->frame_type;

+

+        s->surface_ptrs_in = av_mallocz_array(in_frames_hwctx->nb_surfaces,

+                                              sizeof(*s->surface_ptrs_in));

+        if (!s->surface_ptrs_in)

+            return AVERROR(ENOMEM);

+

+        for (i = 0; i < in_frames_hwctx->nb_surfaces; i++)

+            s->surface_ptrs_in[i] = in_frames_hwctx->surfaces + i;

+

+        s->nb_surface_ptrs_in = in_frames_hwctx->nb_surfaces;

+    } else if (avctx->hw_device_ctx) {

+        device_ref     = avctx->hw_device_ctx;

+        s->in_mem_mode = MFX_MEMTYPE_SYSTEM_MEMORY;

+    } else {

+        av_log(avctx, AV_LOG_ERROR, "No hw context provided.\n");

+        return AVERROR(EINVAL);

+    }

+

+    device_ctx   = (AVHWDeviceContext *)device_ref->data;

+    device_hwctx = device_ctx->hwctx;

+

+    if (outlink->format == AV_PIX_FMT_QSV) {

+        AVHWFramesContext *out_frames_ctx;

+        AVBufferRef *out_frames_ref = av_hwframe_ctx_alloc(device_ref);

+        if (!out_frames_ref)

+            return AVERROR(ENOMEM);

+

+        s->out_mem_mode = IS_OPAQUE_MEMORY(s->in_mem_mode) ?

+                          MFX_MEMTYPE_OPAQUE_FRAME :

+                          MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;

+

+        out_frames_ctx   = (AVHWFramesContext *)out_frames_ref->data;

+        out_frames_hwctx = out_frames_ctx->hwctx;

+

+        out_frames_ctx->format            = AV_PIX_FMT_QSV;

+        out_frames_ctx->width             = FFALIGN(outlink->w, 32);

+        out_frames_ctx->height            = FFALIGN(outlink->h, 32);

+        out_frames_ctx->sw_format         = s->out_sw_format;

+        out_frames_ctx->initial_pool_size = 64;

+        out_frames_hwctx->frame_type      = s->out_mem_mode;

+

+        ret = av_hwframe_ctx_init(out_frames_ref);

+        if (ret < 0) {

+            av_buffer_unref(&out_frames_ref);

+            av_log(avctx, AV_LOG_ERROR, "Error creating frames_ctx for output pad.\n");

+            return ret;

+        }

+

+        s->surface_ptrs_out = av_mallocz_array(out_frames_hwctx->nb_surfaces,

+                                               sizeof(*s->surface_ptrs_out));

+        if (!s->surface_ptrs_out) {

+            av_buffer_unref(&out_frames_ref);

+            return AVERROR(ENOMEM);

+        }

+

+        for (i = 0; i < out_frames_hwctx->nb_surfaces; i++)

+            s->surface_ptrs_out[i] = out_frames_hwctx->surfaces + i;

+        s->nb_surface_ptrs_out = out_frames_hwctx->nb_surfaces;

+

+        av_buffer_unref(&outlink->hw_frames_ctx);

+        outlink->hw_frames_ctx = out_frames_ref;

+    } else

+        s->out_mem_mode = MFX_MEMTYPE_SYSTEM_MEMORY;

+

+    /* extract the properties of the "master" session given to us */

+    ret = MFXQueryIMPL(device_hwctx->session, &impl);

+    if (ret == MFX_ERR_NONE)

+        ret = MFXQueryVersion(device_hwctx->session, &ver);

+    if (ret != MFX_ERR_NONE) {

+        av_log(avctx, AV_LOG_ERROR, "Error querying the session attributes\n");

+        return AVERROR_UNKNOWN;

+    }

+

+    for (i = 0; i < FF_ARRAY_ELEMS(handle_types); i++) {

+        ret = MFXVideoCORE_GetHandle(device_hwctx->session, handle_types[i], &handle);

+        if (ret == MFX_ERR_NONE) {

+            handle_type = handle_types[i];

+            break;

+        }

+    }

+

+    /* create a "slave" session with those same properties, to be used for vpp */

+    ret = MFXInit(impl, &ver, &s->session);

+    if (ret != MFX_ERR_NONE) {

+        av_log(avctx, AV_LOG_ERROR, "Error initializing a session for scaling\n");

+        return AVERROR_UNKNOWN;

+    }

+

+    if (handle) {

+        ret = MFXVideoCORE_SetHandle(s->session, handle_type, handle);

+        if (ret != MFX_ERR_NONE)

+            return AVERROR_UNKNOWN;

+    }

+

+    if (IS_OPAQUE_MEMORY(s->in_mem_mode) || IS_OPAQUE_MEMORY(s->out_mem_mode)) {

+        s->opaque_alloc.In.Surfaces   = s->surface_ptrs_in;

+        s->opaque_alloc.In.NumSurface = s->nb_surface_ptrs_in;

+        s->opaque_alloc.In.Type       = s->in_mem_mode;

+

+        s->opaque_alloc.Out.Surfaces   = s->surface_ptrs_out;

+        s->opaque_alloc.Out.NumSurface = s->nb_surface_ptrs_out;

+        s->opaque_alloc.Out.Type       = s->out_mem_mode;

+

+        s->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;

+        s->opaque_alloc.Header.BufferSz = sizeof(s->opaque_alloc);

+    } else if (IS_VIDEO_MEMORY(s->in_mem_mode) || IS_VIDEO_MEMORY(s->out_mem_mode)) {

+        mfxFrameAllocator frame_allocator = {

+            .pthis  = s,

+            .Alloc  = frame_alloc,

+            .Lock   = frame_lock,

+            .Unlock = frame_unlock,

+            .GetHDL = frame_get_hdl,

+            .Free   = frame_free,

+        };

+

+        ret = MFXVideoCORE_SetFrameAllocator(s->session, &frame_allocator);

+        if (ret != MFX_ERR_NONE)

+            return AVERROR_UNKNOWN;

+    }

+

+    return 0;

+}

+

+int ff_qsvvpp_create(AVFilterContext *avctx, QSVVPPContext **vpp, QSVVPPParam *param)

+{

+    int i;

+    int ret;

+    QSVVPPContext *s;

+

+    s = av_mallocz(sizeof(*s));

+    if (!s)

+        return AVERROR(ENOMEM);

+

+    s->filter_frame  = param->filter_frame;

+    if (!s->filter_frame)

+        s->filter_frame = ff_filter_frame;

+    s->out_sw_format = param->out_sw_format;

+

+    /* create the vpp session */

+    ret = init_vpp_session(avctx, s);

+    if (ret < 0)

+        goto failed;

+

+    s->frame_infos = av_mallocz_array(avctx->nb_inputs, sizeof(*s->frame_infos));

+    if (!s->frame_infos) {

+        ret = AVERROR(ENOMEM);

+        goto failed;

+    }

+

+    /* Init each input's information */

+    for (i = 0; i < avctx->nb_inputs; i++) {

+        ret = fill_frameinfo_by_link(&s->frame_infos[i], avctx->inputs[i]);

+        if (ret < 0)

+            goto failed;

+    }

+

+    /* Update input's frame info according to crop */

+    for (i = 0; i < param->num_crop; i++) {

+        QSVVPPCrop *crop = param->crop + i;

+        if (crop->in_idx > avctx->nb_inputs) {

+            ret = AVERROR(EINVAL);

+            goto failed;

+        }

+        s->frame_infos[crop->in_idx].CropX = crop->x;

+        s->frame_infos[crop->in_idx].CropY = crop->y;

+        s->frame_infos[crop->in_idx].CropW = crop->w;

+        s->frame_infos[crop->in_idx].CropH = crop->h;

+    }

+

+    s->vpp_param.vpp.In = s->frame_infos[0];

+

+    ret = fill_frameinfo_by_link(&s->vpp_param.vpp.Out, avctx->outputs[0]);

+    if (ret < 0) {

+        av_log(avctx, AV_LOG_ERROR, "Fail to get frame info from link.\n");

+        goto failed;

+    }

+

+    if (IS_OPAQUE_MEMORY(s->in_mem_mode) || IS_OPAQUE_MEMORY(s->out_mem_mode)) {

+        s->nb_ext_buffers = param->num_ext_buf + 1;

+        s->ext_buffers = av_mallocz_array(s->nb_ext_buffers, sizeof(*s->ext_buffers));

+        if (!s->ext_buffers) {

+            ret = AVERROR(ENOMEM);

+            goto failed;

+        }

+

+        s->ext_buffers[0] = (mfxExtBuffer *)&s->opaque_alloc;

+        for (i = 1; i < param->num_ext_buf; i++)

+            s->ext_buffers[i]    = param->ext_buf[i - 1];

+        s->vpp_param.ExtParam    = s->ext_buffers;

+        s->vpp_param.NumExtParam = s->nb_ext_buffers;

+    } else {

+        s->vpp_param.NumExtParam = param->num_ext_buf;

+        s->vpp_param.ExtParam    = param->ext_buf;

+    }

+

+    s->vpp_param.AsyncDepth = 1;

+

+    if (IS_SYSTEM_MEMORY(s->in_mem_mode))

+        s->vpp_param.IOPattern |= MFX_IOPATTERN_IN_SYSTEM_MEMORY;

+    else if (IS_VIDEO_MEMORY(s->in_mem_mode))

+        s->vpp_param.IOPattern |= MFX_IOPATTERN_IN_VIDEO_MEMORY;

+    else if (IS_OPAQUE_MEMORY(s->in_mem_mode))

+        s->vpp_param.IOPattern |= MFX_IOPATTERN_IN_OPAQUE_MEMORY;

+

+    if (IS_SYSTEM_MEMORY(s->out_mem_mode))

+        s->vpp_param.IOPattern |= MFX_IOPATTERN_OUT_SYSTEM_MEMORY;

+    else if (IS_VIDEO_MEMORY(s->out_mem_mode))

+        s->vpp_param.IOPattern |= MFX_IOPATTERN_OUT_VIDEO_MEMORY;

+    else if (IS_OPAQUE_MEMORY(s->out_mem_mode))

+        s->vpp_param.IOPattern |= MFX_IOPATTERN_OUT_OPAQUE_MEMORY;

+

+    ret = MFXVideoVPP_Init(s->session, &s->vpp_param);

+    if (ret < 0) {

+        av_log(avctx, AV_LOG_ERROR, "Failed to create a qsvvpp, ret = %d.\n", ret);

+        goto failed;

+    }

+

+    *vpp = s;

+    return 0;

+

+failed:

+    ff_qsvvpp_free(&s);

+

+    return ret;

+}

+

+int ff_qsvvpp_free(QSVVPPContext **vpp)

+{

+    QSVVPPContext *s = *vpp;

+

+    if (!s)

+        return 0;

+

+    if (s->session) {

+        MFXVideoVPP_Close(s->session);

+        MFXClose(s->session);

+    }

+

+    /* release all the resources */

+    clear_frame_list(&s->in_frame_list);

+    clear_frame_list(&s->out_frame_list);

+    av_freep(&s->surface_ptrs_in);

+    av_freep(&s->surface_ptrs_out);

+    av_freep(&s->ext_buffers);

+    av_freep(&s->frame_infos);

+    av_freep(vpp);

+

+    return 0;

+}

+

+int ff_qsvvpp_filter_frame(QSVVPPContext *s, AVFilterLink *inlink, AVFrame *picref)

+{

+    AVFilterContext  *ctx     = inlink->dst;

+    AVFilterLink     *outlink = ctx->outputs[0];

+    mfxSyncPoint      sync;

+    QSVFrame         *in_frame, *out_frame;

+    int               ret, filter_ret;

+

+    in_frame = submit_frame(s, inlink, picref);

+    if (!in_frame) {

+        av_log(ctx, AV_LOG_ERROR, "Failed to submit frame on input[%d]\n",

+               FF_INLINK_IDX(inlink));

+        return AVERROR(ENOMEM);

+    }

+

+    do {

+        out_frame = query_frame(s, outlink);

+        if (!out_frame) {

+            av_log(ctx, AV_LOG_ERROR, "Failed to query an output frame.\n");

+            return AVERROR(ENOMEM);

+        }

+

+        do {

+            ret = MFXVideoVPP_RunFrameVPPAsync(s->session, in_frame->surface,

+                                               out_frame->surface, NULL, &sync);

+            if (ret == MFX_WRN_DEVICE_BUSY)

+                av_usleep(500);

+        } while (ret == MFX_WRN_DEVICE_BUSY);

+

+        if (ret < 0 && ret != MFX_ERR_MORE_SURFACE) {

+            /* Ignore more_data error */

+            if (ret == MFX_ERR_MORE_DATA)

+                ret = AVERROR(EAGAIN);

+            break;

+        }

+

+        if (MFXVideoCORE_SyncOperation(s->session, sync, 1000) < 0)

+            av_log(ctx, AV_LOG_WARNING, "Sync failed.\n");

+

+        out_frame->frame->pts = av_rescale_q(out_frame->surface->Data.TimeStamp,

+                                             default_tb, outlink->time_base);

+

+        filter_ret = s->filter_frame(outlink, out_frame->frame);

+        if (filter_ret < 0) {

+            av_frame_free(&out_frame->frame);

+            ret = filter_ret;

+            break;

+        }

+        out_frame->frame = NULL;

+    } while(ret == MFX_ERR_MORE_SURFACE);

+

+    return ret;

+}

new file mode 100644

@@ -0,0 +1,66 @@

+/*

+ * 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

+ */

+

+/**

+ * @file

+ * Intel Quick Sync Video VPP base function

+ */

+

+#ifndef AVFILTER_QSVVPP_H

+#define AVFILTER_QSVVPP_H

+

+#include <mfx/mfxvideo.h>

+

+#include "avfilter.h"

+

+#define FF_INLINK_IDX(link)  ((int)((link)->dstpad - (link)->dst->input_pads))

+#define FF_OUTLINK_IDX(link) ((int)((link)->srcpad - (link)->src->output_pads))

+

+typedef struct QSVVPPContext QSVVPPContext;

+

+typedef struct QSVVPPCrop {

+    int in_idx;        ///< Input index

+    int x, y, w, h;    ///< Crop rectangle

+} QSVVPPCrop;

+

+typedef struct QSVVPPParam {

+    /* default is ff_filter_frame */

+    int (*filter_frame)(AVFilterLink *outlink, AVFrame *frame);

+

+    /* To fill with MFX enhanced filter configurations */

+    int num_ext_buf;

+    mfxExtBuffer **ext_buf;

+

+    /* Real output format */

+    enum AVPixelFormat out_sw_format;

+

+    /* Crop information for each input, if needed */

+    int num_crop;