osx/corelayer.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2004-2025 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/>.
 */
 
#ifndef CORE_LAYER_H_
#define CORE_LAYER_H_
 
#include "audio/audiolayer.h"
#include <AudioToolbox/AudioToolbox.h>
 
#define checkErr(err) \
    if (err) { \
        OSStatus error = static_cast<OSStatus>(err); \
        fprintf(stdout, "CoreAudio Error: %ld ->  %s:  %d\n", (long) error, __FILE__, __LINE__); \
        fflush(stdout); \
    }
 
namespace jami {
 
class RingBuffer;
class AudioDevice;
 
class CoreLayer : public AudioLayer
{
public:
    CoreLayer(const AudioPreference& pref);
    ~CoreLayer();
 
    virtual std::vector<std::string> getCaptureDeviceList() const;
    virtual std::vector<std::string> getPlaybackDeviceList() const;
 
    virtual int getAudioDeviceIndex(const std::string& name, AudioDeviceType type) const;
    virtual std::string getAudioDeviceName(int index, AudioDeviceType type) const;
 
    virtual int getIndexCapture() const { return indexIn_; }
 
    virtual int getIndexPlayback() const { return indexOut_; }
 
    virtual int getIndexRingtone() const { return indexRing_; }
 
    void initAudioLayerIO(AudioDeviceType stream);
 
    virtual void startStream(AudioDeviceType stream = AudioDeviceType::ALL);
 
    void destroyAudioLayer();
 
    virtual void stopStream(AudioDeviceType stream = AudioDeviceType::ALL);
 
private:
    NON_COPYABLE(CoreLayer);
 
    void initAudioFormat();
 
    static OSStatus outputCallback(void* inRefCon,
                                   AudioUnitRenderActionFlags* ioActionFlags,
                                   const AudioTimeStamp* inTimeStamp,
                                   UInt32 inBusNumber,
                                   UInt32 inNumberFrames,
                                   AudioBufferList* ioData);
 
    void write(AudioUnitRenderActionFlags* ioActionFlags,
               const AudioTimeStamp* inTimeStamp,
               UInt32 inBusNumber,
               UInt32 inNumberFrames,
               AudioBufferList* ioData);
 
    static OSStatus inputCallback(void* inRefCon,
                                  AudioUnitRenderActionFlags* ioActionFlags,
                                  const AudioTimeStamp* inTimeStamp,
                                  UInt32 inBusNumber,
                                  UInt32 inNumberFrames,
                                  AudioBufferList* ioData);
    static OSStatus deviceIsAliveCallback(AudioObjectID inObjectID,
                                          UInt32 inNumberAddresses,
                                          const AudioObjectPropertyAddress inAddresses[],
                                          void* inRefCon);
    static OSStatus devicesChangedCallback(AudioObjectID inObjectID,
                                           UInt32 inNumberAddresses,
                                           const AudioObjectPropertyAddress inAddresses[],
                                           void* inRefCon);
 
    void read(AudioUnitRenderActionFlags* ioActionFlags,
              const AudioTimeStamp* inTimeStamp,
              UInt32 inBusNumber,
              UInt32 inNumberFrames,
              AudioBufferList* ioData);
 
    virtual void updatePreference(AudioPreference& pref, int index, AudioDeviceType type);
 
    int indexIn_;
 
    int indexOut_;
 
    int indexRing_;
 
    AudioUnit ioUnit_;
 
    Float64 inSampleRate_;
    UInt32 inChannelsPerFrame_;
    Float64 outSampleRate_;
    UInt32 outChannelsPerFrame_;
 
    std::vector<AudioDevice> getDeviceList(bool getCapture) const;
};
 
} // namespace jami
 
#endif // CORE_LAYER_H_