ffmpeg | branch: master | Mark Thompson <s...@jkqxz.net> | Sun Mar 12 16:55:32 2017 +0000| [b9acc7fbd9fe6aeb76c9c91a65f1f5dab141fce4] | committer: Mark Thompson
Merge commit 'ad71d3276fef0ee7e791e62bbfe9c4e540047417' * commit 'ad71d3276fef0ee7e791e62bbfe9c4e540047417': lavfi: add a QSV deinterlacing filter Minor fixup for lavfi differences. Merged-by: Mark Thompson <s...@jkqxz.net> > http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=b9acc7fbd9fe6aeb76c9c91a65f1f5dab141fce4 --- Changelog | 2 +- configure | 1 + libavfilter/Makefile | 1 + libavfilter/allfilters.c | 1 + libavfilter/version.h | 2 +- libavfilter/vf_deinterlace_qsv.c | 575 +++++++++++++++++++++++++++++++++++++++ 6 files changed, 580 insertions(+), 2 deletions(-) diff --git a/Changelog b/Changelog index ac9998e..8cefcb5 100644 --- a/Changelog +++ b/Changelog @@ -26,7 +26,7 @@ version <next>: - native Opus encoder - ScreenPressor decoder - incomplete ClearVideo decoder -- Intel QSV video scaling filter +- Intel QSV video scaling and deinterlacing filters version 3.2: - libopenmpt demuxer diff --git a/configure b/configure index dc18bfa..1e2e774 100755 --- a/configure +++ b/configure @@ -3083,6 +3083,7 @@ bs2b_filter_deps="libbs2b" colormatrix_filter_deps="gpl" cover_rect_filter_deps="avcodec avformat gpl" cropdetect_filter_deps="gpl" +deinterlace_qsv_filter_deps="libmfx" deinterlace_vaapi_filter_deps="vaapi" delogo_filter_deps="gpl" deshake_filter_select="pixelutils" diff --git a/libavfilter/Makefile b/libavfilter/Makefile index 4d1180b..428251f 100644 --- a/libavfilter/Makefile +++ b/libavfilter/Makefile @@ -156,6 +156,7 @@ OBJS-$(CONFIG_DCTDNOIZ_FILTER) += vf_dctdnoiz.o OBJS-$(CONFIG_DEBAND_FILTER) += vf_deband.o OBJS-$(CONFIG_DECIMATE_FILTER) += vf_decimate.o OBJS-$(CONFIG_DEFLATE_FILTER) += vf_neighbor.o +OBJS-$(CONFIG_DEINTERLACE_QSV_FILTER) += vf_deinterlace_qsv.o OBJS-$(CONFIG_DEINTERLACE_VAAPI_FILTER) += vf_deinterlace_vaapi.o OBJS-$(CONFIG_DEJUDDER_FILTER) += vf_dejudder.o OBJS-$(CONFIG_DELOGO_FILTER) += vf_delogo.o diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c index 6aa482d..2bf34ef 100644 --- a/libavfilter/allfilters.c +++ b/libavfilter/allfilters.c @@ -167,6 +167,7 @@ static void register_all(void) REGISTER_FILTER(DEBAND, deband, vf); REGISTER_FILTER(DECIMATE, decimate, vf); REGISTER_FILTER(DEFLATE, deflate, vf); + REGISTER_FILTER(DEINTERLACE_QSV,deinterlace_qsv,vf); REGISTER_FILTER(DEINTERLACE_VAAPI, deinterlace_vaapi, vf); REGISTER_FILTER(DEJUDDER, dejudder, vf); REGISTER_FILTER(DELOGO, delogo, vf); diff --git a/libavfilter/version.h b/libavfilter/version.h index 878711d..e67f34b 100644 --- a/libavfilter/version.h +++ b/libavfilter/version.h @@ -30,7 +30,7 @@ #include "libavutil/version.h" #define LIBAVFILTER_VERSION_MAJOR 6 -#define LIBAVFILTER_VERSION_MINOR 75 +#define LIBAVFILTER_VERSION_MINOR 76 #define LIBAVFILTER_VERSION_MICRO 100 #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \ diff --git a/libavfilter/vf_deinterlace_qsv.c b/libavfilter/vf_deinterlace_qsv.c new file mode 100644 index 0000000..e7491e1 --- /dev/null +++ b/libavfilter/vf_deinterlace_qsv.c @@ -0,0 +1,575 @@ +/* + * 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 + * deinterlace video filter - QSV + */ + +#include <mfx/mfxvideo.h> + +#include <stdio.h> +#include <string.h> + +#include "libavutil/avstring.h" +#include "libavutil/common.h" +#include "libavutil/hwcontext.h" +#include "libavutil/hwcontext_qsv.h" +#include "libavutil/internal.h" +#include "libavutil/mathematics.h" +#include "libavutil/opt.h" +#include "libavutil/pixdesc.h" +#include "libavutil/time.h" + +#include "avfilter.h" +#include "formats.h" +#include "internal.h" +#include "video.h" + +enum { + QSVDEINT_MORE_OUTPUT = 1, + QSVDEINT_MORE_INPUT, +}; + +typedef struct QSVFrame { + AVFrame *frame; + mfxFrameSurface1 surface; + int used; + + struct QSVFrame *next; +} QSVFrame; + +typedef struct QSVDeintContext { + const AVClass *class; + + AVBufferRef *hw_frames_ctx; + /* a clone of the main session, used internally for deinterlacing */ + mfxSession session; + + mfxMemId *mem_ids; + int nb_mem_ids; + + mfxFrameSurface1 **surface_ptrs; + int nb_surface_ptrs; + + mfxExtOpaqueSurfaceAlloc opaque_alloc; + mfxExtBuffer *ext_buffers[1]; + + QSVFrame *work_frames; + + int64_t last_pts; + + int eof; +} QSVDeintContext; + +static void qsvdeint_uninit(AVFilterContext *ctx) +{ + QSVDeintContext *s = ctx->priv; + QSVFrame *cur; + + if (s->session) { + MFXClose(s->session); + s->session = NULL; + } + av_buffer_unref(&s->hw_frames_ctx); + + cur = s->work_frames; + while (cur) { + s->work_frames = cur->next; + av_frame_free(&cur->frame); + av_freep(&cur); + cur = s->work_frames; + } + + av_freep(&s->mem_ids); + s->nb_mem_ids = 0; + + av_freep(&s->surface_ptrs); + s->nb_surface_ptrs = 0; +} + +static int qsvdeint_query_formats(AVFilterContext *ctx) +{ + static const enum AVPixelFormat pixel_formats[] = { + AV_PIX_FMT_QSV, AV_PIX_FMT_NONE, + }; + AVFilterFormats *pix_fmts = ff_make_format_list(pixel_formats); + int ret; + + if ((ret = ff_set_common_formats(ctx, pix_fmts)) < 0) + return ret; + + return 0; +} + +static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req, + mfxFrameAllocResponse *resp) +{ + AVFilterContext *ctx = pthis; + QSVDeintContext *s = ctx->priv; + + 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; + + resp->mids = s->mem_ids; + resp->NumFrameActual = s->nb_mem_ids; + + 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 const mfxHandleType handle_types[] = { + MFX_HANDLE_VA_DISPLAY, + MFX_HANDLE_D3D9_DEVICE_MANAGER, + MFX_HANDLE_D3D11_DEVICE, +}; + +static int init_out_session(AVFilterContext *ctx) +{ + + QSVDeintContext *s = ctx->priv; + AVHWFramesContext *hw_frames_ctx = (AVHWFramesContext*)s->hw_frames_ctx->data; + AVQSVFramesContext *hw_frames_hwctx = hw_frames_ctx->hwctx; + AVQSVDeviceContext *device_hwctx = hw_frames_ctx->device_ctx->hwctx; + + int opaque = !!(hw_frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME); + + mfxHDL handle = NULL; + mfxHandleType handle_type; + mfxVersion ver; + mfxIMPL impl; + mfxVideoParam par; + mfxStatus err; + int i; + + /* extract the properties of the "master" session given to us */ + err = MFXQueryIMPL(device_hwctx->session, &impl); + if (err == MFX_ERR_NONE) + err = MFXQueryVersion(device_hwctx->session, &ver); + if (err != MFX_ERR_NONE) { + av_log(ctx, AV_LOG_ERROR, "Error querying the session attributes\n"); + return AVERROR_UNKNOWN; + } + + for (i = 0; i < FF_ARRAY_ELEMS(handle_types); i++) { + err = MFXVideoCORE_GetHandle(device_hwctx->session, handle_types[i], &handle); + if (err == MFX_ERR_NONE) { + handle_type = handle_types[i]; + break; + } + } + + /* create a "slave" session with those same properties, to be used for + * actual deinterlacing */ + err = MFXInit(impl, &ver, &s->session); + if (err != MFX_ERR_NONE) { + av_log(ctx, AV_LOG_ERROR, "Error initializing a session for deinterlacing\n"); + return AVERROR_UNKNOWN; + } + + if (handle) { + err = MFXVideoCORE_SetHandle(s->session, handle_type, handle); + if (err != MFX_ERR_NONE) + return AVERROR_UNKNOWN; + } + + memset(&par, 0, sizeof(par)); + + if (opaque) { + s->surface_ptrs = av_mallocz_array(hw_frames_hwctx->nb_surfaces, + sizeof(*s->surface_ptrs)); + if (!s->surface_ptrs) + return AVERROR(ENOMEM); + for (i = 0; i < hw_frames_hwctx->nb_surfaces; i++) + s->surface_ptrs[i] = hw_frames_hwctx->surfaces + i; + s->nb_surface_ptrs = hw_frames_hwctx->nb_surfaces; + + s->opaque_alloc.In.Surfaces = s->surface_ptrs; + s->opaque_alloc.In.NumSurface = s->nb_surface_ptrs; + s->opaque_alloc.In.Type = hw_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; + + par.ExtParam = s->ext_buffers; + par.NumExtParam = FF_ARRAY_ELEMS(s->ext_buffers); + + par.IOPattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY | MFX_IOPATTERN_OUT_OPAQUE_MEMORY; + } else { + mfxFrameAllocator frame_allocator = { + .pthis = ctx, + .Alloc = frame_alloc, + .Lock = frame_lock, + .Unlock = frame_unlock, + .GetHDL = frame_get_hdl, + .Free = frame_free, + }; + + s->mem_ids = av_mallocz_array(hw_frames_hwctx->nb_surfaces, + sizeof(*s->mem_ids)); + if (!s->mem_ids) + return AVERROR(ENOMEM); + for (i = 0; i < hw_frames_hwctx->nb_surfaces; i++) + s->mem_ids[i] = hw_frames_hwctx->surfaces[i].Data.MemId; + s->nb_mem_ids = hw_frames_hwctx->nb_surfaces; + + err = MFXVideoCORE_SetFrameAllocator(s->session, &frame_allocator); + if (err != MFX_ERR_NONE) + return AVERROR_UNKNOWN; + + par.IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY; + } + + par.AsyncDepth = 1; // TODO async + + par.vpp.In = hw_frames_hwctx->surfaces[0].Info; + + par.vpp.In.CropW = ctx->inputs[0]->w; + par.vpp.In.CropH = ctx->inputs[0]->h; + + if (ctx->inputs[0]->frame_rate.num) { + par.vpp.In.FrameRateExtN = ctx->inputs[0]->frame_rate.num; + par.vpp.In.FrameRateExtD = ctx->inputs[0]->frame_rate.den; + } else { + par.vpp.In.FrameRateExtN = ctx->inputs[0]->time_base.num; + par.vpp.In.FrameRateExtD = ctx->inputs[0]->time_base.den; + } + + par.vpp.Out = par.vpp.In; + + if (ctx->outputs[0]->frame_rate.num) { + par.vpp.Out.FrameRateExtN = ctx->outputs[0]->frame_rate.num; + par.vpp.Out.FrameRateExtD = ctx->outputs[0]->frame_rate.den; + } else { + par.vpp.Out.FrameRateExtN = ctx->outputs[0]->time_base.num; + par.vpp.Out.FrameRateExtD = ctx->outputs[0]->time_base.den; + } + + err = MFXVideoVPP_Init(s->session, &par); + if (err != MFX_ERR_NONE) { + av_log(ctx, AV_LOG_ERROR, "Error opening the VPP for deinterlacing: %d\n", err); + return AVERROR_UNKNOWN; + } + + return 0; +} + +static int qsvdeint_config_props(AVFilterLink *outlink) +{ + AVFilterContext *ctx = outlink->src; + AVFilterLink *inlink = ctx->inputs[0]; + QSVDeintContext *s = ctx->priv; + int ret; + + qsvdeint_uninit(ctx); + + s->last_pts = AV_NOPTS_VALUE; + outlink->frame_rate = av_mul_q(inlink->frame_rate, + (AVRational){ 2, 1 }); + outlink->time_base = av_mul_q(inlink->time_base, + (AVRational){ 1, 2 }); + + /* check that we have a hw context */ + if (!inlink->hw_frames_ctx) { + av_log(ctx, AV_LOG_ERROR, "No hw context provided on input\n"); + return AVERROR(EINVAL); + } + + s->hw_frames_ctx = av_buffer_ref(inlink->hw_frames_ctx); + if (!s->hw_frames_ctx) + return AVERROR(ENOMEM); + + av_buffer_unref(&outlink->hw_frames_ctx); + outlink->hw_frames_ctx = av_buffer_ref(inlink->hw_frames_ctx); + if (!outlink->hw_frames_ctx) { + qsvdeint_uninit(ctx); + return AVERROR(ENOMEM); + } + + ret = init_out_session(ctx); + if (ret < 0) + return ret; + + + return 0; +} + +static void clear_unused_frames(QSVDeintContext *s) +{ + QSVFrame *cur = s->work_frames; + while (cur) { + if (!cur->surface.Data.Locked) { + av_frame_free(&cur->frame); + cur->used = 0; + } + cur = cur->next; + } +} + +static int get_free_frame(QSVDeintContext *s, QSVFrame **f) +{ + QSVFrame *frame, **last; + + clear_unused_frames(s); + + frame = s->work_frames; + last = &s->work_frames; + while (frame) { + if (!frame->used) { + *f = frame; + return 0; + } + + last = &frame->next; + frame = frame->next; + } + + frame = av_mallocz(sizeof(*frame)); + if (!frame) + return AVERROR(ENOMEM); + *last = frame; + *f = frame; + + return 0; +} + +static int submit_frame(AVFilterContext *ctx, AVFrame *frame, + mfxFrameSurface1 **surface) +{ + QSVDeintContext *s = ctx->priv; + QSVFrame *qf; + int ret; + + ret = get_free_frame(s, &qf); + if (ret < 0) + return ret; + + qf->frame = frame; + + qf->surface = *(mfxFrameSurface1*)qf->frame->data[3]; + + qf->surface.Data.Locked = 0; + qf->surface.Info.CropW = qf->frame->width; + qf->surface.Info.CropH = qf->frame->height; + + qf->surface.Info.PicStruct = !qf->frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE : + (qf->frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF : + MFX_PICSTRUCT_FIELD_BFF); + if (qf->frame->repeat_pict == 1) + qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED; + else if (qf->frame->repeat_pict == 2) + qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING; + else if (qf->frame->repeat_pict == 4) + qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING; + + if (ctx->inputs[0]->frame_rate.num) { + qf->surface.Info.FrameRateExtN = ctx->inputs[0]->frame_rate.num; + qf->surface.Info.FrameRateExtD = ctx->inputs[0]->frame_rate.den; + } else { + qf->surface.Info.FrameRateExtN = ctx->inputs[0]->time_base.num; + qf->surface.Info.FrameRateExtD = ctx->inputs[0]->time_base.den; + } + + qf->surface.Data.TimeStamp = av_rescale_q(qf->frame->pts, + ctx->inputs[0]->time_base, + (AVRational){1, 90000}); + + *surface = &qf->surface; + qf->used = 1; + + return 0; +} + +static int process_frame(AVFilterContext *ctx, const AVFrame *in, + mfxFrameSurface1 *surf_in) +{ + QSVDeintContext *s = ctx->priv; + AVFilterLink *inlink = ctx->inputs[0]; + AVFilterLink *outlink = ctx->outputs[0]; + + AVFrame *out; + mfxFrameSurface1 *surf_out; + mfxSyncPoint sync = NULL; + mfxStatus err; + int ret, again = 0; + + out = av_frame_alloc(); + if (!out) + return AVERROR(ENOMEM); + + ret = av_hwframe_get_buffer(s->hw_frames_ctx, out, 0); + if (ret < 0) + goto fail; + + surf_out = (mfxFrameSurface1*)out->data[3]; + surf_out->Info.CropW = outlink->w; + surf_out->Info.CropH = outlink->h; + surf_out->Info.PicStruct = MFX_PICSTRUCT_PROGRESSIVE; + + do { + err = MFXVideoVPP_RunFrameVPPAsync(s->session, surf_in, surf_out, + NULL, &sync); + if (err == MFX_WRN_DEVICE_BUSY) + av_usleep(1); + } while (err == MFX_WRN_DEVICE_BUSY); + + if (err == MFX_ERR_MORE_DATA) { + av_frame_free(&out); + return QSVDEINT_MORE_INPUT; + } + + if ((err < 0 && err != MFX_ERR_MORE_SURFACE) || !sync) { + av_log(ctx, AV_LOG_ERROR, "Error during deinterlacing: %d\n", err); + ret = AVERROR_UNKNOWN; + goto fail; + } + if (err == MFX_ERR_MORE_SURFACE) + again = 1; + + do { + err = MFXVideoCORE_SyncOperation(s->session, sync, 1000); + } while (err == MFX_WRN_IN_EXECUTION); + if (err < 0) { + av_log(ctx, AV_LOG_ERROR, "Error synchronizing the operation: %d\n", err); + ret = AVERROR_UNKNOWN; + goto fail; + } + + ret = av_frame_copy_props(out, in); + if (ret < 0) + goto fail; + + out->width = outlink->w; + out->height = outlink->h; + out->interlaced_frame = 0; + + out->pts = av_rescale_q(out->pts, inlink->time_base, outlink->time_base); + if (out->pts == s->last_pts) + out->pts++; + s->last_pts = out->pts; + + ret = ff_filter_frame(outlink, out); + if (ret < 0) + return ret; + + return again ? QSVDEINT_MORE_OUTPUT : 0; +fail: + av_frame_free(&out); + return ret; +} + +static int qsvdeint_filter_frame(AVFilterLink *link, AVFrame *in) +{ + AVFilterContext *ctx = link->dst; + + mfxFrameSurface1 *surf_in; + int ret; + + ret = submit_frame(ctx, in, &surf_in); + if (ret < 0) { + av_frame_free(&in); + return ret; + } + + do { + ret = process_frame(ctx, in, surf_in); + if (ret < 0) + return ret; + } while (ret == QSVDEINT_MORE_OUTPUT); + + return 0; +} + +static int qsvdeint_request_frame(AVFilterLink *outlink) +{ + AVFilterContext *ctx = outlink->src; + + return ff_request_frame(ctx->inputs[0]); +} + +#define OFFSET(x) offsetof(QSVDeintContext, x) +#define FLAGS AV_OPT_FLAG_VIDEO_PARAM +static const AVOption options[] = { + { NULL }, +}; + +static const AVClass qsvdeint_class = { + .class_name = "deinterlace_qsv", + .item_name = av_default_item_name, + .option = options, + .version = LIBAVUTIL_VERSION_INT, +}; + +static const AVFilterPad qsvdeint_inputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .filter_frame = qsvdeint_filter_frame, + }, + { NULL } +}; + +static const AVFilterPad qsvdeint_outputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .config_props = qsvdeint_config_props, + .request_frame = qsvdeint_request_frame, + }, + { NULL } +}; + +AVFilter ff_vf_deinterlace_qsv = { + .name = "deinterlace_qsv", + .description = NULL_IF_CONFIG_SMALL("QuickSync video deinterlacing"), + + .uninit = qsvdeint_uninit, + .query_formats = qsvdeint_query_formats, + + .priv_size = sizeof(QSVDeintContext), + .priv_class = &qsvdeint_class, + + .inputs = qsvdeint_inputs, + .outputs = qsvdeint_outputs, +}; ====================================================================== diff --cc Changelog index ac9998e,d3201b3..8cefcb5 --- a/Changelog +++ b/Changelog @@@ -2,285 -2,17 +2,285 @@@ Entries are sorted chronologically fro releases are sorted from youngest to oldest. version <next>: -- aliases and defaults for Ogg subtypes (opus, spx) -- HEVC/H.265 RTP payload format (draft v6) packetizer and depacketizer -- avplay now exits by default at the end of playback -- XCB-based screen-grabber -- creating DASH compatible fragmented MP4, MPEG-DASH segmenting muxer -- H.261 RTP payload format (RFC 4587) depacketizer and experimental packetizer +- CrystalHD decoder moved to new decode API +- add internal ebur128 library, remove external libebur128 dependency +- Pro-MPEG CoP #3-R2 FEC protocol +- premultiply video filter +- Support for spherical videos +- configure now fails if autodetect-libraries are requested but not found +- PSD Decoder +- 16.8 floating point pcm decoder +- 24.0 floating point pcm decoder +- Apple Pixlet decoder +- QDMC audio decoder +- NewTek SpeedHQ decoder +- MIDI Sample Dump Standard demuxer +- readeia608 filter +- Sample Dump eXchange demuxer +- abitscope multimedia filter +- Scenarist Closed Captions demuxer and muxer +- threshold filter +- midequalizer filter +- Optimal Huffman tables for (M)JPEG encoding +- FM Screen Capture Codec decoder +- native Opus encoder +- ScreenPressor decoder +- incomplete ClearVideo decoder - - Intel QSV video scaling filter ++- Intel QSV video scaling and deinterlacing filters + +version 3.2: +- libopenmpt demuxer +- tee protocol +- Changed metadata print option to accept general urls +- Alias muxer for Ogg Video (.ogv) +- VP8 in Ogg muxing +- curves filter doesn't automatically insert points at x=0 and x=1 anymore +- 16-bit support in curves filter and selectivecolor filter +- OpenH264 decoder wrapper +- MediaCodec H.264/HEVC/MPEG-4/VP8/VP9 hwaccel +- True Audio (TTA) muxer +- crystalizer audio filter +- acrusher audio filter +- bitplanenoise video filter +- floating point support in als decoder +- fifo muxer +- maskedclamp filter +- hysteresis filter +- lut2 filter +- yuvtestsrc filter +- CUDA CUVID H.263/VP8/VP9/10 bit HEVC (Dithered) Decoding +- vaguedenoiser filter +- added threads option per filter instance +- weave filter +- gblur filter +- avgblur filter +- sobel and prewitt filter +- MediaCodec HEVC/MPEG-4/VP8/VP9 decoding +- Meridian Lossless Packing (MLP) / TrueHD encoder +- Non-Local Means (nlmeans) denoising filter +- sdl2 output device and ffplay support +- sdl1 output device and sdl1 support removed +- extended mov edit list support +- libfaac encoder removed +- Matroska muxer now writes CRC32 elements by default in all Level 1 elements +- sidedata video and asidedata audio filter +- Changed mapping of rtp MIME type G726 to codec g726le. +- spec compliant VAAPI/DXVA2 VC-1 decoding of slices in frame-coded images + + +version 3.1: +- DXVA2-accelerated HEVC Main10 decoding +- fieldhint filter +- loop video filter and aloop audio filter +- Bob Weaver deinterlacing filter +- firequalizer filter +- datascope filter +- bench and abench filters +- ciescope filter +- protocol blacklisting API +- MediaCodec H264 decoding +- VC-2 HQ RTP payload format (draft v1) depacketizer and packetizer +- VP9 RTP payload format (draft v2) packetizer +- AudioToolbox audio decoders +- AudioToolbox audio encoders +- coreimage filter (GPU based image filtering on OSX) +- libdcadec removed +- bitstream filter for extracting DTS core +- ADPCM IMA DAT4 decoder +- musx demuxer +- aix demuxer +- remap filter +- hash and framehash muxers +- colorspace filter +- hdcd filter +- readvitc filter +- VAAPI-accelerated format conversion and scaling +- libnpp/CUDA-accelerated format conversion and scaling +- Duck TrueMotion 2.0 Real Time decoder +- Wideband Single-bit Data (WSD) demuxer +- VAAPI-accelerated H.264/HEVC/MJPEG encoding +- DTS Express (LBR) decoder +- Generic OpenMAX IL encoder with support for Raspberry Pi +- IFF ANIM demuxer & decoder +- Direct Stream Transfer (DST) decoder +- loudnorm filter +- MTAF demuxer and decoder +- MagicYUV decoder +- OpenExr improvements (tile data and B44/B44A support) +- BitJazz SheerVideo decoder +- CUDA CUVID H264/HEVC decoder +- 10-bit depth support in native utvideo decoder +- libutvideo wrapper removed +- YUY2 Lossless Codec decoder +- VideoToolbox H.264 encoder +- VAAPI-accelerated MPEG-2 and VP8 encoding + + +version 3.0: +- Common Encryption (CENC) MP4 encoding and decoding support +- DXV decoding +- extrastereo filter +- ocr filter +- alimiter filter +- stereowiden filter +- stereotools filter +- rubberband filter +- tremolo filter +- agate filter +- chromakey filter +- maskedmerge filter +- Screenpresso SPV1 decoding +- chromaprint fingerprinting muxer +- ffplay dynamic volume control +- displace filter +- selectivecolor filter +- extensive native AAC encoder improvements and removal of experimental flag +- ADPCM PSX decoder +- 3dostr, dcstr, fsb, genh, vag, xvag, ads, msf, svag & vpk demuxer +- zscale filter +- wve demuxer +- zero-copy Intel QSV transcoding in ffmpeg +- shuffleframes filter +- SDX2 DPCM decoder +- vibrato filter +- innoHeim/Rsupport Screen Capture Codec decoder +- ADPCM AICA decoder +- Interplay ACM demuxer and audio decoder +- XMA1 & XMA2 decoder +- realtime filter +- anoisesrc audio filter source +- IVR demuxer +- compensationdelay filter +- acompressor filter +- support encoding 16-bit RLE SGI images +- apulsator filter +- sidechaingate audio filter +- mipsdspr1 option has been renamed to mipsdsp +- aemphasis filter +- mips32r5 option has been removed +- mips64r6 option has been removed +- DXVA2-accelerated VP9 decoding +- SOFAlizer: virtual binaural acoustics filter +- VAAPI VP9 hwaccel +- audio high-order multiband parametric equalizer +- automatic bitstream filtering +- showspectrumpic filter +- libstagefright support removed +- spectrumsynth filter +- ahistogram filter +- only seek with the right mouse button in ffplay +- toggle full screen when double-clicking with the left mouse button in ffplay +- afftfilt filter +- convolution filter +- libquvi support removed +- support for dvaudio in wav and avi +- libaacplus and libvo-aacenc support removed +- Cineform HD decoder +- new DCA decoder with full support for DTS-HD extensions +- significant performance improvements in Windows Television (WTV) demuxer +- nnedi deinterlacer +- streamselect video and astreamselect audio filter +- swaprect filter +- metadata video and ametadata audio filter +- SMPTE VC-2 HQ profile support for the Dirac decoder +- SMPTE VC-2 native encoder supporting the HQ profile + + +version 2.8: +- colorkey video filter +- BFSTM/BCSTM demuxer +- little-endian ADPCM_THP decoder +- Hap decoder and encoder +- DirectDraw Surface image/texture decoder +- ssim filter +- optional new ASF demuxer +- showvolume filter +- Many improvements to the JPEG 2000 decoder +- Go2Meeting decoding support +- adrawgraph audio and drawgraph video filter +- removegrain video filter +- Intel QSV-accelerated MPEG-2 video and HEVC encoding +- Intel QSV-accelerated MPEG-2 video and HEVC decoding +- Intel QSV-accelerated VC-1 video decoding +- libkvazaar HEVC encoder +- erosion, dilation, deflate and inflate video filters +- Dynamic Audio Normalizer as dynaudnorm filter +- Reverse video and areverse audio filter +- Random filter +- deband filter +- AAC fixed-point decoding +- sidechaincompress audio filter +- bitstream filter for converting HEVC from MP4 to Annex B +- acrossfade audio filter +- allyuv and allrgb video sources +- atadenoise video filter +- OS X VideoToolbox support +- aphasemeter filter +- showfreqs filter +- vectorscope filter +- waveform filter +- hstack and vstack filter +- Support DNx100 (1440x1080@8) +- VAAPI hevc hwaccel +- VDPAU hevc hwaccel +- framerate filter +- Switched default encoders for webm to VP9 and Opus +- Removed experimental flag from the JPEG 2000 encoder + + +version 2.7: +- FFT video filter +- TDSC decoder +- DTS lossless extension (XLL) decoding (not lossless, disabled by default) +- showwavespic filter +- DTS decoding through libdcadec +- Drop support for nvenc API before 5.0 +- nvenc HEVC encoder +- Detelecine filter +- Intel QSV-accelerated H.264 encoding +- MMAL-accelerated H.264 decoding +- basic APNG encoder and muxer with default extension "apng" +- unpack DivX-style packed B-frames in MPEG-4 bitstream filter +- WebM Live Chunk Muxer +- nvenc level and tier options +- chorus filter +- Canopus HQ/HQA decoder +- Automatically rotate videos based on metadata in ffmpeg +- improved Quickdraw compatibility +- VP9 high bit-depth and extended colorspaces decoding support +- WebPAnimEncoder API when available for encoding and muxing WebP +- Direct3D11-accelerated decoding +- Support Secure Transport +- Multipart JPEG demuxer + + +version 2.6: +- nvenc encoder +- 10bit spp filter +- colorlevels filter +- RIFX format for *.wav files - RTP/mpegts muxer -- VP8 in Ogg demuxing +- non continuous cache protocol support +- tblend filter +- cropdetect support for non 8bpp, absolute (if limit >= 1) and relative (if limit < 1.0) threshold +- Camellia symmetric block cipher - OpenH264 encoder wrapper +- VOC seeking support +- Closed caption Decoder +- fspp, uspp, pp7 MPlayer postprocessing filters ported to native filters +- showpalette filter +- Twofish symmetric block cipher - Support DNx100 (960x720@8) -- Direct3D11-accelerated decoding +- eq2 filter ported from libmpcodecs as eq filter +- removed libmpcodecs +- Changed default DNxHD colour range in QuickTime .mov derivatives to mpeg range +- ported softpulldown filter from libmpcodecs as repeatfields filter +- dcshift filter +- RTP depacketizer for loss tolerant payload format for MP3 audio (RFC 5219) +- RTP depacketizer for AC3 payload format (RFC 4184) +- palettegen and paletteuse filters +- VP9 RTP payload format (draft 0) experimental depacketizer +- RTP depacketizer for DV (RFC 6469) - DXVA2-accelerated HEVC decoding - AAC ELD 480 decoding - Intel QSV-accelerated H.264 decoding diff --cc configure index dc18bfa,f12fa6f..1e2e774 --- a/configure +++ b/configure @@@ -3080,84 -2401,20 +3080,85 @@@ azmq_filter_deps="libzmq blackframe_filter_deps="gpl" boxblur_filter_deps="gpl" bs2b_filter_deps="libbs2b" +colormatrix_filter_deps="gpl" +cover_rect_filter_deps="avcodec avformat gpl" cropdetect_filter_deps="gpl" + deinterlace_qsv_filter_deps="libmfx" +deinterlace_vaapi_filter_deps="vaapi" delogo_filter_deps="gpl" +deshake_filter_select="pixelutils" drawtext_filter_deps="libfreetype" +eq_filter_deps="gpl" +fftfilt_filter_deps="avcodec" +fftfilt_filter_select="rdft" +find_rect_filter_deps="avcodec avformat gpl" +firequalizer_filter_deps="avcodec" +firequalizer_filter_select="rdft" +flite_filter_deps="libflite" +framerate_filter_select="pixelutils" frei0r_filter_deps="frei0r dlopen" -frei0r_filter_extralibs='$ldl' frei0r_src_filter_deps="frei0r dlopen" -frei0r_src_filter_extralibs='$ldl' +fspp_filter_deps="gpl" +geq_filter_deps="gpl" +histeq_filter_deps="gpl" hqdn3d_filter_deps="gpl" interlace_filter_deps="gpl" +kerndeint_filter_deps="gpl" +ladspa_filter_deps="ladspa dlopen" +mcdeint_filter_deps="avcodec gpl" +movie_filter_deps="avcodec avformat" +mpdecimate_filter_deps="gpl" +mpdecimate_filter_select="pixelutils" +mptestsrc_filter_deps="gpl" +negate_filter_deps="lut_filter" +nnedi_filter_deps="gpl" +ocr_filter_deps="libtesseract" ocv_filter_deps="libopencv" +owdenoise_filter_deps="gpl" +pan_filter_deps="swresample" +perspective_filter_deps="gpl" +phase_filter_deps="gpl" +pp7_filter_deps="gpl" +pp_filter_deps="gpl postproc" +pullup_filter_deps="gpl" +removelogo_filter_deps="avcodec avformat swscale" +repeatfields_filter_deps="gpl" resample_filter_deps="avresample" +rubberband_filter_deps="librubberband" +sab_filter_deps="gpl swscale" +scale2ref_filter_deps="swscale" scale_filter_deps="swscale" scale_qsv_filter_deps="libmfx" +select_filter_select="pixelutils" +showcqt_filter_deps="avcodec avformat swscale" +showcqt_filter_select="fft" +showfreqs_filter_deps="avcodec" +showfreqs_filter_select="fft" +showspectrum_filter_deps="avcodec" +showspectrum_filter_select="fft" +showspectrumpic_filter_deps="avcodec" +showspectrumpic_filter_select="fft" +smartblur_filter_deps="gpl swscale" +sofalizer_filter_deps="netcdf avcodec" +sofalizer_filter_select="fft" +spectrumsynth_filter_deps="avcodec" +spectrumsynth_filter_select="fft" +spp_filter_deps="gpl avcodec" +spp_filter_select="fft idctdsp fdctdsp me_cmp pixblockdsp" +stereo3d_filter_deps="gpl" +subtitles_filter_deps="avformat avcodec libass" +super2xsai_filter_deps="gpl" +pixfmts_super2xsai_test_deps="super2xsai_filter" +tinterlace_filter_deps="gpl" +tinterlace_merge_test_deps="tinterlace_filter" +tinterlace_pad_test_deps="tinterlace_filter" +uspp_filter_deps="gpl avcodec" +vaguedenoiser_filter_deps="gpl" +vidstabdetect_filter_deps="libvidstab" +vidstabtransform_filter_deps="libvidstab" +zmq_filter_deps="libzmq" +zoompan_filter_deps="swscale" +zscale_filter_deps="libzimg" scale_vaapi_filter_deps="vaapi VAProcPipelineParameterBuffer" # examples diff --cc libavfilter/Makefile index 4d1180b,dea8ffa..428251f --- a/libavfilter/Makefile +++ b/libavfilter/Makefile @@@ -78,107 -33,26 +78,108 @@@ OBJS-$(CONFIG_BIQUAD_FILTER OBJS-$(CONFIG_BS2B_FILTER) += af_bs2b.o OBJS-$(CONFIG_CHANNELMAP_FILTER) += af_channelmap.o OBJS-$(CONFIG_CHANNELSPLIT_FILTER) += af_channelsplit.o +OBJS-$(CONFIG_CHORUS_FILTER) += af_chorus.o generate_wave_table.o OBJS-$(CONFIG_COMPAND_FILTER) += af_compand.o +OBJS-$(CONFIG_COMPENSATIONDELAY_FILTER) += af_compensationdelay.o +OBJS-$(CONFIG_CRYSTALIZER_FILTER) += af_crystalizer.o +OBJS-$(CONFIG_DCSHIFT_FILTER) += af_dcshift.o +OBJS-$(CONFIG_DYNAUDNORM_FILTER) += af_dynaudnorm.o +OBJS-$(CONFIG_EARWAX_FILTER) += af_earwax.o +OBJS-$(CONFIG_EBUR128_FILTER) += f_ebur128.o +OBJS-$(CONFIG_EQUALIZER_FILTER) += af_biquads.o +OBJS-$(CONFIG_EXTRASTEREO_FILTER) += af_extrastereo.o +OBJS-$(CONFIG_FIREQUALIZER_FILTER) += af_firequalizer.o +OBJS-$(CONFIG_FLANGER_FILTER) += af_flanger.o generate_wave_table.o +OBJS-$(CONFIG_HDCD_FILTER) += af_hdcd.o +OBJS-$(CONFIG_HIGHPASS_FILTER) += af_biquads.o OBJS-$(CONFIG_JOIN_FILTER) += af_join.o +OBJS-$(CONFIG_LADSPA_FILTER) += af_ladspa.o +OBJS-$(CONFIG_LOUDNORM_FILTER) += af_loudnorm.o ebur128.o +OBJS-$(CONFIG_LOWPASS_FILTER) += af_biquads.o +OBJS-$(CONFIG_PAN_FILTER) += af_pan.o +OBJS-$(CONFIG_REPLAYGAIN_FILTER) += af_replaygain.o OBJS-$(CONFIG_RESAMPLE_FILTER) += af_resample.o +OBJS-$(CONFIG_RUBBERBAND_FILTER) += af_rubberband.o +OBJS-$(CONFIG_SIDECHAINCOMPRESS_FILTER) += af_sidechaincompress.o +OBJS-$(CONFIG_SIDECHAINGATE_FILTER) += af_agate.o +OBJS-$(CONFIG_SILENCEDETECT_FILTER) += af_silencedetect.o +OBJS-$(CONFIG_SILENCEREMOVE_FILTER) += af_silenceremove.o +OBJS-$(CONFIG_SOFALIZER_FILTER) += af_sofalizer.o +OBJS-$(CONFIG_STEREOTOOLS_FILTER) += af_stereotools.o +OBJS-$(CONFIG_STEREOWIDEN_FILTER) += af_stereowiden.o +OBJS-$(CONFIG_TREBLE_FILTER) += af_biquads.o +OBJS-$(CONFIG_TREMOLO_FILTER) += af_tremolo.o +OBJS-$(CONFIG_VIBRATO_FILTER) += af_vibrato.o generate_wave_table.o OBJS-$(CONFIG_VOLUME_FILTER) += af_volume.o +OBJS-$(CONFIG_VOLUMEDETECT_FILTER) += af_volumedetect.o -OBJS-$(CONFIG_ANULLSINK_FILTER) += asink_anullsink.o +OBJS-$(CONFIG_AEVALSRC_FILTER) += aeval.o +OBJS-$(CONFIG_ANOISESRC_FILTER) += asrc_anoisesrc.o OBJS-$(CONFIG_ANULLSRC_FILTER) += asrc_anullsrc.o +OBJS-$(CONFIG_FLITE_FILTER) += asrc_flite.o +OBJS-$(CONFIG_SINE_FILTER) += asrc_sine.o + +OBJS-$(CONFIG_ANULLSINK_FILTER) += asink_anullsink.o # video filters +OBJS-$(CONFIG_ALPHAEXTRACT_FILTER) += vf_extractplanes.o +OBJS-$(CONFIG_ALPHAMERGE_FILTER) += vf_alphamerge.o +OBJS-$(CONFIG_ASS_FILTER) += vf_subtitles.o +OBJS-$(CONFIG_ATADENOISE_FILTER) += vf_atadenoise.o +OBJS-$(CONFIG_AVGBLUR_FILTER) += vf_avgblur.o +OBJS-$(CONFIG_BBOX_FILTER) += bbox.o vf_bbox.o +OBJS-$(CONFIG_BENCH_FILTER) += f_bench.o +OBJS-$(CONFIG_BITPLANENOISE_FILTER) += vf_bitplanenoise.o +OBJS-$(CONFIG_BLACKDETECT_FILTER) += vf_blackdetect.o OBJS-$(CONFIG_BLACKFRAME_FILTER) += vf_blackframe.o +OBJS-$(CONFIG_BLEND_FILTER) += vf_blend.o dualinput.o framesync.o OBJS-$(CONFIG_BOXBLUR_FILTER) += vf_boxblur.o +OBJS-$(CONFIG_BWDIF_FILTER) += vf_bwdif.o +OBJS-$(CONFIG_CHROMAKEY_FILTER) += vf_chromakey.o +OBJS-$(CONFIG_CIESCOPE_FILTER) += vf_ciescope.o +OBJS-$(CONFIG_CODECVIEW_FILTER) += vf_codecview.o +OBJS-$(CONFIG_COLORBALANCE_FILTER) += vf_colorbalance.o +OBJS-$(CONFIG_COLORCHANNELMIXER_FILTER) += vf_colorchannelmixer.o +OBJS-$(CONFIG_COLORKEY_FILTER) += vf_colorkey.o +OBJS-$(CONFIG_COLORLEVELS_FILTER) += vf_colorlevels.o +OBJS-$(CONFIG_COLORMATRIX_FILTER) += vf_colormatrix.o +OBJS-$(CONFIG_COLORSPACE_FILTER) += vf_colorspace.o colorspacedsp.o +OBJS-$(CONFIG_CONVOLUTION_FILTER) += vf_convolution.o OBJS-$(CONFIG_COPY_FILTER) += vf_copy.o +OBJS-$(CONFIG_COREIMAGE_FILTER) += vf_coreimage.o +OBJS-$(CONFIG_COVER_RECT_FILTER) += vf_cover_rect.o lavfutils.o OBJS-$(CONFIG_CROP_FILTER) += vf_crop.o OBJS-$(CONFIG_CROPDETECT_FILTER) += vf_cropdetect.o +OBJS-$(CONFIG_CURVES_FILTER) += vf_curves.o +OBJS-$(CONFIG_DATASCOPE_FILTER) += vf_datascope.o +OBJS-$(CONFIG_DCTDNOIZ_FILTER) += vf_dctdnoiz.o +OBJS-$(CONFIG_DEBAND_FILTER) += vf_deband.o +OBJS-$(CONFIG_DECIMATE_FILTER) += vf_decimate.o +OBJS-$(CONFIG_DEFLATE_FILTER) += vf_neighbor.o + OBJS-$(CONFIG_DEINTERLACE_QSV_FILTER) += vf_deinterlace_qsv.o +OBJS-$(CONFIG_DEINTERLACE_VAAPI_FILTER) += vf_deinterlace_vaapi.o +OBJS-$(CONFIG_DEJUDDER_FILTER) += vf_dejudder.o OBJS-$(CONFIG_DELOGO_FILTER) += vf_delogo.o +OBJS-$(CONFIG_DESHAKE_FILTER) += vf_deshake.o +OBJS-$(CONFIG_DETELECINE_FILTER) += vf_detelecine.o +OBJS-$(CONFIG_DILATION_FILTER) += vf_neighbor.o +OBJS-$(CONFIG_DISPLACE_FILTER) += vf_displace.o framesync.o OBJS-$(CONFIG_DRAWBOX_FILTER) += vf_drawbox.o +OBJS-$(CONFIG_DRAWGRAPH_FILTER) += f_drawgraph.o +OBJS-$(CONFIG_DRAWGRID_FILTER) += vf_drawbox.o OBJS-$(CONFIG_DRAWTEXT_FILTER) += vf_drawtext.o +OBJS-$(CONFIG_EDGEDETECT_FILTER) += vf_edgedetect.o +OBJS-$(CONFIG_ELBG_FILTER) += vf_elbg.o +OBJS-$(CONFIG_EQ_FILTER) += vf_eq.o +OBJS-$(CONFIG_EROSION_FILTER) += vf_neighbor.o +OBJS-$(CONFIG_EXTRACTPLANES_FILTER) += vf_extractplanes.o OBJS-$(CONFIG_FADE_FILTER) += vf_fade.o +OBJS-$(CONFIG_FFTFILT_FILTER) += vf_fftfilt.o +OBJS-$(CONFIG_FIELD_FILTER) += vf_field.o +OBJS-$(CONFIG_FIELDHINT_FILTER) += vf_fieldhint.o +OBJS-$(CONFIG_FIELDMATCH_FILTER) += vf_fieldmatch.o OBJS-$(CONFIG_FIELDORDER_FILTER) += vf_fieldorder.o +OBJS-$(CONFIG_FIND_RECT_FILTER) += vf_find_rect.o lavfutils.o OBJS-$(CONFIG_FORMAT_FILTER) += vf_format.o OBJS-$(CONFIG_FPS_FILTER) += vf_fps.o OBJS-$(CONFIG_FRAMEPACK_FILTER) += vf_framepack.o diff --cc libavfilter/allfilters.c index 6aa482d,de49d65..2bf34ef --- a/libavfilter/allfilters.c +++ b/libavfilter/allfilters.c @@@ -133,63 -65,17 +133,64 @@@ static void register_all(void REGISTER_FILTER(ANULLSINK, anullsink, asink); + REGISTER_FILTER(ALPHAEXTRACT, alphaextract, vf); + REGISTER_FILTER(ALPHAMERGE, alphamerge, vf); + REGISTER_FILTER(ASS, ass, vf); + REGISTER_FILTER(ATADENOISE, atadenoise, vf); + REGISTER_FILTER(AVGBLUR, avgblur, vf); + REGISTER_FILTER(BBOX, bbox, vf); + REGISTER_FILTER(BENCH, bench, vf); + REGISTER_FILTER(BITPLANENOISE, bitplanenoise, vf); + REGISTER_FILTER(BLACKDETECT, blackdetect, vf); REGISTER_FILTER(BLACKFRAME, blackframe, vf); + REGISTER_FILTER(BLEND, blend, vf); REGISTER_FILTER(BOXBLUR, boxblur, vf); + REGISTER_FILTER(BWDIF, bwdif, vf); + REGISTER_FILTER(CHROMAKEY, chromakey, vf); + REGISTER_FILTER(CIESCOPE, ciescope, vf); + REGISTER_FILTER(CODECVIEW, codecview, vf); + REGISTER_FILTER(COLORBALANCE, colorbalance, vf); + REGISTER_FILTER(COLORCHANNELMIXER, colorchannelmixer, vf); + REGISTER_FILTER(COLORKEY, colorkey, vf); + REGISTER_FILTER(COLORLEVELS, colorlevels, vf); + REGISTER_FILTER(COLORMATRIX, colormatrix, vf); + REGISTER_FILTER(COLORSPACE, colorspace, vf); + REGISTER_FILTER(CONVOLUTION, convolution, vf); REGISTER_FILTER(COPY, copy, vf); + REGISTER_FILTER(COREIMAGE, coreimage, vf); + REGISTER_FILTER(COVER_RECT, cover_rect, vf); REGISTER_FILTER(CROP, crop, vf); REGISTER_FILTER(CROPDETECT, cropdetect, vf); + REGISTER_FILTER(CURVES, curves, vf); + REGISTER_FILTER(DATASCOPE, datascope, vf); + REGISTER_FILTER(DCTDNOIZ, dctdnoiz, vf); + REGISTER_FILTER(DEBAND, deband, vf); + REGISTER_FILTER(DECIMATE, decimate, vf); + REGISTER_FILTER(DEFLATE, deflate, vf); + REGISTER_FILTER(DEINTERLACE_QSV,deinterlace_qsv,vf); + REGISTER_FILTER(DEINTERLACE_VAAPI, deinterlace_vaapi, vf); + REGISTER_FILTER(DEJUDDER, dejudder, vf); REGISTER_FILTER(DELOGO, delogo, vf); + REGISTER_FILTER(DESHAKE, deshake, vf); + REGISTER_FILTER(DETELECINE, detelecine, vf); + REGISTER_FILTER(DILATION, dilation, vf); + REGISTER_FILTER(DISPLACE, displace, vf); REGISTER_FILTER(DRAWBOX, drawbox, vf); + REGISTER_FILTER(DRAWGRAPH, drawgraph, vf); + REGISTER_FILTER(DRAWGRID, drawgrid, vf); REGISTER_FILTER(DRAWTEXT, drawtext, vf); + REGISTER_FILTER(EDGEDETECT, edgedetect, vf); + REGISTER_FILTER(ELBG, elbg, vf); + REGISTER_FILTER(EQ, eq, vf); + REGISTER_FILTER(EROSION, erosion, vf); + REGISTER_FILTER(EXTRACTPLANES, extractplanes, vf); REGISTER_FILTER(FADE, fade, vf); + REGISTER_FILTER(FFTFILT, fftfilt, vf); + REGISTER_FILTER(FIELD, field, vf); + REGISTER_FILTER(FIELDHINT, fieldhint, vf); + REGISTER_FILTER(FIELDMATCH, fieldmatch, vf); REGISTER_FILTER(FIELDORDER, fieldorder, vf); + REGISTER_FILTER(FIND_RECT, find_rect, vf); REGISTER_FILTER(FORMAT, format, vf); REGISTER_FILTER(FPS, fps, vf); REGISTER_FILTER(FRAMEPACK, framepack, vf); diff --cc libavfilter/version.h index 878711d,7f3ede2..e67f34b --- a/libavfilter/version.h +++ b/libavfilter/version.h @@@ -29,9 -29,9 +29,9 @@@ #include "libavutil/version.h" -#define LIBAVFILTER_VERSION_MAJOR 6 -#define LIBAVFILTER_VERSION_MINOR 6 -#define LIBAVFILTER_VERSION_MICRO 0 +#define LIBAVFILTER_VERSION_MAJOR 6 - #define LIBAVFILTER_VERSION_MINOR 75 ++#define LIBAVFILTER_VERSION_MINOR 76 +#define LIBAVFILTER_VERSION_MICRO 100 #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \ LIBAVFILTER_VERSION_MINOR, \ diff --cc libavfilter/vf_deinterlace_qsv.c index 0000000,b26a900..e7491e1 mode 000000,100644..100644 --- a/libavfilter/vf_deinterlace_qsv.c +++ b/libavfilter/vf_deinterlace_qsv.c @@@ -1,0 -1,580 +1,575 @@@ + /* - * 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 + */ + + /** + * @file + * deinterlace video filter - QSV + */ + + #include <mfx/mfxvideo.h> + + #include <stdio.h> + #include <string.h> + + #include "libavutil/avstring.h" + #include "libavutil/common.h" + #include "libavutil/hwcontext.h" + #include "libavutil/hwcontext_qsv.h" + #include "libavutil/internal.h" + #include "libavutil/mathematics.h" + #include "libavutil/opt.h" + #include "libavutil/pixdesc.h" + #include "libavutil/time.h" + + #include "avfilter.h" + #include "formats.h" + #include "internal.h" + #include "video.h" + + enum { + QSVDEINT_MORE_OUTPUT = 1, + QSVDEINT_MORE_INPUT, + }; + + typedef struct QSVFrame { + AVFrame *frame; + mfxFrameSurface1 surface; + int used; + + struct QSVFrame *next; + } QSVFrame; + + typedef struct QSVDeintContext { + const AVClass *class; + + AVBufferRef *hw_frames_ctx; + /* a clone of the main session, used internally for deinterlacing */ + mfxSession session; + + mfxMemId *mem_ids; + int nb_mem_ids; + + mfxFrameSurface1 **surface_ptrs; + int nb_surface_ptrs; + + mfxExtOpaqueSurfaceAlloc opaque_alloc; + mfxExtBuffer *ext_buffers[1]; + + QSVFrame *work_frames; + + int64_t last_pts; + - int got_output_frame; + int eof; + } QSVDeintContext; + + static void qsvdeint_uninit(AVFilterContext *ctx) + { + QSVDeintContext *s = ctx->priv; + QSVFrame *cur; + + if (s->session) { + MFXClose(s->session); + s->session = NULL; + } + av_buffer_unref(&s->hw_frames_ctx); + + cur = s->work_frames; + while (cur) { + s->work_frames = cur->next; + av_frame_free(&cur->frame); + av_freep(&cur); + cur = s->work_frames; + } + + av_freep(&s->mem_ids); + s->nb_mem_ids = 0; + + av_freep(&s->surface_ptrs); + s->nb_surface_ptrs = 0; + } + + static int qsvdeint_query_formats(AVFilterContext *ctx) + { + static const enum AVPixelFormat pixel_formats[] = { + AV_PIX_FMT_QSV, AV_PIX_FMT_NONE, + }; + AVFilterFormats *pix_fmts = ff_make_format_list(pixel_formats); ++ int ret; + - ff_set_common_formats(ctx, pix_fmts); ++ if ((ret = ff_set_common_formats(ctx, pix_fmts)) < 0) ++ return ret; + + return 0; + } + + static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req, + mfxFrameAllocResponse *resp) + { + AVFilterContext *ctx = pthis; + QSVDeintContext *s = ctx->priv; + + 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; + + resp->mids = s->mem_ids; + resp->NumFrameActual = s->nb_mem_ids; + + 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 const mfxHandleType handle_types[] = { + MFX_HANDLE_VA_DISPLAY, + MFX_HANDLE_D3D9_DEVICE_MANAGER, + MFX_HANDLE_D3D11_DEVICE, + }; + + static int init_out_session(AVFilterContext *ctx) + { + + QSVDeintContext *s = ctx->priv; + AVHWFramesContext *hw_frames_ctx = (AVHWFramesContext*)s->hw_frames_ctx->data; + AVQSVFramesContext *hw_frames_hwctx = hw_frames_ctx->hwctx; + AVQSVDeviceContext *device_hwctx = hw_frames_ctx->device_ctx->hwctx; + + int opaque = !!(hw_frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME); + + mfxHDL handle = NULL; + mfxHandleType handle_type; + mfxVersion ver; + mfxIMPL impl; + mfxVideoParam par; + mfxStatus err; + int i; + + /* extract the properties of the "master" session given to us */ + err = MFXQueryIMPL(device_hwctx->session, &impl); + if (err == MFX_ERR_NONE) + err = MFXQueryVersion(device_hwctx->session, &ver); + if (err != MFX_ERR_NONE) { + av_log(ctx, AV_LOG_ERROR, "Error querying the session attributes\n"); + return AVERROR_UNKNOWN; + } + + for (i = 0; i < FF_ARRAY_ELEMS(handle_types); i++) { + err = MFXVideoCORE_GetHandle(device_hwctx->session, handle_types[i], &handle); + if (err == MFX_ERR_NONE) { + handle_type = handle_types[i]; + break; + } + } + + /* create a "slave" session with those same properties, to be used for + * actual deinterlacing */ + err = MFXInit(impl, &ver, &s->session); + if (err != MFX_ERR_NONE) { + av_log(ctx, AV_LOG_ERROR, "Error initializing a session for deinterlacing\n"); + return AVERROR_UNKNOWN; + } + + if (handle) { + err = MFXVideoCORE_SetHandle(s->session, handle_type, handle); + if (err != MFX_ERR_NONE) + return AVERROR_UNKNOWN; + } + + memset(&par, 0, sizeof(par)); + + if (opaque) { + s->surface_ptrs = av_mallocz_array(hw_frames_hwctx->nb_surfaces, + sizeof(*s->surface_ptrs)); + if (!s->surface_ptrs) + return AVERROR(ENOMEM); + for (i = 0; i < hw_frames_hwctx->nb_surfaces; i++) + s->surface_ptrs[i] = hw_frames_hwctx->surfaces + i; + s->nb_surface_ptrs = hw_frames_hwctx->nb_surfaces; + + s->opaque_alloc.In.Surfaces = s->surface_ptrs; + s->opaque_alloc.In.NumSurface = s->nb_surface_ptrs; + s->opaque_alloc.In.Type = hw_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; + + par.ExtParam = s->ext_buffers; + par.NumExtParam = FF_ARRAY_ELEMS(s->ext_buffers); + + par.IOPattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY | MFX_IOPATTERN_OUT_OPAQUE_MEMORY; + } else { + mfxFrameAllocator frame_allocator = { + .pthis = ctx, + .Alloc = frame_alloc, + .Lock = frame_lock, + .Unlock = frame_unlock, + .GetHDL = frame_get_hdl, + .Free = frame_free, + }; + + s->mem_ids = av_mallocz_array(hw_frames_hwctx->nb_surfaces, + sizeof(*s->mem_ids)); + if (!s->mem_ids) + return AVERROR(ENOMEM); + for (i = 0; i < hw_frames_hwctx->nb_surfaces; i++) + s->mem_ids[i] = hw_frames_hwctx->surfaces[i].Data.MemId; + s->nb_mem_ids = hw_frames_hwctx->nb_surfaces; + + err = MFXVideoCORE_SetFrameAllocator(s->session, &frame_allocator); + if (err != MFX_ERR_NONE) + return AVERROR_UNKNOWN; + + par.IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY; + } + + par.AsyncDepth = 1; // TODO async + + par.vpp.In = hw_frames_hwctx->surfaces[0].Info; + + par.vpp.In.CropW = ctx->inputs[0]->w; + par.vpp.In.CropH = ctx->inputs[0]->h; + + if (ctx->inputs[0]->frame_rate.num) { + par.vpp.In.FrameRateExtN = ctx->inputs[0]->frame_rate.num; + par.vpp.In.FrameRateExtD = ctx->inputs[0]->frame_rate.den; + } else { + par.vpp.In.FrameRateExtN = ctx->inputs[0]->time_base.num; + par.vpp.In.FrameRateExtD = ctx->inputs[0]->time_base.den; + } + + par.vpp.Out = par.vpp.In; + + if (ctx->outputs[0]->frame_rate.num) { + par.vpp.Out.FrameRateExtN = ctx->outputs[0]->frame_rate.num; + par.vpp.Out.FrameRateExtD = ctx->outputs[0]->frame_rate.den; + } else { + par.vpp.Out.FrameRateExtN = ctx->outputs[0]->time_base.num; + par.vpp.Out.FrameRateExtD = ctx->outputs[0]->time_base.den; + } + + err = MFXVideoVPP_Init(s->session, &par); + if (err != MFX_ERR_NONE) { + av_log(ctx, AV_LOG_ERROR, "Error opening the VPP for deinterlacing: %d\n", err); + return AVERROR_UNKNOWN; + } + + return 0; + } + + static int qsvdeint_config_props(AVFilterLink *outlink) + { + AVFilterContext *ctx = outlink->src; + AVFilterLink *inlink = ctx->inputs[0]; + QSVDeintContext *s = ctx->priv; + int ret; + + qsvdeint_uninit(ctx); + + s->last_pts = AV_NOPTS_VALUE; + outlink->frame_rate = av_mul_q(inlink->frame_rate, + (AVRational){ 2, 1 }); + outlink->time_base = av_mul_q(inlink->time_base, + (AVRational){ 1, 2 }); + + /* check that we have a hw context */ + if (!inlink->hw_frames_ctx) { + av_log(ctx, AV_LOG_ERROR, "No hw context provided on input\n"); + return AVERROR(EINVAL); + } + + s->hw_frames_ctx = av_buffer_ref(inlink->hw_frames_ctx); + if (!s->hw_frames_ctx) + return AVERROR(ENOMEM); + + av_buffer_unref(&outlink->hw_frames_ctx); + outlink->hw_frames_ctx = av_buffer_ref(inlink->hw_frames_ctx); + if (!outlink->hw_frames_ctx) { + qsvdeint_uninit(ctx); + return AVERROR(ENOMEM); + } + + ret = init_out_session(ctx); + if (ret < 0) + return ret; + + + return 0; + } + + static void clear_unused_frames(QSVDeintContext *s) + { + QSVFrame *cur = s->work_frames; + while (cur) { + if (!cur->surface.Data.Locked) { + av_frame_free(&cur->frame); + cur->used = 0; + } + cur = cur->next; + } + } + + static int get_free_frame(QSVDeintContext *s, QSVFrame **f) + { + QSVFrame *frame, **last; + + clear_unused_frames(s); + + frame = s->work_frames; + last = &s->work_frames; + while (frame) { + if (!frame->used) { + *f = frame; + return 0; + } + + last = &frame->next; + frame = frame->next; + } + + frame = av_mallocz(sizeof(*frame)); + if (!frame) + return AVERROR(ENOMEM); + *last = frame; + *f = frame; + + return 0; + } + + static int submit_frame(AVFilterContext *ctx, AVFrame *frame, + mfxFrameSurface1 **surface) + { + QSVDeintContext *s = ctx->priv; + QSVFrame *qf; + int ret; + + ret = get_free_frame(s, &qf); + if (ret < 0) + return ret; + + qf->frame = frame; + + qf->surface = *(mfxFrameSurface1*)qf->frame->data[3]; + + qf->surface.Data.Locked = 0; + qf->surface.Info.CropW = qf->frame->width; + qf->surface.Info.CropH = qf->frame->height; + + qf->surface.Info.PicStruct = !qf->frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE : + (qf->frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF : + MFX_PICSTRUCT_FIELD_BFF); + if (qf->frame->repeat_pict == 1) + qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED; + else if (qf->frame->repeat_pict == 2) + qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING; + else if (qf->frame->repeat_pict == 4) + qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING; + + if (ctx->inputs[0]->frame_rate.num) { + qf->surface.Info.FrameRateExtN = ctx->inputs[0]->frame_rate.num; + qf->surface.Info.FrameRateExtD = ctx->inputs[0]->frame_rate.den; + } else { + qf->surface.Info.FrameRateExtN = ctx->inputs[0]->time_base.num; + qf->surface.Info.FrameRateExtD = ctx->inputs[0]->time_base.den; + } + + qf->surface.Data.TimeStamp = av_rescale_q(qf->frame->pts, + ctx->inputs[0]->time_base, + (AVRational){1, 90000}); + + *surface = &qf->surface; + qf->used = 1; + + return 0; + } + + static int process_frame(AVFilterContext *ctx, const AVFrame *in, + mfxFrameSurface1 *surf_in) + { + QSVDeintContext *s = ctx->priv; + AVFilterLink *inlink = ctx->inputs[0]; + AVFilterLink *outlink = ctx->outputs[0]; + + AVFrame *out; + mfxFrameSurface1 *surf_out; + mfxSyncPoint sync = NULL; + mfxStatus err; + int ret, again = 0; + + out = av_frame_alloc(); + if (!out) + return AVERROR(ENOMEM); + + ret = av_hwframe_get_buffer(s->hw_frames_ctx, out, 0); + if (ret < 0) + goto fail; + + surf_out = (mfxFrameSurface1*)out->data[3]; + surf_out->Info.CropW = outlink->w; + surf_out->Info.CropH = outlink->h; + surf_out->Info.PicStruct = MFX_PICSTRUCT_PROGRESSIVE; + + do { + err = MFXVideoVPP_RunFrameVPPAsync(s->session, surf_in, surf_out, + NULL, &sync); + if (err == MFX_WRN_DEVICE_BUSY) + av_usleep(1); + } while (err == MFX_WRN_DEVICE_BUSY); + + if (err == MFX_ERR_MORE_DATA) { + av_frame_free(&out); + return QSVDEINT_MORE_INPUT; + } + + if ((err < 0 && err != MFX_ERR_MORE_SURFACE) || !sync) { + av_log(ctx, AV_LOG_ERROR, "Error during deinterlacing: %d\n", err); + ret = AVERROR_UNKNOWN; + goto fail; + } + if (err == MFX_ERR_MORE_SURFACE) + again = 1; + + do { + err = MFXVideoCORE_SyncOperation(s->session, sync, 1000); + } while (err == MFX_WRN_IN_EXECUTION); + if (err < 0) { + av_log(ctx, AV_LOG_ERROR, "Error synchronizing the operation: %d\n", err); + ret = AVERROR_UNKNOWN; + goto fail; + } + + ret = av_frame_copy_props(out, in); + if (ret < 0) + goto fail; + + out->width = outlink->w; + out->height = outlink->h; + out->interlaced_frame = 0; + + out->pts = av_rescale_q(out->pts, inlink->time_base, outlink->time_base); + if (out->pts == s->last_pts) + out->pts++; + s->last_pts = out->pts; + + ret = ff_filter_frame(outlink, out); + if (ret < 0) + return ret; + + return again ? QSVDEINT_MORE_OUTPUT : 0; + fail: + av_frame_free(&out); + return ret; + } + + static int qsvdeint_filter_frame(AVFilterLink *link, AVFrame *in) + { + AVFilterContext *ctx = link->dst; + + mfxFrameSurface1 *surf_in; + int ret; + + ret = submit_frame(ctx, in, &surf_in); + if (ret < 0) { + av_frame_free(&in); + return ret; + } + + do { + ret = process_frame(ctx, in, surf_in); + if (ret < 0) + return ret; + } while (ret == QSVDEINT_MORE_OUTPUT); + + return 0; + } + + static int qsvdeint_request_frame(AVFilterLink *outlink) + { + AVFilterContext *ctx = outlink->src; - QSVDeintContext *s = ctx->priv; - int ret = 0; + - s->got_output_frame = 0; - while (ret >= 0 && !s->got_output_frame) - ret = ff_request_frame(ctx->inputs[0]); - - return ret; ++ return ff_request_frame(ctx->inputs[0]); + } + + #define OFFSET(x) offsetof(QSVDeintContext, x) + #define FLAGS AV_OPT_FLAG_VIDEO_PARAM + static const AVOption options[] = { + { NULL }, + }; + + static const AVClass qsvdeint_class = { + .class_name = "deinterlace_qsv", + .item_name = av_default_item_name, + .option = options, + .version = LIBAVUTIL_VERSION_INT, + }; + + static const AVFilterPad qsvdeint_inputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .filter_frame = qsvdeint_filter_frame, + }, + { NULL } + }; + + static const AVFilterPad qsvdeint_outputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .config_props = qsvdeint_config_props, + .request_frame = qsvdeint_request_frame, + }, + { NULL } + }; + + AVFilter ff_vf_deinterlace_qsv = { + .name = "deinterlace_qsv", + .description = NULL_IF_CONFIG_SMALL("QuickSync video deinterlacing"), + + .uninit = qsvdeint_uninit, + .query_formats = qsvdeint_query_formats, + + .priv_size = sizeof(QSVDeintContext), + .priv_class = &qsvdeint_class, + + .inputs = qsvdeint_inputs, + .outputs = qsvdeint_outputs, + }; _______________________________________________ ffmpeg-cvslog mailing list ffmpeg-cvslog@ffmpeg.org http://ffmpeg.org/mailman/listinfo/ffmpeg-cvslog
