videofilter.cpp

// SPDX-License-Identifier: AGPL-3.0-or-later

/**
 * @file videofilter.cpp
 * Deinterlace and Scaling Filters
 *
 * @copyright 2009 - 2015 by Johns.  All Rights Reserved.
 * @copyright 2018 by zille.  All Rights Reserved.
 * @copyright 2025 - 2026 by Andreas Baierl. All Rights Reserved.
 *
 * @license{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/thread.h>

#include "logger.h"
#include "misc.h"
#include "videofilter.h"
#include "videorender.h"

/**
 * Initiate Filter
 *
 * @param videoRender     renderer
 * @param drmBufferQueue  drm buffer queue
 * @param name            stream name
 * @param frameOutput     frame output function
 */
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)
{
}

/**
 * Setup the filter output pixel format
 *
 * @param pixFmt            AV pixel format
 */
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);
}

/**
 * Init and start the video filter thread
 *
 * @param videoCtx               codec context
 * @param frame                  AVFrame to take init parameters from
 * @param enableDeinterlacer     true, if the deinterlacer should be used
 */
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;
	m_filterBug = false;

	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";
			m_filterBug = true;
		}
	} 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();
}

/**
 * Main filter thread loop
 *
 * Pops unfiltered frames from the input queue, processes them and sends the filtered frames to the render queue
 */
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()) {
				if (filtFrame->format == AV_PIX_FMT_NV12 && m_filterBug) // scale filter or sw deinterlacer, no prime data, always returns NV12
					filtFrame->pts /= 2; // ffmpeg bug

				m_frameOutput(filtFrame);
			} else
				av_frame_free(&filtFrame);
		}
	}
	LOGDEBUG("video filter: thread stopped");
}

/**
 * Puts a frame in the buffer to be filtered
 */
void cVideoFilter::PushFrame(AVFrame *frame)
{
	m_frames.Push(frame);
}

/**
 * Stops the filter thread and does a cleanup
 */
void cVideoFilter::Stop(void)
{
	if (!Active())
		return;

	LOGDEBUG("video filter: stopping thread");
	Cancel(2);
	m_filterBug = false;
	m_numFramesToFilter = 0;

	while (!m_frames.IsEmpty()) {
		AVFrame *frame = m_frames.Pop();
		av_frame_free(&frame);
	}

	avfilter_graph_free(&m_pFilterGraph);
}