audio.h

Go to the documentation of this file.

// SPDX-License-Identifier: AGLP-3.0-or-later
 
#ifndef __AUDIO_H
#define __AUDIO_H
 
#include <atomic>
#include <chrono>
#include <mutex>
#include <vector>
 
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavfilter/avfilter.h>
}
 
#include <alsa/asoundlib.h>
 
#include <vdr/thread.h>
 
#include "event.h"
#include "filllevel.h"
#include "pidcontroller.h"
#include "ringbuffer.h"
 
class cSoftHdConfig;
class cSoftHdDevice;
 
class cSoftHdAudio : public cThread {
public:
    cSoftHdAudio(cSoftHdDevice *);
 
    void LazyInit(void);
    void Exit(void);
    int Setup(AVCodecContext *, int , int , int);
    void SetPaused(bool);
    bool IsPaused(void) { return m_paused; };
    void Filter(AVFrame *, AVCodecContext *);
    void EnqueueSpdif(uint16_t *, int, AVFrame *);
    bool IsBufferFull(void) { return m_pRingbuffer.FreeBytes() <= AUDIO_MIN_BUFFER_FREE; }
 
    void FlushBuffers(void);
    int GetUsedBytes(void);
    int64_t GetHardwareOutputPtsMs(void);
    int64_t GetHardwareOutputDelayMs(void);
    int64_t GetHardwareOutputPtsTimebaseUnits(void);
    int GetPassthrough(void) const { return m_passthrough; }
    bool HasInputPts(void) { return m_inputPts != AV_NOPTS_VALUE; }
    int64_t GetInputPtsMs(void) { return PtsToMs(m_inputPts); }
    int64_t GetOutputPtsMs(void);
    int GetAvResyncBorderMs(void) { return AV_SYNC_BORDER_MS; };
 
    void SetEq(int[18], int);
    void SetVolume(int);
    void SetDownmix(int downMix) { m_downmix = downMix; };
    void SetSoftvol(bool softVolume) { m_softVolume = softVolume; };
    void SetNormalize(bool, int);
    void SetCompression(bool, int);
    void SetStereoDescent(int);
    void SetPassthroughMask(int);
    void SetAutoAES(bool appendAes) { m_appendAES = appendAes; }
    void SetTimebase(AVRational *timebase) { m_pTimebase = timebase; };
 
    void DropSamplesOlderThanPtsMs(int64_t);
    void ClockDriftCompensation(void);
    void ResetHwDelayBaseline(void);
    void SetHwDelayBaseline(void);
 
    void Stop(void);
 
protected:
    virtual void Action(void);
 
private:
    constexpr static int AUDIO_MIN_BUFFER_FREE = 3072 * 8 * 8; 
    constexpr static int NORMALIZE_MAX_INDEX = 128;            
    constexpr static int AV_SYNC_BORDER_MS = 5000;             
    cSoftHdDevice *m_pDevice;               
    cSoftHdConfig *m_pConfig;               
    IEventReceiver *m_pEventReceiver;       
    cBufferFillLevelLowPassFilter m_fillLevel;                  
    cPidController m_pidController{3, 0.005, 0, 1000};          
    std::chrono::steady_clock::time_point m_lastPidInvocation;  
    int m_alsaBufferSizeFrames = 0;         
    int m_packetCounter = 0;                
 
    // common audio, alsa
    bool m_initialized = false;             
    const int m_bytesPerSample = 2;         
    unsigned int m_hwSampleRate = 0;        
    unsigned int m_hwNumChannels = 0;       
    AVRational *m_pTimebase;                
    std::mutex m_mutex;                     
    std::mutex m_pauseMutex;                
    std::vector<Event> m_eventQueue;        
    std::atomic<double> m_pitchPpm = 0;     
    int m_pitchAdjustFrameCounter = 0;      
 
    int m_downmix;                          
 
    int64_t m_inputPts = AV_NOPTS_VALUE;    
    std::atomic<bool> m_paused = true;      
 
    bool m_softVolume;                      
    int m_passthrough;                      
    const char *m_pPCMDevice;               
    const char *m_pPassthroughDevice;       
    bool m_appendAES;                       
    int m_spdifBurstSize = 0;               
    std::vector<uint16_t> m_pauseBurst;     
    snd_pcm_sframes_t m_hwBaseline = 0;     
    bool m_firstRealAudioReceived = false;  
 
    void Enqueue(uint16_t *, int, AVFrame *);
    void EnqueueFrame(AVFrame *);
    bool SendAudio(int);
    bool SendPause(void);
    void BuildPauseBurst(void);
 
    // Normalizer
    bool m_normalize;                       
    const int m_normalizeSamples = 4096;    
    int m_normalizeCounter;                 
    uint32_t m_normalizeAverage[NORMALIZE_MAX_INDEX]; 
    int m_normalizeIndex;                   
    int m_normalizeReady;                   
    int m_normalizeFactor;                  
    const int m_normalizeMinFactor = 100;   
    int m_normalizeMaxFactor;               
    void Normalize(uint16_t *, int);
 
    // Compressor
    bool m_compression;                     
    int m_compressionFactor = 0;            
    int m_compressionMaxFactor;             
    void Compress(uint16_t *, int);
 
    // Amplifier
    int m_amplifier;                        
    int m_stereoDescent;                    
    int m_volume = 0;                       
    void SoftAmplify(int16_t *, int);
 
    // Equalizer
    int m_useEqualizer;                     
    float m_equalizerBand[18];              
 
    // mixer
    const char *m_pMixerDevice = nullptr;   
    const char *m_pMixerChannel;            
 
    // filter
    int m_filterChanged = 0;                
    int m_filterReady = 0;                  
    AVFilterGraph *m_pFilterGraph = nullptr;
    AVFilterContext *m_pBuffersrcCtx;
    AVFilterContext *m_pBuffersinkCtx;
    int InitFilter(AVCodecContext *);
    AVFrame *FilterGetFrame(void);
    int CheckForFilterReady(AVCodecContext *);
 
    // ring buffer variables
    static constexpr unsigned RINGBUFFER_SIZE = 3 * 5 * 7 * 8 * 2 * 1000; 
    cSoftHdRingbuffer m_pRingbuffer{RINGBUFFER_SIZE};                     
 
    // alsa
    snd_pcm_t *m_pAlsaPCMHandle;         
    snd_mixer_t *m_pAlsaMixer = nullptr; 
    snd_mixer_elem_t *m_pAlsaMixerElem = nullptr; 
    int m_alsaRatio;                     
    bool m_alsaUseMmap;                  
 
    int AlsaSetup(int channels, int sample_rate, int passthrough);
    char *OpenAlsaDevice(const char *, int);
    char *FindAlsaDevice(const char *, const char *, int);
    void AlsaInitPCMDevice(void);
    void AlsaInitMixer(void);
    void AlsaSetVolume(int);
    void AlsaInit(void);
    void AlsaExit(void);
    void FlushAlsaBuffers(void);
    void DropAlsaBuffers(void);
    void FlushAlsaBuffersInternal(bool);
    bool CyclicCall(void);
    void ProcessEvents(void);
    void HandleError(int);
 
    int64_t GetOutputPtsMsInternal(void);
    int64_t PtsToMs(int64_t pts) { return pts * av_q2d(*m_pTimebase) * 1000; }
    int64_t MsToPts(int64_t ptsMs) { return ptsMs / av_q2d(*m_pTimebase) / 1000; }
    int MsToFrames(int milliseconds) { return (int64_t)milliseconds * m_hwSampleRate / 1000; }
    int FramesToMs(int frames) { return (int64_t)frames * 1000 / m_hwSampleRate; }
    double FramesToMsDouble(int frames) { return (double)frames * 1000 / m_hwSampleRate; }
};
 
#endif