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 <string>
#include <vector>
 
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavfilter/avfilter.h>
}
 
#include <vdr/thread.h>
 
#include "alsadevice.h"
#include "audioprocessor.h"
#include "filllevel.h"
#include "pidcontroller.h"
#include "ringbuffer.h"
#include "statemachine.h"
 
class cSoftHdConfig;
class cSoftHdDevice;
 
class cSoftHdAudio : public cThread {
public:
    cSoftHdAudio(cSoftHdDevice *);
 
    int LazyInit(void);
    void Exit(void);
    int Setup(AVRational, int , int , bool);
    void SetPaused(bool);
    bool IsPaused(void) { return m_paused; };
    void Filter(AVFrame *, AVCodecContext *);
    void EnqueueSpdif(const uint16_t *, int, int64_t pts);
    bool IsBufferFull(void) { return m_pRingbuffer.FreeBytes() <= AUDIO_MIN_BUFFER_FREE; };
    bool IsBufferEmpty(void) { return m_pRingbuffer.UsedBytes() == 0 && m_alsa.GetHwDelayFrames() == 0; };
 
    void FlushBuffers(void);
    int GetUsedRingbufferBytes(void);
    int GetUsedRingbufferMs(void);
    int64_t GetHardwareOutputPtsMs(void);
    int64_t GetHardwareOutputDelayMs(void);
    int64_t GetHardwareOutputPtsTimebaseUnits(void);
    bool HasInputPts(void) { return m_inputPts != AV_NOPTS_VALUE; };
    int64_t GetInputPtsMs(void) { return m_alsa.PtsToMs(m_inputPts, av_q2d(m_timebase)); };
    int64_t GetOutputPtsMs(void);
    int GetAvResyncBorderMs(void) { return AV_SYNC_BORDER_MS; };
 
    void SetTrickSpeed(double, bool, bool);
    void AdvanceTrickSpeedPts(int64_t);
    int64_t GetTrickSpeedPtsTimebaseUnits(void) { return m_trickSpeedPts; };
    void ResetTrickSpeedPts(void) { m_trickSpeedPts = AV_NOPTS_VALUE; };
    bool IsForwardTrickSpeed(void) { return m_forwardTrickspeed; };
    bool IsSlowTrickSpeed(void) { return m_trickspeedFactor <= 1.0 ; };
 
    void SetVolume(int);
    void SetSoftvol(bool softVolume) { m_softVolume = softVolume; };
 
    void SetNormalize(bool, int);
    void SetCompression(bool, int);
    void SetEqualizer(bool, int[18]);
    void SetStereoDescent(int);
 
    void SetPassthroughMask(int mask) { m_alsa.SetPassthroughMask(mask); };
    void SetAutoAES(bool appendAes) { m_alsa.SetAutoAES(appendAes); };
    void SetTimebase(AVRational timebase) { m_timebase = timebase; };
    void SetDownmix(int downMix) { m_alsa.SetDownmix(downMix); };
    int GetPassthroughMask(void) const { return m_alsa.GetPassthroughMask(); };
 
    void DropSamplesOlderThanPtsMs(int64_t);
    void ClockDriftCompensation(void);
    void ResetHwDelayBaseline(void);
    void SetHwDelayBaseline(void);
 
protected:
    virtual void Action(void);
 
private:
    constexpr static int AUDIO_MIN_BUFFER_FREE = 3072 * 8 * 8; 
    constexpr static int AV_SYNC_BORDER_MS = 5000;             
    constexpr static int BYTES_PER_SAMPLE = 2;                 
    constexpr static int64_t PTS_WRAP = 1LL << 33;             
    constexpr static double MAX_TRICKSPEED_STEP_DELAY_MS = 3000; 
 
    cSoftHdDevice *m_pDevice;               
    cSoftHdConfig *m_pConfig;               
    cAlsaDevice m_alsa;                     
    cBufferFillLevelLowPassFilter m_fillLevel;                  
    cPidController m_pidController{3, 0.005, 0, 1000};          
    std::chrono::steady_clock::time_point m_lastPidInvocation;  
    int m_packetCounter = 0;                
 
    // common audio
    bool m_initialized = false;             
    std::mutex m_mutex;                     
    std::mutex m_pauseMutex;                
    std::mutex m_queueMutex;                
    std::vector<Event> m_eventQueue;        
    std::atomic<double> m_pitchPpm = 0;     
    int m_pitchAdjustFrameCounter = 0;      
 
    int m_volume = 0;                       
    int m_stereoDescent;                    
    AVRational m_timebase;                  
 
    int64_t m_inputPts = AV_NOPTS_VALUE;    
    std::atomic<bool> m_paused = true;      
    std::atomic<int64_t> m_trickSpeedPts = AV_NOPTS_VALUE; 
    std::atomic<double> m_trickspeedFactor = 0;   
    std::atomic<bool> m_trickspeed = false;       
    std::atomic<bool> m_forwardTrickspeed = true; 
 
    bool m_softVolume;                      
    int m_spdifBurstSize = 0;               
    std::vector<uint16_t> m_pauseBurst;     
    int m_hwBaseline = 0;                   
    bool m_firstRealAudioReceived = false;  
 
    void Enqueue(const uint16_t *, int, int64_t);
    void EnqueueFrame(AVFrame *);
    bool SendAudio(int);
    bool SendPause(void);
    void RebuildPauseBurst(int);
    void Stop(void);
    void FlushAlsaBuffers(void);
    void DropAlsaBuffers(void);
    bool CyclicCall(void);
    void ProcessEvents(void);
 
    // audio manipulation
    cAudioProcessor m_audioProcessor;
    bool m_useNormalizer;                   
    bool m_useCompressor;                   
    bool m_useEqualizer;                    
 
    // 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 *);
    std::string BuildChannelMapFilter(const AVChannelLayout &);
 
    // ring buffer variables
    static constexpr unsigned RINGBUFFER_SIZE = 3 * 5 * 7 * 8 * 2 * 1000; 
    cSoftHdRingbuffer m_pRingbuffer{RINGBUFFER_SIZE};                     
 
    int64_t GetOutputPtsMsInternal(void);
};
 
#endif