audiolayer.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2004-2026 Savoir-faire Linux Inc.
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
#pragma once
 
#include "ringbuffer.h"
#include "noncopyable.h"
#include "audio_frame_resizer.h"
#include "audio-processing/audio_processor.h"
 
#include <chrono>
#include <mutex>
#include <vector>
#include <atomic>
#include <condition_variable>
 
extern "C" {
struct SpeexEchoState_;
typedef struct SpeexEchoState_ SpeexEchoState;
}
 
// Define the audio api
#define AAUDIO_API_STR     "aaudio"
#define PULSEAUDIO_API_STR "pulseaudio"
#define ALSA_API_STR       "alsa"
#define JACK_API_STR       "jack"
#define COREAUDIO_API_STR  "coreaudio"
#define PORTAUDIO_API_STR  "portaudio"
 
#define PCM_DEFAULT     "default"     // Default ALSA plugin
#define PCM_DSNOOP      "plug:dsnoop" // Alsa plugin for microphone sharing
#define PCM_DMIX_DSNOOP "dmix/dsnoop" // Audio profile using Alsa dmix/dsnoop
 
namespace jami {
 
class AudioPreference;
class Resampler;
 
enum class AudioDeviceType : int8_t { ALL = -1, PLAYBACK = 0, CAPTURE, RINGTONE };
 
class AudioLayer
{
private:
    NON_COPYABLE(AudioLayer);
 
protected:
    enum class Status : uint8_t { Idle, Starting, Started };
 
public:
    AudioLayer(const AudioPreference&);
    virtual ~AudioLayer();
 
    virtual void startStream(AudioDeviceType stream) = 0;
 
    virtual void startCaptureStream(const std::string& id) { (void) id; };
 
    virtual void stopCaptureStream(const std::string& id) { (void) id; };
 
    virtual void stopStream(AudioDeviceType stream = AudioDeviceType::ALL) = 0;
 
    virtual std::vector<std::string> getCaptureDeviceList() const = 0;
    virtual std::vector<std::string> getPlaybackDeviceList() const = 0;
 
    virtual int getAudioDeviceIndex(const std::string& name, AudioDeviceType type) const = 0;
    virtual std::string getAudioDeviceName(int index, AudioDeviceType type) const = 0;
    virtual int getIndexCapture() const = 0;
    virtual int getIndexPlayback() const = 0;
    virtual int getIndexRingtone() const = 0;
 
    inline bool isStarted() const { return status_ == Status::Started; }
 
    template<class Rep, class Period>
    bool waitForStart(const std::chrono::duration<Rep, Period>& rel_time) const
    {
        std::unique_lock lk(mutex_);
        startedCv_.wait_for(lk, rel_time, [this] { return isStarted(); });
        return isStarted();
    }
 
    void putUrgent(std::shared_ptr<AudioFrame> buffer);
 
    void playIncomingCallNotification(bool play) { playIncomingCallBeep_.exchange(play); }
 
    void flushMain();
 
    void flushUrgent();
 
    bool isCaptureMuted() const { return isCaptureMuted_; }
 
    void muteCapture(bool muted) { isCaptureMuted_ = muted; }
 
    bool isPlaybackMuted() const { return isPlaybackMuted_; }
 
    void mutePlayback(bool muted) { isPlaybackMuted_ = muted; }
 
    bool isRingtoneMuted() const { return isRingtoneMuted_; }
    void muteRingtone(bool muted) { isRingtoneMuted_ = muted; }
 
    void setCaptureGain(double gain) { captureGain_ = gain; }
 
    double getCaptureGain() const { return captureGain_; }
 
    void setPlaybackGain(double gain) { playbackGain_ = gain; }
 
    double getPlaybackGain() const { return playbackGain_; }
 
    unsigned int getSampleRate() const { return audioFormat_.sample_rate; }
 
    AudioFormat getFormat() const { return audioFormat_; }
 
    void notifyIncomingCall();
 
    virtual void updatePreference(AudioPreference& pref, int index, AudioDeviceType type) = 0;
 
protected:
    void hardwareFormatAvailable(AudioFormat playback, size_t bufSize = 0);
 
    void hardwareInputFormatAvailable(AudioFormat capture);
 
    void devicesChanged();
 
    void playbackChanged(bool started);
    void recordChanged(bool started);
    void setHasNativeAEC(bool hasEAC);
    void setHasNativeNS(bool hasNS);
 
    std::shared_ptr<AudioFrame> getToPlay(AudioFormat format, size_t writableSamples);
    std::shared_ptr<AudioFrame> getToRing(AudioFormat format, size_t writableSamples);
    std::shared_ptr<AudioFrame> getPlayback(AudioFormat format, size_t samples)
    {
        const auto& ringBuff = getToRing(format, samples);
        const auto& playBuff = getToPlay(format, samples);
        return ringBuff ? ringBuff : playBuff;
    }
 
    void putRecorded(std::shared_ptr<AudioFrame>&& frame);
 
    void flush();
 
    bool isCaptureMuted_;
 
    bool isPlaybackMuted_;
 
    bool isRingtoneMuted_ {false};
 
    bool playbackStarted_ {false};
    bool recordStarted_ {false};
    bool hasNativeAEC_ {true};
    bool hasNativeNS_ {false};
 
    double captureGain_;
 
    double playbackGain_;
 
    // audio processor preferences
    const AudioPreference& pref_;
 
    std::shared_ptr<RingBuffer> mainRingBuffer_;
    std::unique_ptr<AudioFrameResizer> playbackQueue_;
 
    std::atomic<Status> status_ {Status::Idle};
    mutable std::condition_variable startedCv_;
 
    AudioFormat audioFormat_;
 
    AudioFormat audioInputFormat_;
 
    size_t nativeFrameSize_ {0};
 
    RingBuffer urgentRingBuffer_;
 
    mutable std::mutex mutex_ {};
 
    std::unique_ptr<Resampler> resampler_;
 
private:
    std::mutex audioProcessorMutex {};
    std::unique_ptr<AudioProcessor> audioProcessor;
 
    void createAudioProcessor();
    void destroyAudioProcessor();
 
    // Set to "true" to play the incoming call notification (beep)
    // when the playback is on (typically when there is already an
    // active call).
    std::atomic_bool playIncomingCallBeep_ {false};
    std::chrono::system_clock::time_point lastNotificationTime_ {std::chrono::system_clock::time_point::min()};
};
 
} // namespace jami