codec_audio.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
#include <cstdint>
#include <mutex>
#include <string>
#include <vector>
#include <unistd.h>
 
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
}
 
#include "audio.h"
#include "codec_audio.h"
#include "logger.h"
#include "misc.h"
 
static std::string GetPassthroughMaskString(int mask)
{
    std::string passthrough = "";
 
    if (mask) {
        passthrough += " (passthrough mask:";
        if (mask & CODEC_AC3)  passthrough += " AC3";
        if (mask & CODEC_EAC3) passthrough += " E-AC-3";
        if (mask & CODEC_DTS)  passthrough += " DTS";
        passthrough += ")";
    }
 
    return passthrough;
}
 
cAudioDecoder::cAudioDecoder(cSoftHdAudio *audio)
    : m_pAudio(audio),
      m_passthroughMask(m_pAudio->GetPassthroughMask() & (CODEC_AC3 | CODEC_EAC3 | CODEC_DTS))
{
    if (!(m_pFrame = av_frame_alloc()))
        LOGFATAL("audiocodec: %s: can't allocate audio decoder frame buffer", __FUNCTION__);
 
    LOGDEBUG2(L_CODEC, "audiocodec: create %s%s", __FUNCTION__, GetPassthroughMaskString(m_passthroughMask).c_str());
}
 
cAudioDecoder::~cAudioDecoder(void)
{
    Close();
 
    av_frame_free(&m_pFrame);
}
 
void cAudioDecoder::Open(AVCodecID codecId, AVCodecParameters *par, AVRational timebase)
{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    const AVCodec *codec;
 
    m_codecId = codecId;
 
    switch (codecId) {
    case AV_CODEC_ID_AC3:
        if (!(codec = avcodec_find_decoder_by_name("ac3_fixed")))
            LOGFATAL("audiocodec: %s: codec ac3_fixed ID %#06x not found", __FUNCTION__, codecId);
        break;
    case AV_CODEC_ID_AAC:
        if (!(codec = avcodec_find_decoder_by_name("aac_fixed")))
            LOGFATAL("audiocodec: %s: codec aac_fixed ID %#06x not found", __FUNCTION__, codecId);
        break;
    default:
        if (!(codec = avcodec_find_decoder(codecId))) {
            LOGFATAL("audiocodec: %s: codec %s ID %#06x not found", __FUNCTION__,
            avcodec_get_name(codecId), codecId);
        }
        break;
    }
 
    if (!(m_pAudioCtx = avcodec_alloc_context3(codec)))
        LOGFATAL("audiocodec: %s: can't allocate audio codec context", __FUNCTION__);
 
    m_pAudioCtx->pkt_timebase = timebase;
 
    if (par && ((avcodec_parameters_to_context(m_pAudioCtx, par)) < 0))
        LOGERROR("audiocodec: %s: insert parameters to context failed!", __FUNCTION__);
 
    if (avcodec_open2(m_pAudioCtx, m_pAudioCtx->codec, NULL) < 0)
        LOGFATAL("audiocodec: %s: can't open audio codec", __FUNCTION__);
 
    LOGDEBUG2(L_CODEC, "audiocodec: %s: Codec %s found%s", __FUNCTION__, m_pAudioCtx->codec->long_name, GetPassthroughMaskString(m_passthroughMask).c_str());
 
    m_currentSampleRate = 0;
    m_currentHwSampleRate = 0;
    m_currentNumChannels = 0;
    m_currentHwNumChannels = 0;
    m_currentPassthroughMask = 0;
}
 
void cAudioDecoder::Close(void)
{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    if (!m_pAudioCtx)
        return;
 
    CloseSpdifMuxer();
 
    LOGDEBUG2(L_CODEC, "audiocodec: %s", __FUNCTION__);
 
    avcodec_free_context(&m_pAudioCtx);
 
    m_codecId = AV_CODEC_ID_NONE;
    m_lastPts = AV_NOPTS_VALUE;
}
 
#if LIBAVFORMAT_VERSION_MAJOR >= 61
int cAudioDecoder::SpdifWriteCallback(void *opaque, const uint8_t *buffer, int bufferSize)
#else
int cAudioDecoder::SpdifWriteCallback(void *opaque, uint8_t *buffer, int bufferSize)
#endif
{
    auto &output = *static_cast<std::vector<uint8_t> *>(opaque);
    output.insert(output.end(), buffer, buffer + bufferSize);
 
    return bufferSize;
}
 
bool cAudioDecoder::OpenSpdifMuxer(AVCodecID codecId, int sampleRate)
{
    CloseSpdifMuxer();
 
    if (avformat_alloc_output_context2(&m_spdifFmtCtx, nullptr, "spdif", nullptr) < 0 || !m_spdifFmtCtx) {
        LOGERROR("audiocodec: %s: failed to allocate spdif muxer", __FUNCTION__);
        return false;
    }
 
    m_spdifFmtCtx->pb = avio_alloc_context(m_spdifIoBuffer.data(), m_spdifIoBuffer.size(), 1, &m_spdifOutputBuf, nullptr, &cAudioDecoder::SpdifWriteCallback, nullptr);
    if (!m_spdifFmtCtx->pb) {
        avformat_free_context(m_spdifFmtCtx);
        m_spdifFmtCtx = nullptr;
        return false;
    }
 
    AVStream *stream = avformat_new_stream(m_spdifFmtCtx, nullptr);
    if (!stream) {
        CloseSpdifMuxer();
        return false;
    }
 
    stream->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
    stream->codecpar->codec_id = codecId;
    stream->codecpar->sample_rate = sampleRate;
    av_channel_layout_default(&stream->codecpar->ch_layout, 2);
    stream->time_base = AVRational{1, sampleRate};
 
    if (avformat_write_header(m_spdifFmtCtx, nullptr) < 0) {
        LOGERROR("audiocodec: %s: failed to write avformat header", __FUNCTION__);
        CloseSpdifMuxer();
        return false;
    }
 
    LOGDEBUG2(L_CODEC, "audiocodec: %s: opened spdif muxer for %s @ %dHz", __FUNCTION__, avcodec_get_name(codecId), sampleRate);
 
    return true;
}
 
void cAudioDecoder::CloseSpdifMuxer(void)
{
    if (m_spdifFmtCtx) {
        LOGDEBUG2(L_CODEC, "audiocodec: %s: close spdif muxer", __FUNCTION__);
        if (m_spdifFmtCtx->pb) {
            m_spdifFmtCtx->pb->buffer = nullptr;
            avio_context_free(&m_spdifFmtCtx->pb);
        }
        avformat_free_context(m_spdifFmtCtx);
        m_spdifFmtCtx = nullptr;
    }
 
    m_spdifOutputBuf.clear();
}
 
const std::vector<uint8_t> &cAudioDecoder::BuildIEC61937(const AVPacket *avpkt)
{
    if (!m_spdifFmtCtx || !avpkt || !avpkt->data || avpkt->size <= 0) {
        m_spdifOutputBuf.clear();
        return m_spdifOutputBuf;
    }
 
    m_spdifOutputBuf.clear();
 
    AVPacket pkt = {};
    int ret = av_packet_ref(&pkt, avpkt);
    if (ret < 0) {
        LOGERROR("audiocodec: %s: av_packet_ref failed: %s", __FUNCTION__, av_err2str(ret));
        return m_spdifOutputBuf;
    }
 
    pkt.stream_index = 0;
 
    ret = av_write_frame(m_spdifFmtCtx, &pkt);
    av_packet_unref(&pkt);
    if (ret < 0) {
        LOGERROR("audiocodec: %s: av_write_frame failed: %s", __FUNCTION__, av_err2str(ret));
        m_spdifOutputBuf.clear();
        return m_spdifOutputBuf;
    }
 
    // always flush to see, if new output is ready
    avio_flush(m_spdifFmtCtx->pb);
 
    return m_spdifOutputBuf;
}
 
bool cAudioDecoder::ShouldTryPassthrough(void)
{
    return (m_passthroughMask & CODEC_AC3  && m_pAudioCtx->codec_id == AV_CODEC_ID_AC3) ||
           (m_passthroughMask & CODEC_EAC3 && m_pAudioCtx->codec_id == AV_CODEC_ID_EAC3) ||
           (m_passthroughMask & CODEC_DTS  && m_pAudioCtx->codec_id == AV_CODEC_ID_DTS);
}
 
int cAudioDecoder::CheckUpdateFormat(bool passthrough)
{
    if (m_currentPassthroughMask == m_passthroughMask &&
        m_currentNumChannels     == m_currentHwNumChannels &&
        m_currentSampleRate      == m_currentHwSampleRate)
        return 0;
 
    m_currentHwSampleRate = m_pAudioCtx->sample_rate;
    m_currentHwNumChannels = m_pAudioCtx->ch_layout.nb_channels;
 
    if (passthrough) {
        CloseSpdifMuxer();
        m_currentHwSampleRate = AUDIO_PASSTHROUGH_RATE_HZ;
        m_currentHwNumChannels = AUDIO_PASSTHROUGH_NUM_CHANNELS;
 
        // E-AC3 over HDMI: some receivers need HBR
        if (m_pAudioCtx->codec_id == AV_CODEC_ID_EAC3)
            m_currentHwSampleRate *= 4;
    }
 
    int err = 0;
    if ((err = m_pAudio->Setup(m_pAudioCtx->pkt_timebase, m_currentHwSampleRate, m_currentHwNumChannels, passthrough)) < 0) {
        // E-AC3 over HDMI: try without HBR
        m_currentHwSampleRate /= 4;
 
        if (m_pAudioCtx->codec_id != AV_CODEC_ID_EAC3 ||
          ((err = m_pAudio->Setup(m_pAudioCtx->pkt_timebase, m_currentHwSampleRate, m_currentHwNumChannels, passthrough)) < 0)) {
            LOGERROR("audiocodec: %s: format change update error", __FUNCTION__);
            m_currentHwSampleRate = 0;
            m_currentHwNumChannels = 0;
            return err;
        }
    }
 
    // remember for next update check
    m_currentSampleRate = m_currentHwSampleRate;
    m_currentNumChannels = m_currentHwNumChannels;
    m_currentPassthroughMask = m_passthroughMask;
 
    // audio was newly set up (err == 0)
    if (!err)
        LOGDEBUG2(L_SOUND, "audiocodec: %s: format changed %s %dHz *%d channels%s", __FUNCTION__,
            av_get_sample_fmt_name(m_pAudioCtx->sample_fmt), m_currentHwSampleRate, m_currentHwNumChannels,
            GetPassthroughMaskString(m_passthroughMask).c_str());
 
    return 0;
}
 
void cAudioDecoder::Decode(const AVPacket *avpkt)
{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    if (ShouldTryPassthrough())
        Passthrough(avpkt);
    else
        DecodePCM(avpkt);
}
 
int cAudioDecoder::Passthrough(const AVPacket *avpkt)
{
    if (CheckUpdateFormat(true)) {
        LOGERROR("audiocodec: %s: unsupported format!", __FUNCTION__);
        return 0;
    }
 
    if (!m_spdifFmtCtx && !OpenSpdifMuxer(m_pAudioCtx->codec_id, m_currentHwSampleRate)) {
        LOGERROR("audiocodec: %s: failed to open spdif muxer for codec %s @ %dHz!", __FUNCTION__, avcodec_get_name(m_pAudioCtx->codec_id), m_currentHwSampleRate);
        return 0;
    }
 
    m_pAudio->SetTimebase(m_pAudioCtx->pkt_timebase);
 
    const auto &burst = BuildIEC61937(avpkt);
 
    if (burst.empty())
        return 0;
 
    m_pAudio->EnqueueSpdif(reinterpret_cast<const uint16_t *>(burst.data()), burst.size(), avpkt->pts);
    return 1;
}
 
void cAudioDecoder::DecodePCM(const AVPacket *avpkt)
{
    int retSend, retRec;
    AVFrame *frame;
 
    frame = m_pFrame;
    av_frame_unref(frame);
 
    do {
        retSend = avcodec_send_packet(m_pAudioCtx, avpkt);
        if (retSend < 0 && retSend != AVERROR(EAGAIN))
            LOGERROR("audiocodec: %s: avcodec_send_packet error: %s", __FUNCTION__, av_err2str(retSend));
 
        do {
            retRec = avcodec_receive_frame(m_pAudioCtx, frame);
 
            if (retRec < 0) {
                if (retRec != AVERROR(EAGAIN))
                    LOGERROR("audiocodec: %s: avcodec_receive_frame error: %s", __FUNCTION__, av_err2str(retRec));
                continue;
            }
 
            if (m_lastPts == AV_NOPTS_VALUE && avpkt->pts == AV_NOPTS_VALUE) {
                // the first AVPacket has no valid PTS, if its PES packet has been truncated while searching for the sync word
                av_frame_unref(frame);
                continue;
            }
 
            // update audio clock and remember last PTS or guess the next PTS
            if (frame->pts != AV_NOPTS_VALUE) {
                m_lastPts = frame->pts;
            } else if (m_lastPts != AV_NOPTS_VALUE) {
                frame->pts = m_lastPts +
                    av_rescale_q(frame->nb_samples, (AVRational){1, frame->sample_rate}, m_pAudioCtx->pkt_timebase);
                m_lastPts = frame->pts;
            }
 
            if (CheckUpdateFormat(false)) {
                LOGERROR("audiocodec: %s: unsupported format!", __FUNCTION__);
                av_frame_unref(frame);
                return;
            }
 
            m_pAudio->Filter(frame, m_pAudioCtx);
 
        } while (retRec == 0);
    } while (retSend == AVERROR(EAGAIN));
}
 
void cAudioDecoder::FlushBuffers(void)
{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    LOGDEBUG2(L_CODEC, "audiocodec: %s", __FUNCTION__);
    if (m_pAudioCtx)
        avcodec_flush_buffers(m_pAudioCtx);
 
    m_lastPts = AV_NOPTS_VALUE;
    m_codecId = AV_CODEC_ID_NONE;
}
 
void cAudioDecoder::SetPassthroughMask(int mask)
{
    m_passthroughMask = mask & (CODEC_AC3 | CODEC_EAC3 | CODEC_DTS);
}