libs/backends/coreaudio/coreaudio_pcmio.h

   1 /*
   2  * Copyright (C) 2015 Robin Gareus <robin@gareus.org>
   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 2 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, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 #include <CoreServices/CoreServices.h>
  20 #include <CoreAudio/CoreAudio.h>
  21 #include <AudioUnit/AudioUnit.h>
  22
  23 #include <AudioUnit/AudioUnit.h>
  24 #include <AudioToolbox/AudioToolbox.h>
  25
  26 #include <map>
  27 #include <vector>
  28 #include <string>
  29
  30 #define AUHAL_OUTPUT_ELEMENT 0
  31 #define AUHAL_INPUT_ELEMENT 1
  32
  33
  34 class CoreAudioPCM {
  35 public:
  36         CoreAudioPCM (void);
  37         ~CoreAudioPCM (void);
  38
  39
  40         int      state (void) const { return _state; }
  41         uint32_t n_playback_channels (void) const { return _playback_channels; }
  42         uint32_t n_capture_channels (void) const { return _capture_channels; }
  43
  44         void     discover();
  45         void     device_list (std::map<size_t, std::string> &devices) const { devices = _devices;}
  46
  47         int      available_sample_rates (uint32_t device_id, std::vector<float>& sampleRates);
  48         int      available_buffer_sizes (uint32_t device_id, std::vector<uint32_t>& sampleRates);
  49         uint32_t available_channels (uint32_t device_id, bool input);
  50         float    current_sample_rate (uint32_t device_id, bool input = false);
  51         uint32_t get_latency (uint32_t device_id, bool input);
  52
  53         std::string cached_port_name (uint32_t portnum, bool input) const;
  54
  55         float    sample_rate ();
  56         uint32_t samples_per_period () const { return _samples_per_period; };
  57
  58         int      set_samples_per_period (uint32_t);
  59
  60         void     launch_control_app (uint32_t device_id);
  61
  62         void     pcm_stop (void);
  63         int      pcm_start (
  64                         uint32_t input_device,
  65                         uint32_t output_device,
  66                         uint32_t sample_rate,
  67                         uint32_t samples_per_period,
  68                         int (process_callback (void*, const uint32_t, const uint64_t)),
  69                         void * process_arg
  70                         );
  71
  72         void     set_error_callback (
  73                         void ( error_callback (void*)),
  74                         void * error_arg
  75                         ) {
  76                 _error_callback = error_callback;
  77                 _error_arg = error_arg;
  78         }
  79
  80         void     set_hw_changed_callback (
  81                         void ( callback (void*)),
  82                         void * arg
  83                         ) {
  84                 _hw_changed_callback = callback;
  85                 _hw_changed_arg = arg;
  86         }
  87
  88         void     set_xrun_callback (
  89                         void ( callback (void*)),
  90                         void * arg
  91                         ) {
  92                 _xrun_callback = callback;
  93                 _xrun_arg = arg;
  94         }
  95         void     set_buffer_size_callback (
  96                         void ( callback (void*)),
  97                         void * arg
  98                         ) {
  99                 _buffer_size_callback = callback;
 100                 _buffer_size_arg = arg;
 101         }
 102         void     set_sample_rate_callback (
 103                         void ( callback (void*)),
 104                         void * arg
 105                         ) {
 106                 _sample_rate_callback = callback;
 107                 _sample_rate_arg = arg;
 108         }
 109
 110         // must be called from process_callback;
 111         int      get_capture_channel (uint32_t chn, float *input, uint32_t n_samples);
 112         int      set_playback_channel (uint32_t chn, const float *input, uint32_t n_samples);
 113         uint32_t n_samples() const { return _cur_samples_per_period; };
 114
 115         // really private
 116         OSStatus render_callback (
 117                         AudioUnitRenderActionFlags* ioActionFlags,
 118                         const AudioTimeStamp* inTimeStamp,
 119                         UInt32 inBusNumber,
 120                         UInt32 inNumberFrames,
 121                         AudioBufferList* ioData);
 122
 123         void xrun_callback ();
 124         void buffer_size_callback ();
 125         void sample_rate_callback ();
 126         void hw_changed_callback ();
 127
 128 private:
 129         float    current_sample_rate_id (AudioDeviceID id, bool input);
 130         uint32_t current_buffer_size_id (AudioDeviceID id);
 131         int      set_device_sample_rate_id (AudioDeviceID id, float rate, bool input);
 132         int      set_device_buffer_size_id (AudioDeviceID id, uint32_t samples_per_period);
 133         int      set_device_sample_rate (uint32_t device_id, float rate, bool input);
 134         void     get_stream_latencies (uint32_t device_id, bool input, std::vector<uint32_t>& latencies);
 135         void     cache_port_names (AudioDeviceID id, bool input);
 136
 137         void destroy_aggregate_device();
 138         int  create_aggregate_device(
 139                         AudioDeviceID input_device_id,
 140                         AudioDeviceID output_device_id,
 141                         uint32_t sample_rate,
 142                         AudioDeviceID *created_device);
 143
 144
 145         AudioUnit _auhal;
 146         AudioDeviceID* _device_ids;
 147         AudioBufferList* _input_audio_buffer_list;
 148         AudioBufferList* _output_audio_buffer_list;
 149
 150         AudioDeviceID _active_device_id;
 151         AudioDeviceID _aggregate_device_id;
 152         AudioDeviceID _aggregate_plugin_id;
 153
 154         int _state;
 155
 156         uint32_t _samples_per_period;
 157         uint32_t _cur_samples_per_period;
 158         uint32_t _capture_channels;
 159         uint32_t _playback_channels;
 160         bool     _in_process;
 161         size_t   _n_devices;
 162
 163         int (* _process_callback) (void*, const uint32_t, const uint64_t);
 164         void * _process_arg;
 165
 166         void (* _error_callback) (void*);
 167         void  * _error_arg;
 168
 169         void (* _hw_changed_callback) (void*);
 170         void  * _hw_changed_arg;
 171
 172         void (* _xrun_callback) (void*);
 173         void  * _xrun_arg;
 174
 175         void (* _buffer_size_callback) (void*);
 176         void  * _buffer_size_arg;
 177
 178         void (* _sample_rate_callback) (void*);
 179         void  * _sample_rate_arg;
 180
 181
 182         // TODO proper device info struct
 183         std::map<size_t, std::string> _devices;
 184         uint32_t * _device_ins;
 185         uint32_t * _device_outs;
 186         std::vector<std::string> _input_names;
 187         std::vector<std::string> _output_names;
 188
 189         pthread_mutex_t _discovery_lock;
 190 };