audio.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
#include <chrono>
#include <cmath>
#include <cstdint>
#include <mutex>
#include <string>
#include <sstream>
#include <vector>
 
#include <alsa/asoundlib.h>
 
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavfilter/avfilter.h>
#include <libavfilter/buffersink.h>
#include <libavfilter/buffersrc.h>
#include <libavutil/channel_layout.h>
#include <libavutil/opt.h>
}
 
#include <vdr/thread.h>
 
#include "audio.h"
#include "codec_audio.h"
#include "config.h"
#include "event.h"
#include "filllevel.h"
#include "logger.h"
#include "misc.h"
#include "pidcontroller.h"
#include "ringbuffer.h"
#include "softhddevice.h"
 
cSoftHdAudio::cSoftHdAudio(cSoftHdDevice *device)
    : cThread("softhd audio"),
      m_pDevice(device),
      m_pConfig(m_pDevice->Config()),
      m_pEventReceiver(device),
      m_downmix(m_pConfig->ConfigAudioDownmix),
      m_softVolume(m_pConfig->ConfigAudioSoftvol),
      m_passthrough(m_pConfig->ConfigAudioPassthroughState ? m_pConfig->ConfigAudioPassthroughMask : 0),
      m_pPCMDevice(m_pConfig->ConfigAudioPCMDevice),
      m_pPassthroughDevice(m_pConfig->ConfigAudioPassthroughDevice),
      m_appendAES(m_pConfig->ConfigAudioAutoAES),
      m_pMixerChannel(m_pConfig->ConfigAudioMixerChannel)
{
    SetNormalize(m_pConfig->ConfigAudioNormalize, m_pConfig->ConfigAudioMaxNormalize);
    SetCompression(m_pConfig->ConfigAudioCompression, m_pConfig->ConfigAudioMaxCompression);
    SetStereoDescent(m_pConfig->ConfigAudioStereoDescent);
    SetEq(m_pConfig->ConfigAudioEqBand, m_pConfig->ConfigAudioEq);
}
 
/******************************************************************************
 * Audio filter and manipulation
 *****************************************************************************/
 
void cSoftHdAudio::Normalize(uint16_t *samples, int count)
{
    int i;
    int l;
    int n;
    uint32_t avg;
    int factor;
    uint16_t *data;
 
    // average samples
    l = count / m_bytesPerSample;
    data = samples;
    do {
        n = l;
        if (m_normalizeCounter + n > m_normalizeSamples) {
            n = m_normalizeSamples - m_normalizeCounter;
        }
        avg = m_normalizeAverage[m_normalizeIndex];
        for (i = 0; i < n; ++i) {
            int t;
 
            t = data[i];
            avg += (t * t) / m_normalizeSamples;
        }
        m_normalizeAverage[m_normalizeIndex] = avg;
        m_normalizeCounter += n;
        if (m_normalizeCounter >= m_normalizeSamples) {
            if (m_normalizeReady < NORMALIZE_MAX_INDEX) {
                m_normalizeReady++;
            } else {
                avg = 0;
                for (i = 0; i < NORMALIZE_MAX_INDEX; ++i) {
                    avg += m_normalizeAverage[i] / NORMALIZE_MAX_INDEX;
                }
 
            // calculate normalize factor
            if (avg > 0) {
                factor = ((INT16_MAX / 8) * 1000U) / (uint32_t) sqrt(avg);
                // smooth normalize
                m_normalizeFactor = (m_normalizeFactor * 500 + factor * 500) / 1000;
                if (m_normalizeFactor < m_normalizeMinFactor) {
                    m_normalizeFactor = m_normalizeMinFactor;
                }
                if (m_normalizeFactor > m_normalizeMaxFactor) {
                    m_normalizeFactor = m_normalizeMaxFactor;
                }
            } else {
                factor = 1000;
            }
            LOGDEBUG2(L_SOUND, "audio: %s: avg %8d, fac=%6.3f, norm=%6.3f", __FUNCTION__,
                      avg, factor / 1000.0, m_normalizeFactor / 1000.0);
            }
 
            m_normalizeIndex = (m_normalizeIndex + 1) % NORMALIZE_MAX_INDEX;
            m_normalizeCounter = 0;
            m_normalizeAverage[m_normalizeIndex] = 0U;
        }
        data += n;
        l -= n;
    } while (l > 0);
 
    // apply normalize factor
    for (i = 0; i < count / m_bytesPerSample; ++i) {
        int t;
 
        t = (samples[i] * m_normalizeFactor) / 1000;
        if (t < INT16_MIN) {
            t = INT16_MIN;
        } else if (t > INT16_MAX) {
            t = INT16_MAX;
        }
        samples[i] = t;
    }
}
 
void cSoftHdAudio::Compress(uint16_t *samples, int count)
{
    int maxSample;
    int i;
    int factor;
 
    // find loudest sample
    maxSample = 0;
    for (i = 0; i < count / m_bytesPerSample; ++i) {
        int t;
 
        t = abs(samples[i]);
        if (t > maxSample) {
            maxSample = t;
        }
    }
 
    // calculate compression factor
    if (maxSample > 0) {
        factor = (INT16_MAX * 1000) / maxSample;
        // smooth compression (FIXME: make configurable?)
        m_compressionFactor = (m_compressionFactor * 950 + factor * 50) / 1000;
        if (m_compressionFactor > factor) {
            m_compressionFactor = factor;   // no clipping
        }
        if (m_compressionFactor > m_compressionMaxFactor) {
            m_compressionFactor = m_compressionMaxFactor;
        }
    } else {
        return; // silent nothing todo
    }
 
    LOGDEBUG2(L_SOUND, "audio: %s: max %5d, fac=%6.3f, com=%6.3f", __FUNCTION__, maxSample,
              factor / 1000.0, m_compressionFactor / 1000.0);
 
    // apply compression factor
    for (i = 0; i < count / m_bytesPerSample; ++i) {
        int t;
 
        t = (samples[i] * m_compressionFactor) / 1000;
        if (t < INT16_MIN) {
            t = INT16_MIN;
        } else if (t > INT16_MAX) {
            t = INT16_MAX;
        }
        samples[i] = t;
    }
}
 
void cSoftHdAudio::SoftAmplify(int16_t *samples, int count)
{
    int i;
 
    // silence
    if (m_volume == 0 || !m_amplifier) {
        memset(samples, 0, count);
        return;
    }
 
    for (i = 0; i < count / m_bytesPerSample; ++i) {
        int t;
 
        t = (samples[i] * m_amplifier) / 1000;
        if (t < INT16_MIN) {
            t = INT16_MIN;
        } else if (t > INT16_MAX) {
            t = INT16_MAX;
        }
        samples[i] = t;
    }
}
 
void cSoftHdAudio::SetEq(int band[18], int onoff)
{
    int i;
/*
    LOGDEBUG2(L_SOUND, "audio: %s: %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i onoff %d", __FUNCTION__,
              band[0], band[1], band[2], band[3], band[4], band[5], band[6], band[7],
              band[8], band[9], band[10], band[11], band[12], band[13], band[14],
              band[15], band[16], band[17], onoff);
*/
    for (i = 0; i < 18; i++) {
        switch (band[i]) {
            case 1:
                m_equalizerBand[i] = 1.5;
                break;
            case 0:
                m_equalizerBand[i] = 1;
                break;
            case -1:
                m_equalizerBand[i] = 0.95;
                break;
            case -2:
                m_equalizerBand[i] = 0.9;
                break;
            case -3:
                m_equalizerBand[i] = 0.85;
                break;
            case -4:
                m_equalizerBand[i] = 0.8;
                break;
            case -5:
                m_equalizerBand[i] = 0.75;
                break;
            case -6:
                m_equalizerBand[i] = 0.7;
                break;
            case -7:
                m_equalizerBand[i] = 0.65;
                break;
            case -8:
                m_equalizerBand[i] = 0.6;
                break;
            case -9:
                m_equalizerBand[i] = 0.55;
                break;
            case -10:
                m_equalizerBand[i] = 0.5;
                break;
            case -11:
                m_equalizerBand[i] = 0.45;
                break;
            case -12:
                m_equalizerBand[i] = 0.4;
                break;
            case -13:
                m_equalizerBand[i] = 0.35;
                break;
            case -14:
                m_equalizerBand[i] = 0.3;
                break;
            case -15:
                m_equalizerBand[i] = 0.25;
                break;
        }
    }
 
    m_filterChanged = 1;
    m_useEqualizer = onoff;
}
 
static const char *alsaToFFmpegChannel(const char *alsaName)
{
    if (!strcmp(alsaName, "RL")) return "BL";
    if (!strcmp(alsaName, "RR")) return "BR";
 
    return alsaName;
}
 
static std::vector<std::string> GetAlsaChannelLayoutAsArray(snd_pcm_t *pcmHandle)
{
    std::vector<std::string> layout;
    snd_pcm_chmap_t *map = snd_pcm_get_chmap(pcmHandle);
    if (!map)
        return layout;
 
    for (unsigned int i = 0; i < map->channels; i++) {
        const char *name = alsaToFFmpegChannel(snd_pcm_chmap_name(static_cast<snd_pcm_chmap_position>(map->pos[i])));
        if (!name)
            continue;
        layout.push_back(std::string(name));
    }
    free(map);
    return layout;
}
 
static std::vector<std::string> GetFFmpegChannelLayoutAsArray(const AVChannelLayout &layout)
{
    std::vector<std::string> names;
    char buf[16];
 
    for (int i = 0; i < layout.nb_channels; i++) {
        enum AVChannel ch = av_channel_layout_channel_from_index(&layout, i);
        int ret = av_channel_name(buf, sizeof(buf), ch);
        if (ret < 0)
            continue;
        names.push_back(std::string(buf));
    }
    return names;
}
 
static bool LayoutsMatch(const std::vector<std::string> &ff, const std::vector<std::string> &alsa)
{
    if (ff.size() != alsa.size())
        return false;
 
    for (size_t i = 0; i < ff.size(); i++) {
        if (ff[i] != alsa[i])
            return false;
    }
 
    return true;
}
 
static std::string BuildChannelMapFilter(snd_pcm_t *pcmHandle, const AVChannelLayout &layout)
{
    auto ff = GetFFmpegChannelLayoutAsArray(layout);
    auto alsa = GetAlsaChannelLayoutAsArray(pcmHandle);
 
    if (ff.size() != alsa.size()) {
        LOGWARNING("audio: %s: FFmpeg and Alsa channel count differs: FFmpeg %zu ALSA %zu", __FUNCTION__, ff.size(), alsa.size());
        return "";
    }
 
    std::string ffString;
    for (size_t i = 0; i < ff.size(); i++) {
        ffString += ff[i];
        if (i < ff.size() - 1)
            ffString += " ";
    }
 
    std::string alsaString;
    for (size_t i = 0; i < alsa.size(); i++) {
        alsaString += alsa[i];
        if (i < alsa.size() - 1)
            alsaString += " ";
    }
 
    if (LayoutsMatch(ff, alsa)) {
        LOGDEBUG2(L_SOUND, "audio: %s: FFmpeg and Alsa channel layouts match: %s", __FUNCTION__, ffString.c_str());
        return "";
    }
 
    std::stringstream ss;
    for (size_t i = 0; i < ff.size(); i++) {
        if (i != 0)
            ss << "|";
        ss << ff[i] << "-" << alsa[i];
    }
 
    LOGDEBUG2(L_SOUND, "audio: %s: FFmpeg Channel Layout: %s", __FUNCTION__, ffString.c_str());
    LOGDEBUG2(L_SOUND, "audio: %s: Alsa Channel Layout  : %s", __FUNCTION__, alsaString.c_str());
    LOGDEBUG2(L_SOUND, "audio: %s: Layouts don't match, map FFmpeg to Alsa: %s", __FUNCTION__, ss.str().c_str());
 
    return ss.str();
}
 
int cSoftHdAudio::InitFilter(AVCodecContext *audioCtx)
{
    const AVFilter  *abuffer;
    AVFilterContext *pFilterCtx[4];
    const AVFilter *channelmap;
    const AVFilter *eq;
    const AVFilter *aformat;
    const AVFilter *abuffersink;
    char channelLayout[64];
    char optionsStr[1024];
    int err, i, numFilter = 0;
 
    // Before filter init set HW parameter.
    if (audioCtx->sample_rate != (int)m_hwSampleRate ||
        (audioCtx->ch_layout.nb_channels != (int)m_hwNumChannels &&
        !(m_downmix && m_hwNumChannels == 2))) {
 
        err = AlsaSetup(audioCtx->ch_layout.nb_channels, audioCtx->sample_rate, 0);
        if (err)
            return err;
    }
 
    m_pTimebase = &audioCtx->pkt_timebase;
 
#if LIBAVFILTER_VERSION_INT < AV_VERSION_INT(7,16,100)
    avfilter_register_all();
#endif
 
    if (!(m_pFilterGraph = avfilter_graph_alloc())) {
        LOGERROR("audio: %s: Unable to create filter graph.", __FUNCTION__);
        return -1;
    }
 
    // input buffer
    if (!(abuffer = avfilter_get_by_name("abuffer"))) {
        LOGWARNING("audio: %s: Could not find the abuffer filter.", __FUNCTION__);
        avfilter_graph_free(&m_pFilterGraph);
        return -1;
    }
    if (!(m_pBuffersrcCtx = avfilter_graph_alloc_filter(m_pFilterGraph, abuffer, "src"))) {
        LOGWARNING("audio: %s: Could not allocate the m_pBuffersrcCtx instance.", __FUNCTION__);
        avfilter_graph_free(&m_pFilterGraph);
        return -1;
    }
 
    av_channel_layout_describe(&audioCtx->ch_layout, channelLayout, sizeof(channelLayout));
 
    LOGDEBUG2(L_SOUND, "audio: %s: IN channelLayout %s sample_fmt %s sample_rate %d channels %d", __FUNCTION__,
              channelLayout, av_get_sample_fmt_name(audioCtx->sample_fmt), audioCtx->sample_rate, audioCtx->ch_layout.nb_channels);
 
    av_opt_set    (m_pBuffersrcCtx, "channel_layout", channelLayout,                                AV_OPT_SEARCH_CHILDREN);
    av_opt_set    (m_pBuffersrcCtx, "sample_fmt",     av_get_sample_fmt_name(audioCtx->sample_fmt), AV_OPT_SEARCH_CHILDREN);
    av_opt_set_q  (m_pBuffersrcCtx, "time_base",      (AVRational){ 1, audioCtx->sample_rate },     AV_OPT_SEARCH_CHILDREN);
    av_opt_set_int(m_pBuffersrcCtx, "sample_rate",    audioCtx->sample_rate,                        AV_OPT_SEARCH_CHILDREN);
//  av_opt_set_int(m_pBuffersrcCtx, "channel_counts", audioCtx->channels,                           AV_OPT_SEARCH_CHILDREN);
 
    // initialize the filter with NULL options, set all options above.
    if (avfilter_init_str(m_pBuffersrcCtx, NULL) < 0) {
        LOGWARNING("audio: %s: Could not initialize the abuffer filter.", __FUNCTION__);
        avfilter_graph_free(&m_pFilterGraph);
        return -1;
    }
 
    // channelmap
    //
    // Map FFmpeg channel layout to Alsa channel layout.
    // Depending on the hardware, e.g. FC and LFE have to be swapped.
    // This is the case for HDMI on RPI4, so we need to do the following:
    //    FL-FL|FR-FR|FC-LFE|LFE-FC|BL-BL|BR-BR
    //
    // The channel mapping is skipped, if
    //   - a stereo downmix is forced (downmix will be done later in aformat filter)
    //   - channel count differs, aformat will handle downmix later
    if (!(m_downmix && m_hwNumChannels == 2)) {
        std::string channelMapString;
        channelMapString = BuildChannelMapFilter(m_pAlsaPCMHandle, audioCtx->ch_layout);
 
        if (!channelMapString.empty()) {
            if (!(channelmap = avfilter_get_by_name("channelmap"))) {
                LOGWARNING("audio: %s: Could not find the channelmap filter.", __FUNCTION__);
                return -1;
            }
            if (!(pFilterCtx[numFilter] = avfilter_graph_alloc_filter(m_pFilterGraph, channelmap, "channelmap"))) {
                LOGWARNING("audio: %s: Could not allocate the channelmap instance.", __FUNCTION__);
                return -1;
            }
            snprintf(optionsStr, sizeof(optionsStr),"map=%s", channelMapString.c_str());
            if (avfilter_init_str(pFilterCtx[numFilter], optionsStr) < 0) {
                LOGWARNING("audio: %s: Could not initialize the channelmap filter \"%s\"", __FUNCTION__, optionsStr);
                avfilter_graph_free(&m_pFilterGraph);
                return -1;
            }
            numFilter++;
        }
    }
 
    // superequalizer
    if (m_useEqualizer) {
        if (!(eq = avfilter_get_by_name("superequalizer"))) {
            LOGWARNING("audio: %s: Could not find the superequalizer filter.", __FUNCTION__);
            avfilter_graph_free(&m_pFilterGraph);
            return -1;
        }
        if (!(pFilterCtx[numFilter] = avfilter_graph_alloc_filter(m_pFilterGraph, eq, "superequalizer"))) {
            LOGWARNING("audio: %s: Could not allocate the superequalizer instance.", __FUNCTION__);
            avfilter_graph_free(&m_pFilterGraph);
            return -1;
        }
        snprintf(optionsStr, sizeof(optionsStr),"1b=%.2f:2b=%.2f:3b=%.2f:4b=%.2f:5b=%.2f"
            ":6b=%.2f:7b=%.2f:8b=%.2f:9b=%.2f:10b=%.2f:11b=%.2f:12b=%.2f:13b=%.2f:14b=%.2f:"
            "15b=%.2f:16b=%.2f:17b=%.2f:18b=%.2f ", m_equalizerBand[0], m_equalizerBand[1],
            m_equalizerBand[2], m_equalizerBand[3], m_equalizerBand[4], m_equalizerBand[5],
            m_equalizerBand[6], m_equalizerBand[7], m_equalizerBand[8], m_equalizerBand[9],
            m_equalizerBand[10], m_equalizerBand[11], m_equalizerBand[12], m_equalizerBand[13],
            m_equalizerBand[14], m_equalizerBand[15], m_equalizerBand[16], m_equalizerBand[17]);
        if (avfilter_init_str(pFilterCtx[numFilter], optionsStr) < 0) {
            LOGWARNING("audio: %s: Could not initialize the superequalizer filter.", __FUNCTION__);
            avfilter_graph_free(&m_pFilterGraph);
            return -1;
        }
        numFilter++;
    }
 
    // aformat
    AVChannelLayout channel_layout;
    if (m_downmix && m_hwNumChannels == 2) {
        // explicit stereo downmix
        av_channel_layout_default(&channel_layout, 2);
    } else {
        if (av_channel_layout_copy(&channel_layout, &audioCtx->ch_layout) < 0) {
            LOGWARNING("audio: %s: Could not copy channel layout", __FUNCTION__);
            return -1;
        }
 
        // clamp channels if the hardware doesn't support them
        if (channel_layout.nb_channels > (int)m_hwNumChannels) {
            LOGDEBUG2(L_SOUND, "audio: %s: clamp channels from %d -> %d", __FUNCTION__, channel_layout.nb_channels, m_hwNumChannels);
            av_channel_layout_uninit(&channel_layout);
            av_channel_layout_default(&channel_layout, m_hwNumChannels);
        }
    }
    av_channel_layout_describe(&channel_layout, channelLayout, sizeof(channelLayout));
    av_channel_layout_uninit(&channel_layout);
 
    LOGDEBUG2(L_SOUND, "audio: %s: OUT m_downmix %d m_hwNumChannels %d m_hwSampleRate %d channelLayout %s bytes_per_sample %d",
              __FUNCTION__, m_downmix, m_hwNumChannels, m_hwSampleRate, channelLayout, av_get_bytes_per_sample(AV_SAMPLE_FMT_S16));
 
    if (!(aformat = avfilter_get_by_name("aformat"))) {
        LOGWARNING("audio: %s: Could not find the aformat filter.", __FUNCTION__);
        avfilter_graph_free(&m_pFilterGraph);
        return -1;
    }
    if (!(pFilterCtx[numFilter] = avfilter_graph_alloc_filter(m_pFilterGraph, aformat, "aformat"))) {
        LOGWARNING("audio: %s: Could not allocate the aformat instance.", __FUNCTION__);
        avfilter_graph_free(&m_pFilterGraph);
        return -1;
    }
    snprintf(optionsStr, sizeof(optionsStr),
        "sample_fmts=%s:sample_rates=%d:channel_layouts=%s",
        av_get_sample_fmt_name(AV_SAMPLE_FMT_S16), m_hwSampleRate, channelLayout);
    if (avfilter_init_str(pFilterCtx[numFilter], optionsStr) < 0) {
        LOGWARNING("audio: %s: Could not initialize the aformat filter.", __FUNCTION__);
        avfilter_graph_free(&m_pFilterGraph);
        return -1;
    }
    numFilter++;
 
    // abuffersink
    if (!(abuffersink = avfilter_get_by_name("abuffersink"))) {
        LOGWARNING("audio: %s: Could not find the abuffersink filter.", __FUNCTION__);
        avfilter_graph_free(&m_pFilterGraph);
        return -1;
    }
    if (!(pFilterCtx[numFilter] = avfilter_graph_alloc_filter(m_pFilterGraph, abuffersink, "sink"))) {
        LOGWARNING("audio: %s: Could not allocate the abuffersink instance.", __FUNCTION__);
        avfilter_graph_free(&m_pFilterGraph);
        return -1;
    }
    if (avfilter_init_str(pFilterCtx[numFilter], NULL) < 0) {
        LOGWARNING("audio: %s: Could not initialize the abuffersink instance.", __FUNCTION__);
        avfilter_graph_free(&m_pFilterGraph);
        return -1;
    }
    numFilter++;
 
    // Connect the filters
    for (i = 0; i < numFilter; i++) {
        if (i == 0) {
            err = avfilter_link(m_pBuffersrcCtx, 0, pFilterCtx[i], 0);
        } else {
            err = avfilter_link(pFilterCtx[i - 1], 0, pFilterCtx[i], 0);
        }
    }
    if (err < 0) {
        LOGWARNING("audio: %s: Error connecting audio filters", __FUNCTION__);
        avfilter_graph_free(&m_pFilterGraph);
        return -1;
    }
 
    // Configure the graph.
    if (avfilter_graph_config(m_pFilterGraph, NULL) < 0) {
        LOGWARNING("audio: %s: Error configuring the audio filter graph", __FUNCTION__);
        avfilter_graph_free(&m_pFilterGraph);
        return -1;
    }
 
    m_pBuffersinkCtx = pFilterCtx[numFilter - 1];
    m_filterChanged = 0;
    m_filterReady = 1;
 
    return 0;
}
 
/******************************************************************************
 * Audio stream handling
 *****************************************************************************/
 
void cSoftHdAudio::DropSamplesOlderThanPtsMs(int64_t ptsMs)
{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    if (!HasInputPts())
        return;
 
    int64_t dropMs = std::max((int64_t)0, ptsMs - GetOutputPtsMsInternal());
    int dropFrames = MsToFrames(dropMs);
    int dropBytes = snd_pcm_frames_to_bytes(m_pAlsaPCMHandle, dropFrames);
 
    dropBytes = std::min(dropBytes, (int)m_pRingbuffer.UsedBytes());
 
    if (dropBytes > 0) {
        LOGDEBUG2(L_AV_SYNC, "audio: %s: dropping %dms audio samples to start in sync with the video (output PTS %s -> %s)",
            __FUNCTION__,
            dropMs,
            Timestamp2String(GetOutputPtsMsInternal(), 1),
            Timestamp2String(ptsMs, 1));
 
        m_pidController.Reset();
        m_fillLevel.Reset();
        m_fillLevel.WroteFrames(dropFrames);
        m_pRingbuffer.ReadAdvance(dropBytes);
    }
}
 
void cSoftHdAudio::EnqueueFrame(AVFrame *frame)
{
    if (!frame)
        return;
 
    uint16_t *buffer;
 
    int byteCount = frame->nb_samples * frame->ch_layout.nb_channels * m_bytesPerSample;
    buffer = (uint16_t *)frame->data[0];
 
    if (m_compression)     // in place operation
        Compress(buffer, byteCount);
 
    if (m_normalize)       // in place operation
        Normalize(buffer, byteCount);
 
    Enqueue((uint16_t *)buffer, byteCount, frame);
 
    av_frame_free(&frame);
}
 
void cSoftHdAudio::BuildPauseBurst(void)
{
    uint16_t *spdif = m_pauseBurst.data();
 
    spdif[0] = htole16(IEC61937_PREAMBLE1);
    spdif[1] = htole16(IEC61937_PREAMBLE2);
    spdif[2] = htole16(IEC61937_NULL);
    spdif[3] = 0;
 
    memset(m_pauseBurst.data() + 4, 0, m_spdifBurstSize - 8);
}
 
void cSoftHdAudio::EnqueueSpdif(uint16_t *buffer, int count, AVFrame *frame)
{
    std::lock_guard<std::mutex> lock(m_pauseMutex);
 
    if (count != m_spdifBurstSize) {
        LOGDEBUG2(L_SOUND, "audio: %s: spdif burst size changed %d -> %d, rebuild pause burst", __FUNCTION__, m_spdifBurstSize, count);
        m_spdifBurstSize = count;
        m_pauseBurst.resize(m_spdifBurstSize / 2);
 
        BuildPauseBurst();
    }
 
    Enqueue(buffer, count, frame);
}
 
void cSoftHdAudio::Enqueue(uint16_t *buffer, int count, AVFrame *frame)
{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    // pitch adjustment
    if (m_pitchAdjustFrameCounter == 0 && std::abs(m_pitchPpm) > 1) { // only adjust if pitch has a significant value to prevent overly large values/division by zero
        int oneFrameBytes = snd_pcm_frames_to_bytes(m_pAlsaPCMHandle, 1);
 
        if (m_pitchPpm < 0 && m_pRingbuffer.Write((const uint16_t *)buffer, oneFrameBytes)) // insert additional frame
            m_fillLevel.ReceivedFrames(1);
        else if (m_pitchPpm > 0) // drop frame
            count = std::max(0, count - oneFrameBytes);
 
        m_pitchAdjustFrameCounter = std::round(1'000'000.0 / std::abs(m_pitchPpm));
    }
 
    m_pitchAdjustFrameCounter = std::max(0, m_pitchAdjustFrameCounter - (int)snd_pcm_bytes_to_frames(m_pAlsaPCMHandle, count));
 
    // write to ringbuffer
    int bytesWritten = m_pRingbuffer.Write((const uint16_t *)buffer, count);
    if (bytesWritten != count)
        LOGERROR("audio: %s: can't place %d samples in ring buffer", __FUNCTION__, count);
 
    m_fillLevel.ReceivedFrames(snd_pcm_bytes_to_frames(m_pAlsaPCMHandle, bytesWritten));
 
    if (frame->pts != AV_NOPTS_VALUE) {
        // discontinuity check, force a resync if the new pts differs more than AV_SYNC_BORDER_MS to the last
        if (m_inputPts != AV_NOPTS_VALUE && std::abs(PtsToMs(m_inputPts) - PtsToMs(frame->pts)) > AV_SYNC_BORDER_MS) {
            LOGDEBUG2(L_AV_SYNC, "audio: %s: discontinuity detected in audio PTS %s -> %s%s", __FUNCTION__,
                Timestamp2String(PtsToMs(m_inputPts), 1), Timestamp2String(PtsToMs(frame->pts), 1),
                PtsToMs(m_inputPts) > PtsToMs(frame->pts) ? " (PTS wrapped)" : "");
            m_eventQueue.push_back(ScheduleResyncAtPtsMsEvent{PtsToMs(frame->pts)});
        }
 
        m_inputPts = frame->pts;
    }
}
 
int cSoftHdAudio::Setup(AVCodecContext *ctx, int samplerate, int channels, int passthrough)
{
    int err = 0;
 
    m_pTimebase = &ctx->pkt_timebase;
 
    // skip setup, nothing changed
    if (samplerate == (int)m_hwSampleRate &&
       (channels == (int)m_hwNumChannels || (m_downmix && m_hwNumChannels == 2)))
        return 1;
 
    err = AlsaSetup(channels, samplerate, passthrough);
    if (err)
        LOGERROR("audio: %s: failed!", __FUNCTION__);
 
    return err;
}
 
AVFrame *cSoftHdAudio::FilterGetFrame(void)
{
    AVFrame *outframe = nullptr;
    outframe = av_frame_alloc();
    if (!outframe) {
        LOGERROR("audio: %s: Error allocating frame", __FUNCTION__);
        return NULL;
    }
 
    int err = av_buffersink_get_frame(m_pBuffersinkCtx, outframe);
 
    if (err == AVERROR(EAGAIN)) {
//      LOGERROR("audio: %s: Error filtering AVERROR(EAGAIN)", __FUNCTION__);
        av_frame_free(&outframe);
    } else if (err == AVERROR_EOF) {
        LOGERROR("audio: %s: Error filtering AVERROR_EOF", __FUNCTION__);
        av_frame_free(&outframe);
    } else if (err < 0) {
        LOGERROR("audio: %s: Error filtering the data", __FUNCTION__);
        av_frame_free(&outframe);
    }
 
    return outframe;
}
 
int cSoftHdAudio::CheckForFilterReady(AVCodecContext *ctx)
{
    if (m_filterReady && m_filterChanged) {
//      LOGDEBUG2(L_SOUND, "audio: %s: m_filterReady %d sink_links_count %d channels %d nb_filters %d nb_outputs %d channels %d m_filterChanged %d",
//          __FUNCTION__, m_filterReady,
//          m_pFilterGraph->sink_links_count, m_pFilterGraph->sink_links[0]->channels,
//          m_pFilterGraph->filters[m_pFilterGraph->nb_filters - 1]->nb_outputs,
//          m_pFilterGraph->nb_filters, m_pFilterGraph->filters[m_pFilterGraph->nb_filters - 1]->outputs[m_pFilterGraph->filters[m_pFilterGraph->nb_filters - 1]->nb_outputs - 1]->channels,
//          m_filterChanged);
        avfilter_graph_free(&m_pFilterGraph);
        m_filterReady = 0;
        LOGDEBUG2(L_SOUND, "audio: %s: Free the filter graph.", __FUNCTION__);
    }
 
    if (!m_filterReady) {
        if (InitFilter(ctx)) {
            LOGDEBUG2(L_SOUND, "audio: %s: AudioFilterReady failed!", __FUNCTION__);
            return 1;
        }
    }
 
    return 0;
}
 
void cSoftHdAudio::Filter(AVFrame *inframe, AVCodecContext *ctx)
{
    AVFrame *outframe = NULL;
    int err = -1;
    int err_count = 0;
 
    if (inframe) {
        while (err < 0) {
            if (CheckForFilterReady(ctx)) {
                av_frame_unref(inframe);
                return;
            }
 
            err = av_buffersrc_add_frame(m_pBuffersrcCtx, inframe);
            if (err < 0) {
                if (err_count) {
                    char errbuf[128];
                    av_strerror(err, errbuf, sizeof(errbuf));
                    LOGERROR("audio: %s: Error submitting the frame to the filter fmt %s channels %d %s", __FUNCTION__,
                        av_get_sample_fmt_name(ctx->sample_fmt), ctx->ch_layout.nb_channels, errbuf);
                    av_frame_unref(inframe);
                    return;
                } else {
                    m_filterChanged = 1;
                    err_count++;
                    LOGDEBUG2(L_SOUND, "audio: %s: m_filterChanged %d  err_count %d", __FUNCTION__, m_filterChanged, err_count);
                }
            }
        }
    }
 
//  if (!inframe)
//      LOGDEBUG2(L_SOUND, "audio: %s: NO inframe!", __FUNCTION__);
 
    outframe = FilterGetFrame();
    EnqueueFrame(outframe);
}
 
void cSoftHdAudio::FlushBuffers(void)
{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    LOGDEBUG2(L_SOUND, "audio: %s", __FUNCTION__);
 
    if (!m_initialized)
        return;
 
    if (m_inputPts != AV_NOPTS_VALUE)
        FlushAlsaBuffers();
 
    m_fillLevel.Reset();
    m_fillLevel.ResetFramesCounters();
    m_pidController.Reset();
    m_pRingbuffer.Reset();
    m_inputPts = AV_NOPTS_VALUE;
    m_filterChanged = 1;
}
 
int cSoftHdAudio::GetUsedBytes(void)
{
    // FIXME: not correct, if multiple buffer are in use
    return m_pRingbuffer.UsedBytes();
}
 
int64_t cSoftHdAudio::GetOutputPtsMs(void)
{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    return GetOutputPtsMsInternal();
}
 
int64_t cSoftHdAudio::GetOutputPtsMsInternal(void)
{
    return PtsToMs(m_inputPts) - FramesToMs(snd_pcm_bytes_to_frames(m_pAlsaPCMHandle, m_pRingbuffer.UsedBytes()));
}
 
int64_t cSoftHdAudio::GetHardwareOutputPtsMs(void)
{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    if (!m_hwSampleRate || !m_pAlsaPCMHandle || m_inputPts == AV_NOPTS_VALUE)
        return AV_NOPTS_VALUE;
 
    snd_pcm_sframes_t delayFrames;
    if (snd_pcm_delay(m_pAlsaPCMHandle, &delayFrames) < 0)
        delayFrames = 0L;
 
    // subtract baseline to ignore pause bursts already in the buffer
    delayFrames -= m_hwBaseline;
 
    return GetOutputPtsMsInternal() - FramesToMs(delayFrames);
}
 
int64_t cSoftHdAudio::GetHardwareOutputDelayMs(void)
{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    if (!m_hwSampleRate || !m_pAlsaPCMHandle || m_inputPts == AV_NOPTS_VALUE)
        return AV_NOPTS_VALUE;
 
    snd_pcm_sframes_t delayFrames;
    if (snd_pcm_delay(m_pAlsaPCMHandle, &delayFrames) < 0)
        delayFrames = 0L;
 
    return FramesToMs(delayFrames);
}
 
int64_t cSoftHdAudio::GetHardwareOutputPtsTimebaseUnits(void)
{
    int64_t ptsMs = GetHardwareOutputPtsMs();
    if (ptsMs == AV_NOPTS_VALUE)
        return AV_NOPTS_VALUE;
 
    return MsToPts(ptsMs);
}
 
void cSoftHdAudio::SetVolume(int volume)
{
    m_volume = volume;
    // reduce loudness for stereo output
    if (m_stereoDescent && m_hwNumChannels == 2 && !m_passthrough) {
        volume -= m_stereoDescent;
        if (volume < 0) {
            volume = 0;
        } else if (volume > 1000) {
            volume = 1000;
        }
    }
    m_amplifier = volume;
    if (!m_softVolume) {
        AlsaSetVolume(volume);
    }
}
 
void cSoftHdAudio::SetPaused(bool pause)
{
    std::lock_guard<std::mutex> lock(m_pauseMutex);
    LOGDEBUG2(L_SOUND, "audio: %s: %d", __FUNCTION__, pause);
 
    m_paused = pause;
}
 
void cSoftHdAudio::SetNormalize(bool enable, int maxfac)
{
    m_normalize = enable;
    m_normalizeMaxFactor = maxfac;
}
 
void cSoftHdAudio::SetCompression(bool enable, int maxfac)
{
    m_compression = enable;
 
    m_compressionMaxFactor = maxfac;
    if (!m_compressionFactor) {
        m_compressionFactor = 1000;
    }
    if (m_compressionFactor > m_compressionMaxFactor) {
        m_compressionFactor = m_compressionMaxFactor;
    }
}
 
void cSoftHdAudio::SetStereoDescent(int delta)
{
    m_stereoDescent = delta;
    SetVolume(m_volume);    // update channel delta
}
 
void cSoftHdAudio::SetPassthroughMask(int mask)
{
    m_passthrough = mask;
 
    // Reset m_pitchPpm if we change the passthrough handling, otherwise
    // we may continue to adjust the pitch in Enqueue() when in passthrough
    if (m_passthrough)
        m_pitchPpm = 0;
}
 
void cSoftHdAudio::LazyInit()
{
    if (!m_initialized) {
        AlsaInit();
        m_initialized = true;
    }
}
 
void cSoftHdAudio::Exit(void)
{
    LOGDEBUG2(L_SOUND, "audio: %s", __FUNCTION__);
 
    Stop();
 
    if (!m_initialized)
        return;
 
    avfilter_graph_free(&m_pFilterGraph);
    AlsaExit();
    m_initialized = false;
}
 
/******************************************************************************
 * A L S A
 *****************************************************************************/
 
void cSoftHdAudio::HandleError(int error)
{
 
    if (snd_pcm_state(m_pAlsaPCMHandle) == SND_PCM_STATE_XRUN && m_passthrough == 0)
        m_eventQueue.push_back(BufferUnderrunEvent{AUDIO});
 
    if (snd_pcm_recover(m_pAlsaPCMHandle, error, 0) < 0)
        LOGERROR("audio: %s: Cannot recover: %s", __FUNCTION__, snd_strerror(error));
 
    snd_pcm_prepare(m_pAlsaPCMHandle);
}
 
void cSoftHdAudio::FlushAlsaBuffers(void)
{
    FlushAlsaBuffersInternal(false);
}
 
void cSoftHdAudio::DropAlsaBuffers(void)
{
    FlushAlsaBuffersInternal(true);
}
 
void cSoftHdAudio::FlushAlsaBuffersInternal(bool drop)
{
    snd_pcm_state_t state = snd_pcm_state(m_pAlsaPCMHandle);
    if (state == SND_PCM_STATE_OPEN)
        return;
 
    LOGDEBUG2(L_SOUND, "audio: %s entered in pcm state %s", __FUNCTION__, snd_pcm_state_name(state));
 
    int err;
    if (m_passthrough && !drop) {
        switch (state) {
            case SND_PCM_STATE_SETUP:
            case SND_PCM_STATE_XRUN:
            case SND_PCM_STATE_DRAINING:
                err = snd_pcm_prepare(m_pAlsaPCMHandle);
                if (err < 0)
                    LOGERROR("audio: %s: snd_pcm_prepare(): %s", __FUNCTION__, snd_strerror(err));
                break;
            default:
                break;
        }
    } else {
        err = snd_pcm_drop(m_pAlsaPCMHandle);
        if (err < 0)
            LOGERROR("audio: %s: snd_pcm_drop(): %s", __FUNCTION__, snd_strerror(err));
        err = snd_pcm_prepare(m_pAlsaPCMHandle);
        if (err < 0)
            LOGERROR("audio: %s: snd_pcm_prepare(): %s", __FUNCTION__, snd_strerror(err));
    }
 
    // reset audio processing values
    m_compressionFactor = 2000;
    if (m_compressionFactor > m_compressionMaxFactor)
        m_compressionFactor = m_compressionMaxFactor;
 
    m_normalizeCounter = 0;
    m_normalizeReady = 0;
 
    for (int i = 0; i < NORMALIZE_MAX_INDEX; ++i)
        m_normalizeAverage[i] = 0U;
 
    m_normalizeFactor = 1000;
 
    state = snd_pcm_state(m_pAlsaPCMHandle);
    LOGDEBUG2(L_SOUND, "audio: %s left in pcm state %s", __FUNCTION__, snd_pcm_state_name(state));
}
 
/******************************************************************************
 * Thread playback
 *****************************************************************************/
 
void cSoftHdAudio::Action(void)
{
    LOGDEBUG("audio: thread started");
    while (Running()) {
        bool scheduleImmediately = CyclicCall();
        ProcessEvents();
 
        if (scheduleImmediately)
            usleep(1000);
        else
            usleep(10000);
    }
    LOGDEBUG("audio: thread stopped");
}
 
void cSoftHdAudio::Stop(void)
{
    if (!Active())
        return;
 
    LOGDEBUG("audio: stopping thread");
    Cancel(2);
}
 
bool cSoftHdAudio::CyclicCall(void)
{
    std::lock_guard<std::mutex> lock1(m_pauseMutex);
 
    // do nothing in paused PCM mode
    if (m_paused && !m_passthrough)
        return false;
 
    // check, if the alsa device is ready for input
    int ret = snd_pcm_wait(m_pAlsaPCMHandle, 150);
    if (ret < 0) {
        LOGDEBUG2(L_SOUND, "audio: %s: Handle error in wait", __FUNCTION__);
        HandleError(ret);
        return false;
    } else if (ret == 0) {
        snd_pcm_state_t state = snd_pcm_state(m_pAlsaPCMHandle);
        LOGERROR("audio: %s: snd_pcm_wait() timeout (state %s)", __FUNCTION__, snd_pcm_state_name(state));
        if (state == SND_PCM_STATE_PREPARED) {
            LOGDEBUG2(L_SOUND, "audio: %s: force start", __FUNCTION__);
            snd_pcm_start(m_pAlsaPCMHandle);
            return true;
        }
        return false;
    }
 
    std::lock_guard<std::mutex> lock2(m_mutex);
 
    // query available space in alsa buffer
    int freeAlsaBufferFrames = snd_pcm_avail_update(m_pAlsaPCMHandle);
    if (freeAlsaBufferFrames < 0) {
        if (freeAlsaBufferFrames == -EAGAIN) {
            LOGDEBUG2(L_SOUND, "audio: %s: -EAGAIN", __FUNCTION__);
            return true;
        }
 
        LOGDEBUG2(L_SOUND, "audio: %s: Handle error in avail", __FUNCTION__);
        HandleError(freeAlsaBufferFrames);
        return false;
    }
 
    size_t freeAlsaBufferBytes = snd_pcm_frames_to_bytes(m_pAlsaPCMHandle, freeAlsaBufferFrames);
    if (m_passthrough && m_paused) {
        // only write, if there is space for a full pause burst
        if ((int)freeAlsaBufferBytes < m_spdifBurstSize)
            return false;
 
        // send a pause burst to keep the audio stream locked
        return SendPause();
    }
 
    return SendAudio(freeAlsaBufferFrames);
}
 
bool cSoftHdAudio::SendAudio(int freeAlsaBufferFrames)
{
    int bytesToWrite;
    int freeAlsaBufferBytes = snd_pcm_frames_to_bytes(m_pAlsaPCMHandle, freeAlsaBufferFrames);
 
    // query ringbuffer fill level
    const void *data;
    ssize_t ringBufferFillLevelBytes = m_pRingbuffer.GetReadPointer(&data);
 
    bytesToWrite = std::min(freeAlsaBufferBytes, (int)ringBufferFillLevelBytes);
 
    if (bytesToWrite == 0)
        return false;
 
    // muting pass-through AC-3, can produce disturbance
    if (m_volume == 0 || (m_softVolume && !m_passthrough)) {
        // FIXME: quick&dirty cast
        SoftAmplify((int16_t *) data, bytesToWrite);
        // FIXME: if not all are written, we double amplify them
    }
 
    int framesToWrite = snd_pcm_bytes_to_frames(m_pAlsaPCMHandle, bytesToWrite);
    int framesWritten;
    if (m_alsaUseMmap)
        framesWritten = snd_pcm_mmap_writei(m_pAlsaPCMHandle, data, framesToWrite);
    else
        framesWritten = snd_pcm_writei(m_pAlsaPCMHandle, data, framesToWrite);
 
    m_fillLevel.WroteFrames(framesWritten);
 
    int bytesWritten = snd_pcm_frames_to_bytes(m_pAlsaPCMHandle, framesWritten);
    m_pRingbuffer.ReadAdvance(bytesWritten);
 
    if (framesWritten < 0) {
        if (framesWritten == -EAGAIN) {
            LOGDEBUG2(L_SOUND, "audio: %s: -EAGAIN", __FUNCTION__);
            return true;
        }
 
        LOGWARNING("audio: %s: writei failed: %s", __FUNCTION__, snd_strerror(framesWritten));
 
        if (snd_pcm_recover(m_pAlsaPCMHandle, framesWritten, 0) < 0)
            LOGERROR("audio: %s: failed to recover from writei: %s", __FUNCTION__, snd_strerror(framesWritten));
 
        return false;
    }
 
    if (framesWritten != framesToWrite) {
        LOGWARNING("audio: %s: not all frames written", __FUNCTION__);
        return false;
    }
 
    return true;
}
 
bool cSoftHdAudio::SendPause(void)
{
    int framesToWrite = snd_pcm_bytes_to_frames(m_pAlsaPCMHandle, m_spdifBurstSize);
 
    int framesWritten;
    if (m_alsaUseMmap)
        framesWritten = snd_pcm_mmap_writei(m_pAlsaPCMHandle, m_pauseBurst.data(), framesToWrite);
    else
        framesWritten = snd_pcm_writei(m_pAlsaPCMHandle, m_pauseBurst.data(), framesToWrite);
 
    if (framesWritten != framesToWrite) {
        if (framesWritten < 0) {
            if (framesWritten == -EAGAIN)
                return true;
 
            LOGWARNING("audio: %s: writei failed: %s", __FUNCTION__, snd_strerror(framesWritten));
 
            if (snd_pcm_recover(m_pAlsaPCMHandle, framesWritten, 0) < 0)
                LOGERROR("audio: %s: failed to recover from writei: %s", __FUNCTION__, snd_strerror(framesWritten));
 
            return false;
        } else {
            LOGWARNING("audio: %s: not all frames written", __FUNCTION__);
            return false;
        }
    }
 
//  LOGDEBUG2(L_SOUND, "audio: %s: %d frames (%dms) written", __FUNCTION__, framesWritten, FramesToMs(framesWritten));
    return true;
}
 
void cSoftHdAudio::SetHwDelayBaseline(void)
{
    if (!m_firstRealAudioReceived) {
        m_hwBaseline = 0;
 
        if (!m_passthrough)
            return;
 
        snd_pcm_sframes_t delayFrames = 0;
        if (snd_pcm_delay(m_pAlsaPCMHandle, &delayFrames) >= 0)
            m_hwBaseline = delayFrames;
 
        LOGDEBUG2(L_SOUND, "audio: %s: first real audio was sent, hwBaseline %ld frames (%dms)", __FUNCTION__, m_hwBaseline, FramesToMs(m_hwBaseline));
        m_firstRealAudioReceived = true;
    }
}
 
void cSoftHdAudio::ResetHwDelayBaseline(void)
{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    LOGDEBUG2(L_SOUND, "audio: %s: reset hw delay baseline to 0", __FUNCTION__);
    m_hwBaseline = 0;
    m_firstRealAudioReceived = false;
}
 
void cSoftHdAudio::ProcessEvents(void)
{
    for (Event event : m_eventQueue)
        m_pEventReceiver->OnEventReceived(event);
 
    m_eventQueue.clear();
}
 
char *cSoftHdAudio::OpenAlsaDevice(const char *device, int passthrough)
{
    int err;
    char tmp[80];
 
    if (!device)
        return NULL;
 
    LOGDEBUG2(L_SOUND, "audio: %s: try opening %sdevice '%s'", __FUNCTION__, passthrough ? "pass-through " : "", device);
 
    if (passthrough && m_appendAES) {
        if (!(strchr(device, ':'))) {
            sprintf(tmp, "%s:AES0=%d,AES1=%d,AES2=0,AES3=%d",
                device,
                IEC958_AES0_NONAUDIO | IEC958_AES0_PRO_EMPHASIS_NONE,
                IEC958_AES1_CON_ORIGINAL | IEC958_AES1_CON_PCM_CODER,
                IEC958_AES3_CON_FS_48000);
        } else {
            sprintf(tmp, "%s,AES0=%d,AES1=%d,AES2=0,AES3=%d",
                device,
                IEC958_AES0_NONAUDIO | IEC958_AES0_PRO_EMPHASIS_NONE,
                IEC958_AES1_CON_ORIGINAL | IEC958_AES1_CON_PCM_CODER,
                IEC958_AES3_CON_FS_48000);
        }
        LOGDEBUG2(L_SOUND, "audio: %s: auto append AES: %s -> %s", __FUNCTION__, device, tmp);
    } else {
        sprintf(tmp, "%s", device);
    }
 
    // open none blocking; if device is already used, we don't want wait
    if ((err = snd_pcm_open(&m_pAlsaPCMHandle, tmp, SND_PCM_STREAM_PLAYBACK,
        SND_PCM_NONBLOCK)) < 0) {
 
        LOGWARNING("audio: %s: could not open device '%s' error: %s", __FUNCTION__, device, snd_strerror(err));
        return NULL;
    }
 
    LOGDEBUG2(L_SOUND, "audio: %s: opened %sdevice '%s'", __FUNCTION__, passthrough ? "pass-through " : "", device);
 
    return (char *)device;
}
 
char *cSoftHdAudio::FindAlsaDevice(const char *devname, const char *hint, int passthrough)
{
    char **hints;
    int err;
    char **n;
    char *name;
 
    err = snd_device_name_hint(-1, devname, (void ***)&hints);
    if (err != 0) {
        LOGWARNING("audio: %s: Cannot get device names for %s!", __FUNCTION__, hint);
        return NULL;
    }
 
    n = hints;
    while (*n != NULL) {
        name = snd_device_name_get_hint(*n, "NAME");
 
        if (name && strstr(name, hint)) {
            if (OpenAlsaDevice(name, passthrough)) {
                snd_device_name_free_hint((void **)hints);
                return name;
            }
        }
 
        if (name)
            free(name);
        n++;
    }
 
    snd_device_name_free_hint((void **)hints);
    return NULL;
}
 
void cSoftHdAudio::AlsaInitPCMDevice(void)
{
    char *device = NULL;
    bool freeDevice = false;  // track if device needs to be freed
    int err;
    LOGDEBUG2(L_SOUND, "audio: %s: passthrough %d", __FUNCTION__, m_passthrough);
 
    // try user set device
    if (m_passthrough)
        device = OpenAlsaDevice(m_pPassthroughDevice, m_passthrough);
 
    if (!device && m_passthrough)
        device = OpenAlsaDevice(getenv("ALSA_PASSTHROUGH_DEVICE"), m_passthrough);
 
    if (!device)
        device = OpenAlsaDevice(m_pPCMDevice, m_passthrough);
 
    if (!device)
        device = OpenAlsaDevice(getenv("ALSA_DEVICE"), m_passthrough);
 
    // walkthrough hdmi: devices
    if (!device) {
        LOGDEBUG2(L_SOUND, "audio: %s: Try hdmi: devices...", __FUNCTION__);
        device = FindAlsaDevice("pcm", "hdmi:", m_passthrough);
        freeDevice = (device != NULL);  // FindAlsaDevice allocates memory
    }
 
    // Rockchip mainline kernel
    if (!device) {
        LOGDEBUG2(L_SOUND, "audio: %s: Try default:CARD=hdmisound devices...", __FUNCTION__);
        device = FindAlsaDevice("pcm", "default:CARD=hdmisound", m_passthrough);
        freeDevice = (device != NULL);  // FindAlsaDevice allocates memory
    }
 
    // walkthrough default: devices
    if (!device) {
        LOGDEBUG2(L_SOUND, "audio: %s: Try default: devices...", __FUNCTION__);
        device = FindAlsaDevice("pcm", "default:", m_passthrough);
        freeDevice = (device != NULL);  // FindAlsaDevice allocates memory
    }
 
    // try default device
    if (!device) {
        LOGDEBUG2(L_SOUND, "audio: %s: Try default device...", __FUNCTION__);
        device = OpenAlsaDevice("default", m_passthrough);
    }
 
    // use null device
    if (!device) {
        LOGDEBUG2(L_SOUND, "audio: %s: Try null device...", __FUNCTION__);
        device = OpenAlsaDevice("null", m_passthrough);
    }
 
    if (!device)
        LOGFATAL("audio: %s: could not open any device, abort!", __FUNCTION__);
 
    if (!strcmp(device, "null"))
        LOGWARNING("audio: %s: using %sdevice '%s'", __FUNCTION__,
            m_passthrough ? "pass-through " : "", device);
    else
        LOGINFO("audio: using %sdevice '%s'",
            m_passthrough ? "pass-through " : "", device);
 
    // Free device string if it was allocated by FindAlsaDevice
    if (freeDevice)
        free(device);
 
    if ((err = snd_pcm_nonblock(m_pAlsaPCMHandle, 0)) < 0) {
        LOGERROR("audio: %s: can't set block mode: %s", __FUNCTION__, snd_strerror(err));
    }
}
 
/******************************************************************************
 * Alsa Mixer
 *****************************************************************************/
 
void cSoftHdAudio::AlsaInitMixer(void)
{
    const char *device;
    const char *channel;
    snd_mixer_t *alsaMixer;
    snd_mixer_elem_t *alsaMixerElem;
    long alsaMixerElemMin;
    long alsaMixerElemMax;
 
    if (!(device = m_pMixerDevice)) {
        if (!(device = getenv("ALSA_MIXER"))) {
            device = "default";
        }
    }
    if (!(channel = m_pMixerChannel)) {
        if (!(channel = getenv("ALSA_MIXER_CHANNEL"))) {
            channel = "PCM";
        }
    }
    LOGDEBUG2(L_SOUND, "audio: %s: mixer %s - %s open", __FUNCTION__, device, channel);
    snd_mixer_open(&alsaMixer, 0);
    if (alsaMixer && snd_mixer_attach(alsaMixer, device) >= 0
        && snd_mixer_selem_register(alsaMixer, NULL, NULL) >= 0
        && snd_mixer_load(alsaMixer) >= 0) {
 
        const char *const alsaMixerElem_name = channel;
 
        alsaMixerElem = snd_mixer_first_elem(alsaMixer);
        while (alsaMixerElem) {
            const char *name;
 
            name = snd_mixer_selem_get_name(alsaMixerElem);
            if (!strcasecmp(name, alsaMixerElem_name)) {
                snd_mixer_selem_get_playback_volume_range(alsaMixerElem, &alsaMixerElemMin, &alsaMixerElemMax);
                m_alsaRatio = 1000 * (alsaMixerElemMax - alsaMixerElemMin);
                LOGDEBUG2(L_SOUND, "audio: %s: %s mixer found %ld - %ld ratio %d", __FUNCTION__, channel, alsaMixerElemMin, alsaMixerElemMax, m_alsaRatio);
                break;
            }
 
            alsaMixerElem = snd_mixer_elem_next(alsaMixerElem);
        }
 
        m_pAlsaMixer = alsaMixer;
        m_pAlsaMixerElem = alsaMixerElem;
    } else {
        LOGERROR("audio: %s: can't open mixer '%s'", __FUNCTION__, device);
    }
}
 
void cSoftHdAudio::AlsaSetVolume(int volume)
{
    int v;
    if (m_pAlsaMixer && m_pAlsaMixerElem) {
        v = (volume * m_alsaRatio) / (1000 * 1000);
        snd_mixer_selem_set_playback_volume(m_pAlsaMixerElem, SND_MIXER_SCHN_FRONT_LEFT, v);
        snd_mixer_selem_set_playback_volume(m_pAlsaMixerElem, SND_MIXER_SCHN_FRONT_RIGHT, v);
    }
}
 
int cSoftHdAudio::AlsaSetup(int channels, int sample_rate, int passthrough)
{
    snd_pcm_hw_params_t *hwparams;
    int err;
    unsigned bufferTimeUs = 100'000;
 
    if (Active()) {
        Stop();
        DropAlsaBuffers();
    }
 
    m_downmix = 0;
 
    snd_pcm_hw_params_alloca(&hwparams);
    if ((err = snd_pcm_hw_params_any(m_pAlsaPCMHandle, hwparams)) < 0) {
        LOGERROR("audio: %s: Read HW config failed! %s", __FUNCTION__, snd_strerror(err));
        return -1;
    }
 
    if (!snd_pcm_hw_params_test_access(m_pAlsaPCMHandle, hwparams, SND_PCM_ACCESS_MMAP_INTERLEAVED)) {
        m_alsaUseMmap = true;
    }
 
    m_hwSampleRate = sample_rate;
    if ((err = snd_pcm_hw_params_set_rate_near(m_pAlsaPCMHandle, hwparams, &m_hwSampleRate, 0)) < 0) {
        LOGERROR("audio: %s: SampleRate %d not supported! %s", __FUNCTION__, sample_rate, snd_strerror(err));
        return -1;
    }
    if ((int)m_hwSampleRate != sample_rate) {
        LOGDEBUG2(L_SOUND, "audio: %s: sample_rate %d m_hwSampleRate %d", __FUNCTION__, sample_rate, m_hwSampleRate);
    }
 
    m_hwNumChannels = channels;
    if ((err = snd_pcm_hw_params_set_channels_near(m_pAlsaPCMHandle, hwparams, &m_hwNumChannels)) < 0) {
        LOGWARNING("audio: %s: %d channels not supported! %s", __FUNCTION__, m_hwNumChannels, snd_strerror(err));
    }
    if ((int)m_hwNumChannels != channels && !passthrough) {
        m_downmix = 1;
    }
    if ((err = snd_pcm_hw_params_set_buffer_time_near(m_pAlsaPCMHandle, hwparams, &bufferTimeUs, NULL)) < 0) {
        LOGWARNING("audio: %s: bufferTime %d not supported! %s", __FUNCTION__, bufferTimeUs, snd_strerror(err));
    }
 
    snd_pcm_uframes_t periodSize = 0;
    if ((err = snd_pcm_hw_params_get_period_size_max(hwparams, &periodSize, NULL)) < 0) {
        LOGWARNING("audio: %s: getting max periodSize not supported! %s", __FUNCTION__, snd_strerror(err));
    }
 
    snd_pcm_uframes_t bufferSize = 0;
    if ((err = snd_pcm_hw_params_get_buffer_size_max(hwparams, &bufferSize)) < 0) {
        LOGWARNING("audio: %s: getting max bufferSize not supported! %s", __FUNCTION__, snd_strerror(err));
    }
 
    m_alsaBufferSizeFrames = MsToFrames(bufferTimeUs / 1000);
 
/*  err = snd_pcm_hw_params_test_format(m_pAlsaPCMHandle, hwparams, SND_PCM_FORMAT_S16);
    if (err < 0)    // err == 0 if is supported
        LOGERROR("audio: %s: SND_PCM_FORMAT_S16 not supported! %s", __FUNCTION__,
            snd_strerror(err));
*/
    if ((err = snd_pcm_set_params(m_pAlsaPCMHandle, SND_PCM_FORMAT_S16,
        m_alsaUseMmap ? SND_PCM_ACCESS_MMAP_INTERLEAVED :
        SND_PCM_ACCESS_RW_INTERLEAVED, m_hwNumChannels, m_hwSampleRate, 1, bufferTimeUs))) {
 
        snd_pcm_state_t state = snd_pcm_state(m_pAlsaPCMHandle);
        LOGERROR("audio: %s: set params error: %s\n"
            "           Channels %d SampleRate %d\n"
            "           HWChannels %d HWSampleRate %d SampleFormat %s\n"
            "           mmap: %s\n"
            "           AlsaBufferTime %dms pcm state: %s\n"
            "           periodSize %d frames, bufferSize %d frames",
            __FUNCTION__,
            snd_strerror(err), channels, sample_rate, m_hwNumChannels,
            m_hwSampleRate, snd_pcm_format_name(SND_PCM_FORMAT_S16),
            m_alsaUseMmap ? "yes" : "no",
            bufferTimeUs / 1000, snd_pcm_state_name(state),
            periodSize, bufferSize);
        return -1;
    }
 
    auto alsaMap = GetAlsaChannelLayoutAsArray(m_pAlsaPCMHandle);
    std::string channelMapString;
    for (size_t i = 0; i < alsaMap.size(); i++) {
        channelMapString += alsaMap[i];
        if (i < alsaMap.size() - 1)
            channelMapString += " ";
    }
 
    snd_pcm_state_t state = snd_pcm_state(m_pAlsaPCMHandle);
    LOGINFO("audio: %s:\n"
        "           Channels %d (%s) SampleRate %d%s\n"
        "           HWChannels %d HWSampleRate %d SampleFormat %s\n"
        "           mmap: %s\n"
        "           AlsaBufferTime %dms, pcm state: %s\n"
        "           periodSize %d frames, bufferSize %d frames",
        __FUNCTION__,
        channels, channelMapString.c_str(), sample_rate, passthrough ? " -> passthrough" : "",
        m_hwNumChannels, m_hwSampleRate,
        snd_pcm_format_name(SND_PCM_FORMAT_S16),
        m_alsaUseMmap ? "yes" : "no",
        bufferTimeUs / 1000, snd_pcm_state_name(state),
        periodSize, bufferSize);
 
    Start();
 
    return 0;
}
 
static void AlsaNoopCallback( __attribute__ ((unused))
    const char *file, __attribute__ ((unused))
    int line, __attribute__ ((unused))
    const char *function, __attribute__ ((unused))
    int err, __attribute__ ((unused))
    const char *fmt, ...)
{
}
 
void cSoftHdAudio::AlsaInit(void)
{
#ifdef ALSA_DEBUG
    (void)AlsaNoopCallback;
#else
    // disable display of alsa error messages
    snd_lib_error_set_handler(AlsaNoopCallback);
#endif
 
    AlsaInitPCMDevice();
    AlsaInitMixer();
}
 
void cSoftHdAudio::AlsaExit(void)
{
    if (m_pAlsaPCMHandle) {
        snd_pcm_close(m_pAlsaPCMHandle);
        m_pAlsaPCMHandle = NULL;
    }
    if (m_pAlsaMixer) {
        snd_mixer_close(m_pAlsaMixer);
        m_pAlsaMixer = NULL;
        m_pAlsaMixerElem = NULL;
    }
}
 
void cSoftHdAudio::ClockDriftCompensation(void)
{
    if (m_passthrough)
        return;
 
    double bufferFillLevelMs = FramesToMsDouble(m_fillLevel.GetBufferFillLevelFramesAvg());
    if (m_fillLevel.IsSettled()) {
        auto now = std::chrono::steady_clock::now();
        std::chrono::duration<double> elapsedSec = now - m_lastPidInvocation;
        m_lastPidInvocation = now;
 
        m_pitchPpm = m_pidController.Update(bufferFillLevelMs, elapsedSec.count()) * -1;
    } else
        m_pidController.SetTargetValue(bufferFillLevelMs);
 
    if (m_packetCounter++ % 1000 == 0) {
        LOGDEBUG2(L_SOUND, "audio: %s: buffer fill level: %.1fms (target: %.1fms), clock drift compensating pitch: %.1fppm, PID controller: P=%.2fppm I=%.2fppm D=%.2fppm",
            __FUNCTION__,
            bufferFillLevelMs,
            m_pidController.GetTargetValue(),
            m_pitchPpm.load(),
            m_pidController.GetPTerm(),
            m_pidController.GetITerm(),
            m_pidController.GetDTerm());
    }
 
    // buffer fill level low pass filter
    int hardwareBufferFillLevelFrames = m_alsaBufferSizeFrames - snd_pcm_avail(m_pAlsaPCMHandle);
 
    if (hardwareBufferFillLevelFrames < 0)
        LOGWARNING("audio: %s: snd_pcm_avail() failes: %s", __FUNCTION__, snd_strerror(hardwareBufferFillLevelFrames));
    else
        m_fillLevel.UpdateAvgBufferFillLevel(hardwareBufferFillLevelFrames);
}