videofilter.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavfilter/buffersink.h>
#include <libavfilter/buffersrc.h>
#include <libavutil/opt.h>
}
 
#include <vdr/remux.h>
#include <vdr/thread.h>
 
#include "logger.h"
#include "misc.h"
#include "videofilter.h"
#include "videorender.h"
 
cVideoFilter::cVideoFilter(cVideoRender *videoRender, cQueue<cDrmBuffer> *drmBufferQueue, const char *name, std::function<void(AVFrame *)> frameOutput)
    : cThread(name),
      m_pRender(videoRender),
      m_frameOutput(frameOutput),
      m_pDrmBufferQueue(drmBufferQueue)
{
}
 
void cVideoFilter::SetFilterOutputPixFormat(AVPixelFormat pixFmt)
{
    int ret;
    enum AVPixelFormat pixFmts[] = { pixFmt, AV_PIX_FMT_NONE };
 
#if LIBAVFILTER_BUILD >= AV_VERSION_INT(10, 6, 100)
    ret = av_opt_set_array(m_pBuffersinkCtx, "pixel_formats",
        AV_OPT_SEARCH_CHILDREN, 0, sizeof(pixFmts) / sizeof(pixFmts[0]) - 1, AV_OPT_TYPE_PIXEL_FMT, pixFmts);
#else
    ret = av_opt_set_int_list(m_pBuffersinkCtx, "pix_fmts",
        pixFmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN);
#endif
 
    if (ret < 0)
        LOGFATAL("video filter: %s: Cannot set output pixel format (%d)", __FUNCTION__, ret);
}
 
void cVideoFilter::InitAndStart(const AVCodecContext *videoCtx, AVFrame *frame, bool enableDeinterlacer)
{
    int ret;
    char args[512];
    const char *filterDescr = NULL;
    m_pFilterGraph = avfilter_graph_alloc();
    if (!m_pFilterGraph)
        LOGFATAL("video filter: %s: Cannot alloc filter graph", __FUNCTION__);
 
    m_numFramesToFilter = 0;
 
    const AVFilter *buffersrc  = avfilter_get_by_name("buffer");
    const AVFilter *buffersink = avfilter_get_by_name("buffersink");
 
#if LIBAVFILTER_VERSION_INT < AV_VERSION_INT(7,16,100)
    avfilter_register_all();
#endif
 
    // interlaced and non-trickspeed AV_PIX_FMT_DRM_PRIME (hardware decoded) -> hardware deinterlacer
    // interlaced and non-trickspeed AV_PIX_FMT_YUV420P (software decoded) -> software deinterlacer
    // progressive and trickspeed AV_PIX_FMT_YUV420P (software decoded) -> scale filter (for NV12 output)
    // progressive and trickspeed AV_PIX_FMT_DRM_PRIME (hardware decoded) doesn't get to the FilterHandlerThread
    if (enableDeinterlacer) {
        if (frame->format == AV_PIX_FMT_DRM_PRIME) {
            filterDescr = "deinterlace_v4l2m2m";
        } else if (frame->format == AV_PIX_FMT_YUV420P) {
            filterDescr = "bwdif=1:-1:0";
        }
    } else if (frame->format == AV_PIX_FMT_YUV420P) {
        filterDescr = "scale";
    } else
        LOGFATAL("video filter: %s: Unexpected pixel format: %d", __FUNCTION__, frame->format);
 
    m_pBuffersinkCtx = avfilter_graph_alloc_filter(m_pFilterGraph, buffersink, "out");
    if (!m_pBuffersinkCtx)
        LOGFATAL("video filter: %s: Cannot create buffer sink", __FUNCTION__);
 
    // if we have a 576i stream without a valid sample_aspect_ratio (0/1) force it to be 64/45
    // wich "stretches" a 576i stream to 1920/1080 size
    // this was observed with h264 coded 576i vodafone DVB-C channels and some mpeg2 576i material
    AVRational sar = videoCtx->sample_aspect_ratio;
    if (videoCtx->sample_aspect_ratio.num == 0 && videoCtx->height == 576) {
        sar = (AVRational){64, 45};
        LOGDEBUG2(L_CODEC, "video filter: %s: Observed 576i material with a sar 0/1, stretch it with sar %d/%d", __FUNCTION__, sar.num, sar.den);
    }
 
    if (frame->format == AV_PIX_FMT_DRM_PRIME) {
        SetFilterOutputPixFormat(AV_PIX_FMT_DRM_PRIME);
 
        m_pBuffersrcCtx = avfilter_graph_alloc_filter(m_pFilterGraph, buffersrc, "in");
        if (!m_pBuffersrcCtx)
            LOGFATAL("video filter: %s: Cannot create buffer src", __FUNCTION__);
 
        AVBufferSrcParameters *par = av_buffersrc_parameters_alloc();
        memset(par, 0, sizeof(*par));
 
        par->format = AV_PIX_FMT_DRM_PRIME;
        par->hw_frames_ctx = frame->hw_frames_ctx;
        par->time_base = videoCtx->pkt_timebase;
        par->width = videoCtx->width;
        par->height = videoCtx->height;
        par->sample_aspect_ratio = sar;
 
        LOGDEBUG2(L_CODEC, "video filter: %s: filter=\"%s\" fmt %d, hw ctx %p, tb %d/%d, wxh %dx%d, sar %d/%d",
            __FUNCTION__, filterDescr,
            par->format, par->hw_frames_ctx, par->time_base.num, par->time_base.den,
            par->width, par->height, par->sample_aspect_ratio.num, par->sample_aspect_ratio.den);
 
        ret = av_buffersrc_parameters_set(m_pBuffersrcCtx, par);
        if (ret < 0)
            LOGFATAL("video filter: %s: Cannot av_buffersrc_parameters_set (%d)", __FUNCTION__, ret);
 
        av_free(par);
 
        ret = avfilter_init_dict(m_pBuffersrcCtx, NULL);
        if (ret < 0)
            LOGFATAL("video filter: %s: Cannot initialize buffer src (%d)", __FUNCTION__, ret);
    } else {
        SetFilterOutputPixFormat(AV_PIX_FMT_NV12);
 
        snprintf(args, sizeof(args), "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
            videoCtx->width, videoCtx->height, frame->format,
            videoCtx->pkt_timebase.num ? videoCtx->pkt_timebase.num : 1,
            videoCtx->pkt_timebase.num ? videoCtx->pkt_timebase.den : 1,
            sar.num, sar.den);
 
        LOGDEBUG2(L_CODEC, "video filter: %s: filter=\"%s\" args=\"%s\"", __FUNCTION__, filterDescr, args);
 
        ret = avfilter_graph_create_filter(&m_pBuffersrcCtx, buffersrc, "in", args, NULL, m_pFilterGraph);
        if (ret < 0)
            LOGFATAL("video filter: %s: Cannot create buffer src", __FUNCTION__);
    }
 
    ret = avfilter_init_dict(m_pBuffersinkCtx, NULL);
    if (ret < 0)
        LOGFATAL("video filter: %s: Cannot initialize buffer sink (%d)", __FUNCTION__, ret);
 
    AVFilterInOut *outputs = avfilter_inout_alloc();
    AVFilterInOut *inputs  = avfilter_inout_alloc();
 
    outputs->name       = av_strdup("in");
    outputs->filter_ctx = m_pBuffersrcCtx;
    outputs->pad_idx    = 0;
    outputs->next       = NULL;
 
    inputs->name       = av_strdup("out");
    inputs->filter_ctx = m_pBuffersinkCtx;
    inputs->pad_idx    = 0;
    inputs->next       = NULL;
 
    ret = avfilter_graph_parse_ptr(m_pFilterGraph, filterDescr, &inputs, &outputs, NULL);
    if (ret < 0) {
        LOGFATAL("video filter: %s: avfilter_graph_parse_ptr failed (%d)", __FUNCTION__, ret);
    }
 
    avfilter_inout_free(&inputs);
    avfilter_inout_free(&outputs);
 
    ret = avfilter_graph_config(m_pFilterGraph, NULL);
    if (ret < 0)
        LOGFATAL("video filter: %s: avfilter_graph_config failed (%d)", __FUNCTION__, ret);
 
    Start();
}
 
void cVideoFilter::Action(void)
{
    LOGDEBUG("video filter: thread started");
 
    while (Running()) {
        if (m_frames.IsEmpty()) {
            usleep(1000);
            continue;
        }
 
        AVFrame *frame = m_frames.Pop();
 
        m_numFramesToFilter++;
        if (isInterlacedFrame(frame))
            m_numFramesToFilter++;
 
        // add frame to filter
        int ret;
        if ((ret = av_buffersrc_add_frame_flags(m_pBuffersrcCtx, frame, AV_BUFFERSRC_FLAG_KEEP_REF)) < 0)
            LOGWARNING("video filter: %s: can't add_frame: %s", __FUNCTION__, av_err2str(ret));
 
        av_frame_free(&frame);
 
        // get filtered frames
        while (Running()) {
            AVFrame *filtFrame = av_frame_alloc();
            if (!filtFrame)
                LOGFATAL("video filter: %s: can't allocate frame", __FUNCTION__);
 
            ret = av_buffersink_get_frame(m_pBuffersinkCtx, filtFrame);
 
            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                av_frame_free(&filtFrame);
                break;
            } else if (ret < 0) {
                LOGERROR("video filter: %s: can't get filtered frame: %s", __FUNCTION__, av_err2str(ret));
                av_frame_free(&filtFrame);
                break;
            }
 
            while (Running() && m_pDrmBufferQueue->IsFull())
                usleep(1000);
 
            if (Running()) {
                // The sink's timebase may differ from the source's one.
                // For example it's 1/180000 in case of bwdif deinterlacer.
                // Rescale the pts and duration and set the original timebase again.
                constexpr AVRational timebase { .num = 1, .den = PTSTICKS };
                const AVRational sinkTimebase = av_buffersink_get_time_base(m_pBuffersinkCtx);
 
                if (filtFrame->pts != AV_NOPTS_VALUE)
                    filtFrame->pts = av_rescale_q(filtFrame->pts, sinkTimebase, timebase);
                if (filtFrame->duration > 0)
                    filtFrame->duration = av_rescale_q(filtFrame->duration, sinkTimebase, timebase);
 
                filtFrame->time_base = timebase;
 
                m_frameOutput(filtFrame);
            } else
                av_frame_free(&filtFrame);
        }
    }
    LOGDEBUG("video filter: thread stopped");
}
 
void cVideoFilter::PushFrame(AVFrame *frame)
{
    m_frames.Push(frame);
}
 
void cVideoFilter::Stop(void)
{
    if (!Active())
        return;
 
    LOGDEBUG("video filter: stopping thread");
    Cancel(2);
    m_numFramesToFilter = 0;
 
    while (!m_frames.IsEmpty()) {
        AVFrame *frame = m_frames.Pop();
        av_frame_free(&frame);
    }
 
    avfilter_graph_free(&m_pFilterGraph);
}