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