videostream.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
#include <functional>
#include <set>
#include <string>
#include <vector>
 
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/timestamp.h>
}
 
#include <vdr/thread.h>
 
#include "codec_video.h"
#include "config.h"
#include "h264parser.h"
#include "logger.h"
#include "misc.h"
#include "queue.h"
#include "videofilter.h"
#include "videostream.h"
#include "videorender.h"
 
static size_t ReadLineFromFile(char *buf, size_t size, const char * file)
{
    FILE *fd = NULL;
    size_t character;
 
    fd = fopen(file, "r");
    if (fd == NULL) {
        LOGERROR("videostream: %s: Can't open %s", __FUNCTION__, file);
        return 0;
    }
 
    character = getline(&buf, &size, fd);
 
    fclose(fd);
 
    return character;
}
 
static int ReadHWPlatform(void)
{
    char *txt_buf;
    char *read_ptr;
    size_t bufsize = 128;
    size_t read_size;
 
    txt_buf = (char *) calloc(bufsize, sizeof(char));
    int hardwareQuirks = 0;
 
    read_size = ReadLineFromFile(txt_buf, bufsize, "/sys/firmware/devicetree/base/compatible");
    if (!read_size) {
        free((void *)txt_buf);
        return 0;
    }
 
    read_ptr = txt_buf;
    // be aware: device tree string can contain \x0 bytes, so every C-string function
    // thinks, we already reached the string's terminating null bytes
    // so copy the string into a temporary string without the "\0"
    char *_txt_buf = (char *) calloc(bufsize, sizeof(char));
    char *_read_ptr = _txt_buf;
    for (size_t i = 0; i < bufsize; i++) {
        if (memcmp(read_ptr, "\0", sizeof(char))) {
            memcpy(_read_ptr, read_ptr, sizeof(char));
            _read_ptr++;
        }
        read_ptr++;
    }
 
    read_ptr = txt_buf;
    LOGDEBUG2(L_DRM, "videostream: %s: found \"%s\", set hardware quirks", __FUNCTION__, _txt_buf);
 
    while(read_size) {
        if (strstr(read_ptr, "bcm2836")) {
            LOGDEBUG2(L_DRM, "videostream: %s: bcm2836 (Raspberry Pi 2 Model B) found", __FUNCTION__);
            hardwareQuirks |= QUIRK_CODEC_FLUSH_WORKAROUND;
            break;
        }
        if (strstr(read_ptr, "bcm2837")) {
            LOGDEBUG2(L_DRM, "videostream: %s: bcm2837 (Raspberry Pi 2 Model B v1.2/ 3 Model B, Raspberry Pi 3 Compute Module 3) found", __FUNCTION__);
            hardwareQuirks |= QUIRK_CODEC_FLUSH_WORKAROUND;
            break;
        }
        if (strstr(read_ptr, "bcm2711")) {
            LOGDEBUG2(L_DRM, "videostream: %s: bcm2711 (Raspberry Pi 4 Model B, Compute Module 4, Pi 400) found", __FUNCTION__);
            hardwareQuirks |= QUIRK_CODEC_FLUSH_WORKAROUND;
            break;
        }
        if (strstr(read_ptr, "bcm2712")) {
            LOGDEBUG2(L_DRM, "videostream: %s: bcm2712 (Raspberry Pi 5, Compute Module 5, Pi 500) found", __FUNCTION__);
            hardwareQuirks |= QUIRK_CODEC_FLUSH_WORKAROUND;
            break;
        }
        if (strstr(read_ptr, "amlogic")) {
            LOGDEBUG2(L_DRM, "videostream: %s: amlogic found, disable HW deinterlacer", __FUNCTION__);
            hardwareQuirks |= QUIRK_CODEC_NEEDS_EXT_INIT
                           |  QUIRK_CODEC_SKIP_FIRST_FRAMES
                           |  QUIRK_NO_HW_DEINT;
            break;
        }
 
        read_size -= (strlen(read_ptr) + 1);
        read_ptr = (char *)&read_ptr[(strlen(read_ptr) + 1)];
    }
    free((void *)_txt_buf);
    free((void *)txt_buf);
 
    return hardwareQuirks;
}
 
/*****************************************************************************
 * cVideoStream class
 ****************************************************************************/
 
cVideoStream::cVideoStream(cVideoRender *render, cQueue<cDrmBuffer> *drmBufferQueue, cSoftHdConfig *config, bool isPipStream, std::function<void(AVFrame *)> frameOutput)
    : cThread(isPipStream ? "shd PIP decode" : "shd main decode"),
      m_pConfig(config),
      m_pDecoder(nullptr),
      m_pRender(render),
      m_identifier(isPipStream ? "PIP" : "main"),
      m_frameOutput(frameOutput),
      m_pDrmBufferQueue(drmBufferQueue),
      m_videoFilter(render, m_pDrmBufferQueue, isPipStream ? "shd PIP filter" : "shd main filter", frameOutput),
      m_userDisabledDeinterlacer(config->ConfigDisableDeint),
      m_deinterlacerDeactivated(isPipStream ? true : false),
      m_startDecodingWithIFrame(config->ConfigDecoderNeedsIFrame),
      m_parseH264Dimensions(config->ConfigParseH264Dimensions)
{
    m_hardwareQuirks = ReadHWPlatform();
    m_decoderFallbackToSwNumPkts = config->ConfigDecoderFallbackToSw ? config->ConfigDecoderFallbackToSwNumPkts : 0;
 
    LOGDEBUG("videostream %s: %s", __FUNCTION__, m_identifier);
    if (m_decoderFallbackToSwNumPkts)
        LOGDEBUG2(L_CODEC, "videostream %s: %s: fallback to sw decoder after %d packets sent", __FUNCTION__, m_identifier, m_decoderFallbackToSwNumPkts);
}
 
cVideoStream::~cVideoStream(void)
{
    LOGDEBUG("videostream %s:", __FUNCTION__);
}
 
void cVideoStream::Flush(void)
{
    m_packets.Push(nullptr);
}
 
bool cVideoStream::PushAvPacket(AVPacket *avpkt)
{
    if (avpkt->pts != AV_NOPTS_VALUE)
        m_inputPts = avpkt->pts;
 
    return m_packets.Push(avpkt);
}
 
int64_t cVideoStream::GetInputPtsMs(void)
{
    return m_inputPts * 1000 * av_q2d(m_timebase);
}
 
void cVideoStream::Exit(void)
{
    LOGDEBUG("videostream %s: %s:", m_identifier, __FUNCTION__);
 
    Stop();
 
    if (m_pDecoder) {
        m_pDecoder->Close();
        delete(m_pDecoder);
        m_pDecoder = nullptr;
    }
 
    ClearVdrCoreToDecoderQueue();
}
 
void cVideoStream::ClearVdrCoreToDecoderQueue(void)
{
    LOGDEBUG("videostream %s: %s: packets %d", m_identifier, __FUNCTION__, m_packets.Size());
 
    while (!m_packets.IsEmpty()) {
        AVPacket *avpkt = m_packets.Pop();
        av_packet_free(&avpkt);
    }
 
    m_inputPts = AV_NOPTS_VALUE;
}
 
void cVideoStream::StartDecoder()
{
    LOGDEBUG2(L_CODEC, "videostream %s: %s", m_identifier, __FUNCTION__);
 
    m_pDecoder = new cVideoDecoder(m_hardwareQuirks, m_identifier);
    Start();
}
 
void cVideoStream::CloseDecoder(void)
{
    LOGDEBUG2(L_CODEC, "videostream %s: %s", m_identifier, __FUNCTION__);
 
    m_codecId = AV_CODEC_ID_NONE;
    m_pDecoder->Close();
    m_pPar = nullptr;
    m_numIFrames = 0;
    m_maxFrameNum = 1;
    m_naluTypesAtStart.clear();
    m_dpbFrames.clear();
}
 
void cVideoStream::FlushDecoder(void)
{
    LOGDEBUG2(L_CODEC, "videostream %s: %s", m_identifier, __FUNCTION__);
 
    if ((m_hardwareQuirks & QUIRK_CODEC_FLUSH_WORKAROUND) && m_pDecoder->IsHardwareDecoder()) {
        if (m_pDecoder->ReopenCodec(m_codecId, m_pPar, m_timebase, 0))
            LOGFATAL("videostream %s: %s: Could not reopen the decoder (flush)!", m_identifier, __FUNCTION__);
    } else {
        m_pDecoder->FlushBuffers();
    }
}
 
void cVideoStream::CheckForcingFrameDecode(void)
{
    int minPkts = m_interlaced ? m_trickpkts : 1;
 
    if (!m_pRender->IsForwardTrickspeed()) {
        m_sentTrickPkts++;
        if (m_sentTrickPkts >= minPkts) {
            m_pDecoder->SendPacket(NULL);
            m_sentTrickPkts = 0;
        }
    }
}
 
void cVideoStream::OpenDecoder(void)
{
    int width = 0;
    int height = 0;
 
    bool needsParsing = m_startDecodingWithIFrame ||
                        m_parseH264Dimensions ||
                       (m_hardwareQuirks & QUIRK_CODEC_NEEDS_EXT_INIT);
 
    if (needsParsing && m_codecId == AV_CODEC_ID_H264) {
        cH264Parser h264Packet(m_packets.Peek(),
                               m_log2MaxFrameNumMinus4,
                               m_ppsNumRefIdxL0DefaultActiveMinus1,
                               m_ppsNumRefIdxL1DefaultActiveMinus1);
        if (!h264Packet.HasSPS()) {
            LOGDEBUG2(L_CODEC, "videostream %s: %s: No SPS in the packet!", m_identifier, __FUNCTION__);
            h264Packet.PrintStreamData();
        }
 
        // start decoding with an I-Frame only
        if (!h264Packet.IsISlice() && m_startDecodingWithIFrame) {
            h264Packet.PrintNalUnits();
            LOGDEBUG2(L_CODEC, "videostream %s: %s: Skip h264 packet, no I-Frame!", m_identifier, __FUNCTION__);
            AVPacket *avpkt = m_packets.Pop();
            av_packet_free(&avpkt);
            return;
        }
 
        // amlogic h264 decoder needs width an height for correct decoder open
        if ((m_hardwareQuirks & QUIRK_CODEC_NEEDS_EXT_INIT) || m_parseH264Dimensions) {
            width = h264Packet.GetWidth();
            height = h264Packet.GetHeight();
            LOGDEBUG2(L_CODEC, "videostream %s: %s: Parsed width %d height %d", m_identifier, __FUNCTION__, width, height);
        }
    }
 
    if (m_pDecoder->Open(m_codecId, m_pPar, m_timebase, false, width, height))
        LOGFATAL("videostream %s: %s: Could not open the decoder!", m_identifier, __FUNCTION__);
 
    m_pConfig->CurrentDecoderType = m_pDecoder->IsHardwareDecoder() ? "hardware" : "software";
    m_pConfig->CurrentDecoderName = m_pDecoder->Name();
    m_newStream = false;
    m_logPackets = m_pConfig->ConfigParseH264StreamStart ? m_pConfig->ConfigParseH264StreamStart + 1 : 0;
    m_dropInvalidPackets = m_pConfig->ConfigDropInvalidH264PFrames ? m_pConfig->ConfigDropInvalidH264PFrames + 1 : 0;
}
 
bool cVideoStream::ParseH264Packet(AVPacket *avpkt)
{
    cH264Parser h264Packet(avpkt,
                               m_log2MaxFrameNumMinus4,
                               m_ppsNumRefIdxL0DefaultActiveMinus1,
                               m_ppsNumRefIdxL1DefaultActiveMinus1);
 
    if (h264Packet.HasSPS()) {
        m_maxFrameNum = 1 << (h264Packet.GetLog2MaxFrameNumMinus4() + 4);
        m_log2MaxFrameNumMinus4 = h264Packet.GetLog2MaxFrameNumMinus4();
    }
 
    if (h264Packet.HasPPS()) {
        m_ppsNumRefIdxL0DefaultActiveMinus1 = h264Packet.GetPpsNumRefIdxL0DefaultActiveMinus1();
        m_ppsNumRefIdxL1DefaultActiveMinus1 = h264Packet.GetPpsNumRefIdxL1DefaultActiveMinus1();
    }
 
    int frameNumber = h264Packet.GetFrameNum();
 
    if (h264Packet.IsReference()) {
        h264Packet.AddFrameNumber(frameNumber);
        m_dpbFrames.insert(frameNumber);
    } else {
        h264Packet.AddFrameNumber(-1);
    }
 
    bool dropPacket = false;
    if (h264Packet.IsPSlice() || h264Packet.IsBSlice()) {
        int numRefL0 = h264Packet.GetNumRefIdxL0Active();
        int numRefL1 = h264Packet.GetNumRefIdxL1Active();
 
        for (auto& mod : h264Packet.GetRefMods()) {
            if (mod.idc != 0 && mod.idc != 1)
                continue;
 
            int activeRefs = (mod.list == 0) ? numRefL0 : numRefL1;
            if (activeRefs <= 0)
                continue;
 
            // Compute the short-term reference frame number
            int modRef = -1;
            int diff = mod.abs_diff_pic_num_minus1 + 1;
 
            if (mod.idc == 0) { // subtraction
                modRef = (frameNumber - diff + m_maxFrameNum) % m_maxFrameNum;
            } else if (mod.idc == 1) { // addition
                modRef = (frameNumber + diff) % m_maxFrameNum;
            }
 
            // Check if this reference exists in the DPB
            if (m_dpbFrames.find(modRef) == m_dpbFrames.end()) {
                h264Packet.AddInvalidReference(modRef, frameNumber);
            } else {
                h264Packet.AddValidReference(modRef);
            }
        }
 
        // only print invalid references for better readability
        h264Packet.BuildInvalidReferenceString(frameNumber);
        // h264Packet.BuildValidReferenceString();
 
        if (h264Packet.HasInvalidBackwardReferences() && h264Packet.IsPSlice() &&  m_numIFrames < m_dropInvalidPackets) {
            LOGDEBUG2(L_CODEC, "videostream %s: %s: invalid backward reference, drop P-Frame %d", m_identifier, __FUNCTION__, frameNumber);
            dropPacket = true;
        }
    }
 
    if (h264Packet.IsISlice())
        m_numIFrames++;
 
    m_naluTypesAtStart.push_back(h264Packet.GetNalUnitString());
 
    return dropPacket;
}
 
void cVideoStream::DecodeInput(void)
{
    AVFrame *frame = nullptr;
    int ret = 0;
 
    if (m_codecId == AV_CODEC_ID_NONE || m_packets.IsEmpty() || m_pDrmBufferQueue->IsFull() || m_videoFilter.IsInputBufferFull())
        return;
 
    if (m_newStream)
        OpenDecoder();
 
    AVPacket *avpkt = m_packets.Peek();
 
    // log H.264 frames up to the given number of I-Frames
    bool dropPacket = false;
    if (avpkt && m_codecId == AV_CODEC_ID_H264 && (m_logPackets || m_dropInvalidPackets) && !m_isResend) {
        if (m_numIFrames < m_logPackets || m_numIFrames < m_dropInvalidPackets) {
            dropPacket = ParseH264Packet(avpkt);
        } else if (m_logPackets) {
            LOGDEBUG("videostream %s: %s: parsed H.264 stream:", m_identifier, __FUNCTION__);
            for (std::size_t i = 0; i < m_naluTypesAtStart.size(); i++) {
                LOGDEBUG("[H264] (%02d) %s", i, m_naluTypesAtStart[i].c_str());
            }
            m_logPackets = 0;
        }
    }
 
    // send packet to decoder
    if (!dropPacket) {
        ret = m_pDecoder->SendPacket(avpkt);
 
        if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
            avpkt = m_packets.Pop();
            av_packet_free(&avpkt);
            m_isResend = false;
        } else {
            m_isResend = true;
        }
 
        if (!ret && m_pRender->IsTrickSpeed())
            CheckForcingFrameDecode();
    } else {
        avpkt = m_packets.Pop();
        av_packet_free(&avpkt);
        m_isResend = false;
    }
 
    // receive frame from decoder
    ret = m_pDecoder->ReceiveFrame(&frame);
    if (ret == 0) {
        RenderFrame(frame);
    } else if (ret == AVERROR_EOF) {
        FlushDecoder();
        m_sentTrickPkts = 0;
    }
 
    if (m_pDecoder->IsHardwareDecoder() && !m_pDecoder->GetFramesReceived()) {
        // log maximum number of packets needed for the hw decoder to deliver a frame
        if (m_pConfig->GetDecoderNeedsMaxPackets() < m_pDecoder->GetPacketsSent())
            m_pConfig->SetDecoderNeedsMaxPackets(m_pDecoder->GetPacketsSent());
 
        // fallback to software decoder if configured and hw decoder fails
        if (m_decoderFallbackToSwNumPkts && m_pDecoder->GetPacketsSent() > m_decoderFallbackToSwNumPkts) {
            LOGWARNING("videostream %s: %s: Could not decode frame after %d packets sent, fallback to software decoder!", m_identifier, __FUNCTION__, m_decoderFallbackToSwNumPkts);
            if (m_pDecoder->ReopenCodec(m_codecId, m_pPar, m_timebase, m_decoderFallbackToSwNumPkts))
                LOGFATAL("videostream %s: %s: Could not reopen the decoder (sw fallback)!", m_identifier, __FUNCTION__);
        }
    }
}
 
void cVideoStream::GetVideoSize(int *width, int *height, double *aspect_ratio)
{
    AVCodecContext *videoCtx = m_pDecoder->GetContext();
 
    if (m_pDecoder && videoCtx) {
        *width = videoCtx->coded_width;
        *height = videoCtx->coded_height;
        *aspect_ratio = *width / (double)*height;
    } else {
        *width = 0;
        *height = 0;
        *aspect_ratio = 1.0;
    }
}
 
void cVideoStream::Open(AVCodecID codecId, AVCodecParameters *par, AVRational timebase) {
    m_newStream = true;
    m_trickpkts = codecId == AV_CODEC_ID_MPEG2VIDEO ? 1 : 2;
    m_timebase = timebase;
    m_codecId = codecId;
    m_pPar = par;
}
 
/*****************************************************************************
 * Thread
 ****************************************************************************/
 
void cVideoStream::Action(void)
{
    LOGDEBUG("videostream: decoding thread started");
    while(Running()) {
        m_mutex.lock();
 
        DecodeInput();
 
        m_mutex.unlock();
 
        usleep(1000);
    }
    LOGDEBUG("videostream: decoding thread stopped");
}
 
void cVideoStream::Stop(void)
{
    if (!Active())
        return;
 
    LOGDEBUG("videostream: stopping decoding thread");
    Cancel(2);
}
 
void cVideoStream::CancelFilterThread(void) {
    if (m_videoFilter.Active())
        m_videoFilter.Stop();
 
    m_checkFilterThreadNeeded = true;
    SetDeinterlacerDeactivated(false);
}
 
void cVideoStream::RenderFrame(AVFrame * frame)
{
    if (frame->decode_error_flags || frame->flags & AV_FRAME_FLAG_CORRUPT)
        LOGWARNING("videostream: %s: %s: error_flag or FRAME_FLAG_CORRUPT", m_identifier, __FUNCTION__);
 
    // Filter thread will only be started, if the lambda function returns true
    if (m_checkFilterThreadNeeded) {
        m_timebase = m_pDecoder->GetContext()->pkt_timebase;
 
        // Enable the deinterlacer only if:
        // - The user did not disable the deinterlacer
        // - The deinterlacer is not temporarily deactivated (trickspeed and still picture)
        // - A hardware quirk does not forbid using the deinterlacer
        // - It is an interlaced stream, determined by:
        //   - The codec is different from HEVC (always progressive)
        //   - The framerate is lower or equal to 30fps
        //   - Or, if the frame's interlaced flag is set
        // We cannot solely rely on the frame's interlaced flag, because the deinterlacer shall also be enabled with mixed progressive/interlaced streams (e.g. TV station "ProSieben").
 
        m_interlaced =
            (m_pDecoder->GetContext()->codec_id != AV_CODEC_ID_HEVC &&
            m_pDecoder->GetContext()->framerate.num > 0 &&
            av_q2d(m_pDecoder->GetContext()->framerate) < 30.1) || isInterlacedFrame(frame); // account for rounding errors when comparing double
 
        bool useDeinterlacer =
            !m_userDisabledDeinterlacer &&
            !m_deinterlacerDeactivated &&
            !(m_hardwareQuirks & QUIRK_NO_HW_DEINT) &&
            m_interlaced;
 
        if (m_userDisabledDeinterlacer)
            LOGDEBUG("videostream: %s: %s: deinterlacer disabled by user configuration", m_identifier, __FUNCTION__);
 
        // Use the filter thread if:
        // - AV_PIX_FMT_YUV420P, interlaced -> software deinterlacer (bwdif filter)
        // - AV_PIX_FMT_YUV420P, progressive -> scale filter to get NV12 frames
        // - AV_PIX_FMT_DRM_PRIME, interlaced, hw deinterlacer available -> hw deinterlacer
        if (frame->format == AV_PIX_FMT_YUV420P || (frame->format == AV_PIX_FMT_DRM_PRIME && useDeinterlacer))
            m_videoFilter.InitAndStart(m_pDecoder->GetContext(), frame, useDeinterlacer);
 
        m_checkFilterThreadNeeded = false;
    }
 
    if (m_videoFilter.Active())
        m_videoFilter.PushFrame(frame);
    else {
        // AV_PIX_FMT_DRM_PRIME, interlaced, hw deinterlacer not available
        // AV_PIX_FMT_DRM_PRIME, progressive
        // -> put the frame directly into render buffer
        if (!m_videoFilter.GetNumFramesToFilter())
            m_frameOutput(frame);
    }
}