threads.cpp

Go to the documentation of this file.

 
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavfilter/buffersink.h>
#include <libavfilter/buffersrc.h>
#include <libavutil/opt.h>
}
 
#include "vdr/thread.h"
 
#include "audio.h"
#include "logger.h"
#include "misc.h"
#include "threads.h"
#include "videorender.h"
#include "videostream.h"
 
/*****************************************************************************
 * cDecodingThread class
 *
 * This thread decodes the video data
 ****************************************************************************/
cDecodingThread::cDecodingThread(cVideoStream *stream, const char *name)
    : cThread(name),
      m_pStream(stream)
{
    Start();
}
 
void cDecodingThread::Action(void)
{
    LOGDEBUG("threads: decoding thread started");
    while(Running()) {
        m_mutex.lock();
 
        m_pStream->DecodeInput();
 
        m_mutex.unlock();
 
        usleep(1000);
    }
    LOGDEBUG("threads: decoding thread stopped");
}
 
void cDecodingThread::Stop(void)
{
    if (!Active())
        return;
 
    LOGDEBUG("threads: stopping decoding thread");
    Cancel(2);
}
 
/*****************************************************************************
 * cDisplayThread class
 *
 * This thread is responsible for displaying the video and osd
 ****************************************************************************/
cDisplayThread::cDisplayThread(cVideoRender *render)
    : cThread("softhd display"),
      m_pRender(render)
{
    Start();
}
 
void cDisplayThread::Action(void)
{
    LOGDEBUG("threads: display thread started");
    while(Running()) {
        m_mutex.lock();
 
        bool scheduleImmediately = m_pRender->DisplayFrame();
 
        m_mutex.unlock();
 
        m_pRender->ProcessEvents();
 
        if (scheduleImmediately)
            usleep(100); // yield thread. give control also to threads with lower priority.
        else
            usleep(1000);
    }
    LOGDEBUG("threads: display thread stopped");
}
 
void cDisplayThread::Stop(void)
{
    if (!Active())
        return;
 
    LOGDEBUG("threads: stopping display thread");
    Cancel(2);
}
 
/*****************************************************************************
 * cAudioThread class
 *
 * This thread is decodes the audio data and moves it to hardware
 ****************************************************************************/
cAudioThread::cAudioThread(cSoftHdAudio *audio)
    : cThread("softhd audio"),
      m_pAudio(audio)
{
    Start();
}
 
void cAudioThread::Action(void)
{
    LOGDEBUG("threads: audio thread started");
    while (Running()) {
        m_pAudio->CyclicCall();
        m_pAudio->ProcessEvents();
 
        usleep(10000);
    }
    LOGDEBUG("threads: audio thread stopped");
}
 
void cAudioThread::Stop(void)
{
    if (!Active())
        return;
 
    LOGDEBUG("threads: stopping audio thread");
    Cancel(2);
}
 
/*****************************************************************************
 * cFilterThread class
 *
 * This thread handles video filters like deinterlacer or scale filter
 ****************************************************************************/
cFilterThread::cFilterThread(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 cFilterThread::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("filter thread: %s: Cannot set output pixel format (%d)", __FUNCTION__, ret);
}
 
void cFilterThread::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("filter thread: %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("filter thread: %s: Unexpected pixel format: %d", __FUNCTION__, frame->format);
 
    m_pBuffersinkCtx = avfilter_graph_alloc_filter(m_pFilterGraph, buffersink, "out");
    if (!m_pBuffersinkCtx)
        LOGFATAL("filter thread: %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, "filter thread: %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("filter thread: %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, "filter thread: %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("filter thread: %s: Cannot av_buffersrc_parameters_set (%d)", __FUNCTION__, ret);
 
        av_free(par);
 
        ret = avfilter_init_dict(m_pBuffersrcCtx, NULL);
        if (ret < 0)
            LOGFATAL("filter thread: %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, "filter thread: %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("filter thread: %s: Cannot create buffer src", __FUNCTION__);
    }
 
    ret = avfilter_init_dict(m_pBuffersinkCtx, NULL);
    if (ret < 0)
        LOGFATAL("filter thread: %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("filter thread: %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("filter thread: %s: avfilter_graph_config failed (%d)", __FUNCTION__, ret);
 
    Start();
}
 
void cFilterThread::Action(void)
{
    LOGDEBUG("threads: 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("filter thread: %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("filter thread: %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("filter thread: %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("threads: filter thread stopped");
}
 
void cFilterThread::PushFrame(AVFrame *frame)
{
    m_frames.Push(frame);
}
 
void cFilterThread::Stop(void)
{
    if (!Active())
        return;
 
    LOGDEBUG("threads: stopping filter 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);
}