X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavfilter%2Fqsvvpp.c;h=4768f6208b47a8ebd84e9e1c7a4a28906c325072;hb=7b6012efaae549b8e624876dba9550cb003f98b1;hp=06efdf50891d006fa5e93345da186388bd125e16;hpb=f32d2939555706365ad1d39aadd5ee7ce1d9fa4f;p=ffmpeg diff --git a/libavfilter/qsvvpp.c b/libavfilter/qsvvpp.c index 06efdf50891..4768f6208b4 100644 --- a/libavfilter/qsvvpp.c +++ b/libavfilter/qsvvpp.c @@ -37,37 +37,6 @@ #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, @@ -76,6 +45,110 @@ static const mfxHandleType handle_types[] = { static const AVRational default_tb = { 1, 90000 }; +static const struct { + int mfx_iopattern; + const char *desc; +} qsv_iopatterns[] = { + {MFX_IOPATTERN_IN_VIDEO_MEMORY, "input is video memory surface" }, + {MFX_IOPATTERN_IN_SYSTEM_MEMORY, "input is system memory surface" }, + {MFX_IOPATTERN_IN_OPAQUE_MEMORY, "input is opaque memory surface" }, + {MFX_IOPATTERN_OUT_VIDEO_MEMORY, "output is video memory surface" }, + {MFX_IOPATTERN_OUT_SYSTEM_MEMORY, "output is system memory surface" }, + {MFX_IOPATTERN_OUT_OPAQUE_MEMORY, "output is opaque memory surface" }, +}; + +int ff_qsvvpp_print_iopattern(void *log_ctx, int mfx_iopattern, + const char *extra_string) +{ + const char *desc = NULL; + + for (int i = 0; i < FF_ARRAY_ELEMS(qsv_iopatterns); i++) { + if (qsv_iopatterns[i].mfx_iopattern == mfx_iopattern) { + desc = qsv_iopatterns[i].desc; + } + } + if (!desc) + desc = "unknown iopattern"; + + av_log(log_ctx, AV_LOG_VERBOSE, "%s: %s\n", extra_string, desc); + return 0; +} + +static const struct { + mfxStatus mfxerr; + int averr; + const char *desc; +} qsv_errors[] = { + { MFX_ERR_NONE, 0, "success" }, + { MFX_ERR_UNKNOWN, AVERROR_UNKNOWN, "unknown error" }, + { MFX_ERR_NULL_PTR, AVERROR(EINVAL), "NULL pointer" }, + { MFX_ERR_UNSUPPORTED, AVERROR(ENOSYS), "unsupported" }, + { MFX_ERR_MEMORY_ALLOC, AVERROR(ENOMEM), "failed to allocate memory" }, + { MFX_ERR_NOT_ENOUGH_BUFFER, AVERROR(ENOMEM), "insufficient input/output buffer" }, + { MFX_ERR_INVALID_HANDLE, AVERROR(EINVAL), "invalid handle" }, + { MFX_ERR_LOCK_MEMORY, AVERROR(EIO), "failed to lock the memory block" }, + { MFX_ERR_NOT_INITIALIZED, AVERROR_BUG, "not initialized" }, + { MFX_ERR_NOT_FOUND, AVERROR(ENOSYS), "specified object was not found" }, + /* the following 3 errors should always be handled explicitly, so those "mappings" + * are for completeness only */ + { MFX_ERR_MORE_DATA, AVERROR_UNKNOWN, "expect more data at input" }, + { MFX_ERR_MORE_SURFACE, AVERROR_UNKNOWN, "expect more surface at output" }, + { MFX_ERR_MORE_BITSTREAM, AVERROR_UNKNOWN, "expect more bitstream at output" }, + { MFX_ERR_ABORTED, AVERROR_UNKNOWN, "operation aborted" }, + { MFX_ERR_DEVICE_LOST, AVERROR(EIO), "device lost" }, + { MFX_ERR_INCOMPATIBLE_VIDEO_PARAM, AVERROR(EINVAL), "incompatible video parameters" }, + { MFX_ERR_INVALID_VIDEO_PARAM, AVERROR(EINVAL), "invalid video parameters" }, + { MFX_ERR_UNDEFINED_BEHAVIOR, AVERROR_BUG, "undefined behavior" }, + { MFX_ERR_DEVICE_FAILED, AVERROR(EIO), "device failed" }, + { MFX_ERR_INCOMPATIBLE_AUDIO_PARAM, AVERROR(EINVAL), "incompatible audio parameters" }, + { MFX_ERR_INVALID_AUDIO_PARAM, AVERROR(EINVAL), "invalid audio parameters" }, + + { MFX_WRN_IN_EXECUTION, 0, "operation in execution" }, + { MFX_WRN_DEVICE_BUSY, 0, "device busy" }, + { MFX_WRN_VIDEO_PARAM_CHANGED, 0, "video parameters changed" }, + { MFX_WRN_PARTIAL_ACCELERATION, 0, "partial acceleration" }, + { MFX_WRN_INCOMPATIBLE_VIDEO_PARAM, 0, "incompatible video parameters" }, + { MFX_WRN_VALUE_NOT_CHANGED, 0, "value is saturated" }, + { MFX_WRN_OUT_OF_RANGE, 0, "value out of range" }, + { MFX_WRN_FILTER_SKIPPED, 0, "filter skipped" }, + { MFX_WRN_INCOMPATIBLE_AUDIO_PARAM, 0, "incompatible audio parameters" }, +}; + +static int qsv_map_error(mfxStatus mfx_err, const char **desc) +{ + int i; + for (i = 0; i < FF_ARRAY_ELEMS(qsv_errors); i++) { + if (qsv_errors[i].mfxerr == mfx_err) { + if (desc) + *desc = qsv_errors[i].desc; + return qsv_errors[i].averr; + } + } + if (desc) + *desc = "unknown error"; + return AVERROR_UNKNOWN; +} + +int ff_qsvvpp_print_error(void *log_ctx, mfxStatus err, + const char *error_string) +{ + const char *desc; + int ret; + ret = qsv_map_error(err, &desc); + av_log(log_ctx, AV_LOG_ERROR, "%s: %s (%d)\n", error_string, desc, err); + return ret; +} + +int ff_qsvvpp_print_warning(void *log_ctx, mfxStatus err, + const char *warning_string) +{ + const char *desc; + int ret; + ret = qsv_map_error(err, &desc); + av_log(log_ctx, AV_LOG_WARNING, "%s: %s (%d)\n", warning_string, desc, err); + return ret; +} + /* functions for frameAlloc */ static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req, mfxFrameAllocResponse *resp) @@ -153,6 +226,7 @@ static int map_frame_to_surface(AVFrame *frame, mfxFrameSurface1 *surface) { switch (frame->format) { case AV_PIX_FMT_NV12: + case AV_PIX_FMT_P010: surface->Data.Y = frame->data[0]; surface->Data.UV = frame->data[1]; break; @@ -231,9 +305,11 @@ static int fill_frameinfo_by_link(mfxFrameInfo *frameinfo, AVFilterLink *link) static void clear_unused_frames(QSVFrame *list) { while (list) { - if (list->surface && !list->surface->Data.Locked) { - list->surface = NULL; + /* list->queued==1 means the frame is not cached in VPP + * process any more, it can be released to pool. */ + if ((list->queued == 1) && !list->surface.Data.Locked) { av_frame_free(&list->frame); + list->queued = 0; } list = list->next; } @@ -256,8 +332,10 @@ static QSVFrame *get_free_frame(QSVFrame **list) QSVFrame *out = *list; for (; out; out = out->next) { - if (!out->surface) + if (!out->queued) { + out->queued = 1; break; + } } if (!out) { @@ -266,8 +344,9 @@ static QSVFrame *get_free_frame(QSVFrame **list) av_log(NULL, AV_LOG_ERROR, "Can't alloc new output frame.\n"); return NULL; } - out->next = *list; - *list = out; + out->queued = 1; + out->next = *list; + *list = out; } return out; @@ -297,7 +376,7 @@ static QSVFrame *submit_frame(QSVVPPContext *s, AVFilterLink *inlink, AVFrame *p return NULL; } qsv_frame->frame = av_frame_clone(picref); - qsv_frame->surface = (mfxFrameSurface1 *)qsv_frame->frame->data[3]; + 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) { @@ -316,32 +395,30 @@ static QSVFrame *submit_frame(QSVVPPContext *s, AVFilterLink *inlink, AVFrame *p } av_frame_copy_props(qsv_frame->frame, picref); - av_frame_free(&picref); } else qsv_frame->frame = av_frame_clone(picref); if (map_frame_to_surface(qsv_frame->frame, - &qsv_frame->surface_internal) < 0) { + &qsv_frame->surface) < 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, + 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->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; + 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; + 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; + qsv_frame->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING; return qsv_frame; } @@ -372,7 +449,7 @@ static QSVFrame *query_frame(QSVVPPContext *s, AVFilterLink *outlink) return NULL; } - out_frame->surface = (mfxFrameSurface1 *)out_frame->frame->data[3]; + out_frame->surface = *(mfxFrameSurface1 *)out_frame->frame->data[3]; } else { /* Get a frame with aligned dimensions. * Libmfx need system memory being 128x64 aligned */ @@ -386,14 +463,12 @@ static QSVFrame *query_frame(QSVVPPContext *s, AVFilterLink *outlink) out_frame->frame->height = outlink->h; ret = map_frame_to_surface(out_frame->frame, - &out_frame->surface_internal); + &out_frame->surface); if (ret < 0) return NULL; - - out_frame->surface = &out_frame->surface_internal; } - out_frame->surface->Info = s->vpp_param.vpp.Out; + out_frame->surface.Info = s->vpp_param.vpp.Out; return out_frame; } @@ -461,6 +536,8 @@ static int init_vpp_session(AVFilterContext *avctx, QSVVPPContext *s) out_frames_ctx->height = FFALIGN(outlink->h, 32); out_frames_ctx->sw_format = s->out_sw_format; out_frames_ctx->initial_pool_size = 64; + if (avctx->extra_hw_frames > 0) + out_frames_ctx->initial_pool_size += avctx->extra_hw_frames; out_frames_hwctx->frame_type = s->out_mem_mode; ret = av_hwframe_ctx_init(out_frames_ref); @@ -503,15 +580,19 @@ static int init_vpp_session(AVFilterContext *avctx, QSVVPPContext *s) } } - if (ret != MFX_ERR_NONE) { - av_log(avctx, AV_LOG_ERROR, "Error getting the session handle\n"); + if (ret < 0) + return ff_qsvvpp_print_error(avctx, ret, "Error getting the session handle"); + else if (ret > 0) { + ff_qsvvpp_print_warning(avctx, ret, "Warning in getting the session handle"); return AVERROR_UNKNOWN; } /* 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"); + if (ret < 0) + return ff_qsvvpp_print_error(avctx, ret, "Error initializing a session"); + else if (ret > 0) { + ff_qsvvpp_print_warning(avctx, ret, "Warning in session initialization"); return AVERROR_UNKNOWN; } @@ -556,6 +637,16 @@ static int init_vpp_session(AVFilterContext *avctx, QSVVPPContext *s) return 0; } +static unsigned int qsv_fifo_item_size(void) +{ + return sizeof(mfxSyncPoint) + sizeof(QSVFrame*); +} + +static unsigned int qsv_fifo_size(const AVFifoBuffer* fifo) +{ + return av_fifo_size(fifo)/qsv_fifo_item_size(); +} + int ff_qsvvpp_create(AVFilterContext *avctx, QSVVPPContext **vpp, QSVVPPParam *param) { int i; @@ -628,7 +719,17 @@ int ff_qsvvpp_create(AVFilterContext *avctx, QSVVPPContext **vpp, QSVVPPParam *p s->vpp_param.ExtParam = param->ext_buf; } - s->vpp_param.AsyncDepth = 1; + s->got_frame = 0; + + /** keep fifo size at least 1. Even when async_depth is 0, fifo is used. */ + s->async_fifo = av_fifo_alloc((param->async_depth + 1) * qsv_fifo_item_size()); + s->async_depth = param->async_depth; + if (!s->async_fifo) { + ret = AVERROR(ENOMEM); + goto failed; + } + + s->vpp_param.AsyncDepth = param->async_depth; if (IS_SYSTEM_MEMORY(s->in_mem_mode)) s->vpp_param.IOPattern |= MFX_IOPATTERN_IN_SYSTEM_MEMORY; @@ -644,11 +745,16 @@ int ff_qsvvpp_create(AVFilterContext *avctx, QSVVPPContext **vpp, QSVVPPParam *p else if (IS_OPAQUE_MEMORY(s->out_mem_mode)) s->vpp_param.IOPattern |= MFX_IOPATTERN_OUT_OPAQUE_MEMORY; + /* Print input memory mode */ + ff_qsvvpp_print_iopattern(avctx, s->vpp_param.IOPattern & 0x0F, "VPP"); + /* Print output memory mode */ + ff_qsvvpp_print_iopattern(avctx, s->vpp_param.IOPattern & 0xF0, "VPP"); 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); + ret = ff_qsvvpp_print_error(avctx, ret, "Failed to create a qsvvpp"); goto failed; - } + } else if (ret > 0) + ff_qsvvpp_print_warning(avctx, ret, "Warning When creating qsvvpp"); *vpp = s; return 0; @@ -678,6 +784,7 @@ int ff_qsvvpp_free(QSVVPPContext **vpp) av_freep(&s->surface_ptrs_out); av_freep(&s->ext_buffers); av_freep(&s->frame_infos); + av_fifo_free(s->async_fifo); av_freep(vpp); return 0; @@ -688,9 +795,29 @@ int ff_qsvvpp_filter_frame(QSVVPPContext *s, AVFilterLink *inlink, AVFrame *picr AVFilterContext *ctx = inlink->dst; AVFilterLink *outlink = ctx->outputs[0]; mfxSyncPoint sync; - QSVFrame *in_frame, *out_frame; + QSVFrame *in_frame, *out_frame, *tmp; int ret, filter_ret; + while (s->eof && qsv_fifo_size(s->async_fifo)) { + av_fifo_generic_read(s->async_fifo, &tmp, sizeof(tmp), NULL); + av_fifo_generic_read(s->async_fifo, &sync, sizeof(sync), NULL); + if (MFXVideoCORE_SyncOperation(s->session, sync, 1000) < 0) + av_log(ctx, AV_LOG_WARNING, "Sync failed.\n"); + + filter_ret = s->filter_frame(outlink, tmp->frame); + if (filter_ret < 0) { + av_frame_free(&tmp->frame); + ret = filter_ret; + break; + } + tmp->queued--; + s->got_frame = 1; + tmp->frame = NULL; + }; + + if (!picref) + return 0; + in_frame = submit_frame(s, inlink, picref); if (!in_frame) { av_log(ctx, AV_LOG_ERROR, "Failed to submit frame on input[%d]\n", @@ -706,8 +833,8 @@ int ff_qsvvpp_filter_frame(QSVVPPContext *s, AVFilterLink *inlink, AVFrame *picr } do { - ret = MFXVideoVPP_RunFrameVPPAsync(s->session, in_frame->surface, - out_frame->surface, NULL, &sync); + 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); @@ -718,20 +845,33 @@ int ff_qsvvpp_filter_frame(QSVVPPContext *s, AVFilterLink *inlink, AVFrame *picr ret = AVERROR(EAGAIN); break; } + out_frame->frame->pts = av_rescale_q(out_frame->surface.Data.TimeStamp, + default_tb, outlink->time_base); - if (MFXVideoCORE_SyncOperation(s->session, sync, 1000) < 0) - av_log(ctx, AV_LOG_WARNING, "Sync failed.\n"); + out_frame->queued++; + av_fifo_generic_write(s->async_fifo, &out_frame, sizeof(out_frame), NULL); + av_fifo_generic_write(s->async_fifo, &sync, sizeof(sync), NULL); - 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; + if (qsv_fifo_size(s->async_fifo) > s->async_depth) { + av_fifo_generic_read(s->async_fifo, &tmp, sizeof(tmp), NULL); + av_fifo_generic_read(s->async_fifo, &sync, sizeof(sync), NULL); + + do { + ret = MFXVideoCORE_SyncOperation(s->session, sync, 1000); + } while (ret == MFX_WRN_IN_EXECUTION); + + filter_ret = s->filter_frame(outlink, tmp->frame); + if (filter_ret < 0) { + av_frame_free(&tmp->frame); + ret = filter_ret; + break; + } + + tmp->queued--; + s->got_frame = 1; + tmp->frame = NULL; } - out_frame->frame = NULL; } while(ret == MFX_ERR_MORE_SURFACE); return ret;