audio.h

Go to the documentation of this file.

 
#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 "event.h"
#include "filllevel.h"
#include "pidcontroller.h"
#include "ringbuffer.h"
 
#define NORMALIZE_MAX_INDEX 128 
#define AV_SYNC_BORDER_MS 5000  
 
class cAudioThread;
class cSoftHdConfig;
class cSoftHdDevice;
 
class cSoftHdAudio {
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 Enqueue(uint16_t *, int, AVFrame *);
    bool IsBufferFull(void) { return m_pRingbuffer.FreeBytes() <= AUDIO_MIN_BUFFER_FREE; }
 
    void FlushBuffers(void);
    int GetUsedBytes(void);
    int GetFreeBytes(void);
    int64_t GetHardwareOutputPtsMs(void);
    int64_t GetHardwareOutputPtsTimebaseUnits(void);
    int GetPassthrough(void) const { return m_passthrough; }
    bool HasPts(void) { return m_inputPts != AV_NOPTS_VALUE; }
    int64_t GetInputPtsMs(void) { return PtsToMs(m_inputPts); }
    int64_t GetOutputPtsMs(void);
 
    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 SetPassthrough(int);
    void SetAutoAES(bool appendAes) { m_appendAES = appendAes; }
    void SetTimebase(AVRational *timebase) { m_pTimebase = timebase; };
 
    void FlushAlsaBuffers(void);
    bool CyclicCall(void);
    void DropSamplesOlderThanPtsMs(int64_t);
    void ProcessEvents(void);
    void ClockDriftCompensation(void);
 
private:
    constexpr static int AUDIO_MIN_BUFFER_FREE = 3072 * 8 * 8; 
    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;                
 
    // thread
    cAudioThread *m_pAudioThread = nullptr; 
 
    // 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;                       
 
    // 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;               
 
    // Compressor
    bool m_compression;                     
    int m_compressionFactor = 0;            
    int m_compressionMaxFactor;             
 
    // Amplifier
    int m_amplifier;                        
    int m_stereoDescent;                    
    int m_volume;                           
 
    // 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;
    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};                     
 
    void Normalize(uint16_t *, int);
    void Compress(uint16_t *, int);
    void SoftAmplify(int16_t *, int);
    int InitFilter(AVCodecContext *);
 
    void EnqueueFrame(AVFrame *);
 
    // 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;                  
 
    void HandleError(int);
    char *OpenAlsaDevice(const char *, int);
    char *FindAlsaDevice(const char *, const char *, int);
    int AlsaSetup(int channels, int sample_rate, int passthrough);
    void AlsaInitPCMDevice(void);
    void AlsaInitMixer(void);
    void AlsaSetVolume(int);
    void AlsaInit(void);
    void AlsaExit(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; }
 
    int64_t GetOutputPtsMsInternal(void);
};
 
#endif