Line data    Source code

       1             : /*
       2             :  *  Copyright (C) 2004-2026 Savoir-faire Linux Inc.
       3             :  *
       4             :  *  This program is free software: you can redistribute it and/or modify
       5             :  *  it under the terms of the GNU General Public License as published by
       6             :  *  the Free Software Foundation, either version 3 of the License, or
       7             :  *  (at your option) any later version.
       8             :  *
       9             :  *  This program is distributed in the hope that it will be useful,
      10             :  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             :  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      12             :  *  GNU General Public License for more details.
      13             :  *
      14             :  *  You should have received a copy of the GNU General Public License
      15             :  *  along with this program. If not, see <https://www.gnu.org/licenses/>.
      16             :  */
      17             : 
      18             : #pragma once
      19             : 
      20             : #include "noncopyable.h"
      21             : #include "logger.h"
      22             : #include "audio/audiolayer.h"
      23             : #include "pulseloopbackcapture.h"
      24             : 
      25             : #include <pulse/pulseaudio.h>
      26             : #include <pulse/stream.h>
      27             : 
      28             : #include <list>
      29             : #include <string>
      30             : #include <memory>
      31             : #include <thread>
      32             : 
      33             : namespace jami {
      34             : 
      35             : class AudioPreference;
      36             : class AudioStream;
      37             : class RingBuffer;
      38             : 
      39             : /**
      40             :  * Convenience structure to hold PulseAudio device propreties such as supported channel number etc.
      41             :  */
      42             : struct PaDeviceInfos
      43             : {
      44             :     uint32_t index {0};
      45             :     std::string name {};
      46             :     std::string description {"default"};
      47             :     pa_sample_spec sample_spec {};
      48             :     pa_channel_map channel_map {};
      49             :     uint32_t monitor_of {PA_INVALID_INDEX};
      50             : 
      51           0 :     PaDeviceInfos() {}
      52             : 
      53           0 :     PaDeviceInfos(const pa_source_info& source)
      54           0 :         : index(source.index)
      55           0 :         , name(source.name)
      56           0 :         , description(source.description)
      57           0 :         , sample_spec(source.sample_spec)
      58           0 :         , channel_map(source.channel_map)
      59           0 :         , monitor_of(source.monitor_of_sink)
      60           0 :     {}
      61             : 
      62           0 :     PaDeviceInfos(const pa_sink_info& source)
      63           0 :         : index(source.index)
      64           0 :         , name(source.name)
      65           0 :         , description(source.description)
      66           0 :         , sample_spec(source.sample_spec)
      67           0 :         , channel_map(source.channel_map)
      68           0 :     {}
      69             : 
      70             :     /**
      71             :      * Unary function to search for a device by name in a list using std functions.
      72             :      */
      73             :     class NameComparator
      74             :     {
      75             :     public:
      76           0 :         explicit NameComparator(const std::string& ref)
      77           0 :             : baseline(ref)
      78           0 :         {}
      79           0 :         bool operator()(const PaDeviceInfos& arg) { return arg.name == baseline; }
      80             : 
      81             :     private:
      82             :         const std::string& baseline;
      83             :     };
      84             : 
      85             :     class DescriptionComparator
      86             :     {
      87             :     public:
      88           0 :         explicit DescriptionComparator(const std::string& ref)
      89           0 :             : baseline(ref)
      90           0 :         {}
      91           0 :         bool operator()(const PaDeviceInfos& arg) { return arg.description == baseline; }
      92             : 
      93             :     private:
      94             :         const std::string& baseline;
      95             :     };
      96             : };
      97             : 
      98             : class PulseMainLoopLock
      99             : {
     100             : public:
     101             :     explicit PulseMainLoopLock(pa_threaded_mainloop* loop);
     102             :     ~PulseMainLoopLock();
     103             : 
     104             : private:
     105             :     NON_COPYABLE(PulseMainLoopLock);
     106             :     pa_threaded_mainloop* loop_;
     107             : };
     108             : 
     109             : class PulseLayer : public AudioLayer
     110             : {
     111             : public:
     112             :     PulseLayer(AudioPreference& pref);
     113             :     ~PulseLayer();
     114             : 
     115             :     /**
     116             :      * Write data from the ring buffer to the hardware and read data
     117             :      * from the hardware.
     118             :      */
     119             :     void readFromMic();
     120             :     void writeToSpeaker();
     121             :     void ringtoneToSpeaker();
     122             : 
     123             :     void updateSinkList();
     124             :     void updateSourceList();
     125             :     void updateServerInfo();
     126             : 
     127             :     bool inSinkList(const std::string& deviceName);
     128             :     bool inSourceList(const std::string& deviceName);
     129             : 
     130             :     virtual std::vector<std::string> getCaptureDeviceList() const;
     131             :     virtual std::vector<std::string> getPlaybackDeviceList() const;
     132             :     int getAudioDeviceIndex(const std::string& descr, AudioDeviceType type) const;
     133             :     int getAudioDeviceIndexByName(const std::string& name, AudioDeviceType type) const;
     134             : 
     135             :     std::string getAudioDeviceName(int index, AudioDeviceType type) const;
     136             : 
     137             :     virtual void startStream(AudioDeviceType stream);
     138             :     virtual void startCaptureStream(const std::string& id) override;
     139             :     virtual void stopCaptureStream(const std::string& id) override;
     140             :     virtual void stopStream(AudioDeviceType stream = AudioDeviceType::ALL);
     141             : 
     142             : private:
     143             :     static void context_state_callback(pa_context* c, void* user_data);
     144             :     static void context_changed_callback(pa_context* c, pa_subscription_event_type_t t, uint32_t idx, void* userdata);
     145             :     void contextStateChanged(pa_context* c);
     146             :     void contextChanged(pa_context*, pa_subscription_event_type_t, uint32_t idx);
     147             : 
     148             :     static void source_input_info_callback(pa_context* c, const pa_source_info* i, int eol, void* userdata);
     149             :     static void sink_input_info_callback(pa_context* c, const pa_sink_info* i, int eol, void* userdata);
     150             :     static void server_info_callback(pa_context*, const pa_server_info* i, void* userdata);
     151             : 
     152             :     virtual void updatePreference(AudioPreference& pref, int index, AudioDeviceType type);
     153             : 
     154             :     virtual int getIndexCapture() const;
     155             :     virtual int getIndexPlayback() const;
     156             :     virtual int getIndexRingtone() const;
     157             : 
     158             :     void waitForDevices();
     159             :     void waitForDeviceList();
     160             : 
     161             :     std::string getPreferredPlaybackDevice() const;
     162             :     std::string getPreferredRingtoneDevice() const;
     163             :     std::string getPreferredCaptureDevice() const;
     164             : 
     165             :     NON_COPYABLE(PulseLayer);
     166             : 
     167             :     /**
     168             :      * Create the audio stream
     169             :      */
     170             :     void createStream(std::unique_ptr<AudioStream>& stream,
     171             :                       AudioDeviceType type,
     172             :                       const PaDeviceInfos& dev_infos,
     173             :                       bool ec,
     174             :                       std::function<void(size_t)>&& onData);
     175             : 
     176           0 :     std::unique_ptr<AudioStream>& getStream(AudioDeviceType type)
     177             :     {
     178           0 :         if (type == AudioDeviceType::PLAYBACK)
     179           0 :             return playback_;
     180           0 :         else if (type == AudioDeviceType::RINGTONE)
     181           0 :             return ringtone_;
     182           0 :         else if (type == AudioDeviceType::CAPTURE)
     183           0 :             return record_;
     184             :         else
     185           0 :             return playback_;
     186             :     }
     187             : 
     188             :     /**
     189             :      * Close the connection with the local pulseaudio server
     190             :      */
     191             :     void disconnectAudioStream();
     192             :     void onStreamReady();
     193             : 
     194             :     /**
     195             :      * Returns a pointer to the PaEndpointInfos with the given name in sourceList_, or nullptr if
     196             :      * not found.
     197             :      */
     198             :     const PaDeviceInfos* getDeviceInfos(const std::vector<PaDeviceInfos>&, const std::string& name) const;
     199             : 
     200             :     std::atomic_uint pendingStreams {0};
     201             : 
     202             :     /**
     203             :      * A stream object to handle the pulseaudio playback stream
     204             :      */
     205             :     std::unique_ptr<AudioStream> playback_;
     206             : 
     207             :     /**
     208             :      * A stream object to handle the pulseaudio capture stream
     209             :      */
     210             :     std::unique_ptr<AudioStream> record_;
     211             : 
     212             :     /**
     213             :      * A special stream object to handle specific playback stream for ringtone
     214             :      */
     215             :     std::unique_ptr<AudioStream> ringtone_;
     216             : 
     217             :     /**
     218             :      * A class that implements methods to capture desktop audio
     219             :      */
     220             :     PulseLoopbackCapture loopbackCapture_;
     221             : 
     222             :     /**
     223             :      * Contains the list of playback devices
     224             :      */
     225             :     std::vector<PaDeviceInfos> sinkList_ {};
     226             : 
     227             :     /**
     228             :      * Contains the list of capture devices
     229             :      */
     230             :     std::vector<PaDeviceInfos> sourceList_ {};
     231             : 
     232             :     /** PulseAudio server defaults */
     233             :     AudioFormat defaultAudioFormat_ {AudioFormat::MONO()};
     234             :     std::string defaultSink_ {};
     235             :     std::string defaultSource_ {};
     236             : 
     237             :     /** PulseAudio context and asynchronous loop */
     238             :     pa_context* context_ {nullptr};
     239             :     std::unique_ptr<pa_threaded_mainloop, decltype(pa_threaded_mainloop_free)&> mainloop_;
     240             :     bool enumeratingSinks_ {false};
     241             :     bool enumeratingSources_ {false};
     242             :     bool gettingServerInfo_ {false};
     243             :     std::atomic_bool waitingDeviceList_ {false};
     244             :     std::mutex readyMtx_ {};
     245             :     std::condition_variable readyCv_ {};
     246             :     std::thread streamStarter_ {};
     247             : 
     248             :     AudioPreference& preference_;
     249             : 
     250             :     pa_operation* subscribeOp_ {nullptr};
     251             :     friend class AudioLayerTest;
     252             : };
     253             : 
     254             : } // namespace jami