videostream.cpp

Go to the documentation of this file.

 
#include <string>
 
#include <assert.h>
#include <unistd.h>
 
#include <libintl.h>
 
#include <pthread.h>
#include <sys/types.h>
#include <sys/wait.h>
 
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/timestamp.h>
}
 
#include "softhddevice-drm-gles.h"
#include "softhddevice.h"
#include "logger.h"
#include "h264parser.h"
 
#include "buf2rgb.h"
 
#include "iatomic.h"
#include "videostream.h"
#include "audio.h"
#include "videorender.h"
#include "codec_audio.h"
#include "codec_video.h"
 
#include "queue.h"
#include "misc.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, const char *identifier, std::function<void(AVFrame *)> frameOutput)
{
    LOGDEBUG("videostream %s: %s", __FUNCTION__, identifier);
 
    m_pRender = render;
    m_pDrmBufferQueue = drmBufferQueue;
    m_pDecoder = nullptr;
    m_frameOutput = frameOutput;
    m_identifier = identifier;
 
    m_codecId = AV_CODEC_ID_NONE;
    m_newStream = false;
    m_pPar = nullptr;
 
    m_userDisabledDeinterlacer = config->ConfigDisableDeint;
 
    m_filterThreadName = "shd " + std::string(identifier) + " filter";
    m_pFilterThread = new cFilterThread(render, m_pDrmBufferQueue, m_filterThreadName.c_str(), frameOutput);
    m_hardwareQuirks = ReadHWPlatform();
}
 
cVideoStream::~cVideoStream(void)
{
    LOGDEBUG("videostream %s:", __FUNCTION__);
 
    if (m_pFilterThread)
        delete m_pFilterThread;
}
 
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__);
 
    ExitDecodingThread();
 
    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);
 
    m_decodingThreadName = "shd " + std::string(m_identifier) + " decode";
    m_pDecodingThread = new cDecodingThread(this, m_decodingThreadName.c_str());
}
 
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;
}
 
void cVideoStream::FlushDecoder(void)
{
    LOGDEBUG2(L_CODEC, "videostream %s: %s", m_identifier, __FUNCTION__);
 
    if (m_hardwareQuirks & QUIRK_CODEC_FLUSH_WORKAROUND) {
        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::DecodeInput(void)
{
    AVFrame *frame = nullptr;
    int ret = 0;
 
    if (m_codecId == AV_CODEC_ID_NONE || m_packets.IsEmpty() || m_pDrmBufferQueue->IsFull() || m_pFilterThread->IsInputBufferFull())
        return;
 
    if (m_newStream) {
        int width = 0;
        int height = 0;
 
        // amlogic h264 decoder needs width an height for correct decoder open
        if ((m_codecId == AV_CODEC_ID_H264) && (m_hardwareQuirks & QUIRK_CODEC_NEEDS_EXT_INIT)) {
            cH264Parser h264Parser(m_packets.Peek());
            h264Parser.GetDimensions(&width, &height);
 
            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, 0, width, height))
            LOGFATAL("videostream %s: %s: Could not open the decoder!", m_identifier, __FUNCTION__);
        m_newStream = false;
    }
 
    // wait for m_trickpkts packets
    //
    // m_trickpkts is the number of packets we need to have in the buffer
    // while in interlaced trickspeed mode, needed to get a frame.
    // This guarantees, that we don't drain the decoder too early, but exactly after
    // m_trickpkts sent packets
    int minPkts = (m_pRender->GetTrickSpeed() && m_interlaced) ? m_trickpkts : 1;
 
    // send packet to decoder
    AVPacket *avpkt = m_packets.Peek();
 
    ret = m_pDecoder->SendPacket(avpkt);
 
    if (ret != AVERROR(EAGAIN)) {
        avpkt = m_packets.Pop();
        av_packet_free(&avpkt);
    }
 
    // in backward trickspeed force the decoder to decode the frame, if minPkts are sent
    bool flushDecoder = false;
    if (ret == 0 && m_pRender->GetTrickSpeed() && !m_pRender->GetTrickForward()) {
        m_sentTrickPkts++;
        if (m_sentTrickPkts >= minPkts) {
            m_pDecoder->SendPacket(NULL);
            m_sentTrickPkts = 0;
            flushDecoder = true;
        }
    }
 
    // receive frame from decoder
    if (!m_newStream) { // this is for mediaplayer?
        if (m_pDecoder->ReceiveFrame(&frame) == 0)
            RenderFrame(frame);
    }
 
    if (ret == AVERROR_EOF || flushDecoder) {
        FlushDecoder();
        m_sentTrickPkts = 0;
    }
}
 
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::ExitDecodingThread(void)
{
    LOGDEBUG("videostream %s: %s", m_identifier, __FUNCTION__);
 
    if (m_pDecodingThread->Active())
        m_pDecodingThread->Stop();
 
    if (m_pDecodingThread)
        delete m_pDecodingThread;
}
 
void cVideoStream::CancelFilterThread(void) {
    if (m_pFilterThread->Active())
        m_pFilterThread->Stop();
 
    m_checkFilterThreadNeeded = true;
}
 
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_pFilterThread->InitAndStart(m_pDecoder->GetContext(), frame, useDeinterlacer);
 
        m_checkFilterThreadNeeded = false;
    }
 
    if (m_pFilterThread->Active())
        m_pFilterThread->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_pFilterThread->GetNumFramesToFilter())
            m_frameOutput(frame);
    }
}