2 * Copyright (C) 2015 Robin Gareus <robin@gareus.org>
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.
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.
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.
24 #include "portaudio_io.h"
26 #define INTERLEAVED_INPUT
27 #define INTERLEAVED_OUTPUT
29 using namespace ARDOUR;
31 PortAudioIO::PortAudioIO ()
33 , _initialized (false)
34 , _capture_channels (0)
35 , _playback_channels (0)
39 , _cur_sample_rate (0)
40 , _cur_input_latency (0)
41 , _cur_output_latency (0)
45 PortAudioIO::~PortAudioIO ()
54 clear_device_lists ();
56 free (_input_buffer); _input_buffer = NULL;
57 free (_output_buffer); _output_buffer = NULL;
62 PortAudioIO::available_sample_rates(int device_id, std::vector<float>& sampleRates)
64 static const float ardourRates[] = { 8000.0, 22050.0, 24000.0, 44100.0, 48000.0, 88200.0, 96000.0, 176400.0, 192000.0};
68 // TODO use separate int device_input, int device_output ?!
69 if (device_id == -1) {
70 device_id = get_default_input_device ();
73 printf("PortAudio: Querying Samplerates for device %d\n", device_id);
77 const PaDeviceInfo* nfo = Pa_GetDeviceInfo(device_id);
80 PaStreamParameters inputParam;
81 PaStreamParameters outputParam;
83 inputParam.device = device_id;
84 inputParam.channelCount = nfo->maxInputChannels;
85 inputParam.sampleFormat = paFloat32;
86 inputParam.suggestedLatency = 0;
87 inputParam.hostApiSpecificStreamInfo = 0;
89 outputParam.device = device_id;
90 outputParam.channelCount = nfo->maxOutputChannels;
91 outputParam.sampleFormat = paFloat32;
92 outputParam.suggestedLatency = 0;
93 outputParam.hostApiSpecificStreamInfo = 0;
95 for (uint32_t i = 0; i < sizeof(ardourRates)/sizeof(float); ++i) {
96 if (paFormatIsSupported == Pa_IsFormatSupported(
97 nfo->maxInputChannels > 0 ? &inputParam : NULL,
98 nfo->maxOutputChannels > 0 ? &outputParam : NULL,
100 sampleRates.push_back (ardourRates[i]);
105 if (sampleRates.empty()) {
106 // fill in something..
107 sampleRates.push_back (44100.0);
108 sampleRates.push_back (48000.0);
115 PortAudioIO::available_buffer_sizes(int device_id, std::vector<uint32_t>& bufferSizes)
118 static const uint32_t ardourSizes[] = { 64, 128, 256, 512, 1024, 2048, 4096 };
119 for(uint32_t i = 0; i < sizeof(ardourSizes)/sizeof(uint32_t); ++i) {
120 bufferSizes.push_back (ardourSizes[i]);
126 PortAudioIO::input_device_list(std::map<int, std::string> &devices) const
128 for (std::map<int, paDevice*>::const_iterator i = _input_devices.begin ();
129 i != _input_devices.end ();
131 devices.insert (std::pair<int, std::string>(i->first, Glib::locale_to_utf8(i->second->name)));
136 PortAudioIO::output_device_list(std::map<int, std::string> &devices) const
138 for (std::map<int, paDevice*>::const_iterator i = _output_devices.begin ();
139 i != _output_devices.end ();
141 devices.insert (std::pair<int, std::string>(i->first, Glib::locale_to_utf8(i->second->name)));
146 PortAudioIO::initialize_pa ()
148 PaError err = paNoError;
151 err = Pa_Initialize();
152 if (err != paNoError) {
162 PortAudioIO::host_api_list (std::vector<std::string>& api_list)
164 if (!initialize_pa()) return;
166 PaHostApiIndex count = Pa_GetHostApiCount();
168 if (count < 0) return;
170 for (int i = 0; i < count; ++i) {
171 const PaHostApiInfo* info = Pa_GetHostApiInfo (i);
172 if (info->name != NULL) { // possible?
173 api_list.push_back (info->name);
179 PortAudioIO::set_host_api (const std::string& host_api_name)
181 _host_api_index = get_host_api_index_from_name (host_api_name);
183 if (_host_api_index < 0) {
184 fprintf(stderr, "Error setting host API\n");
189 PortAudioIO::get_host_api_index_from_name (const std::string& name)
191 if (!initialize_pa()) return -1;
193 PaHostApiIndex count = Pa_GetHostApiCount();
195 if (count < 0) return -1;
197 for (int i = 0; i < count; ++i) {
198 const PaHostApiInfo* info = Pa_GetHostApiInfo (i);
199 if (info->name != NULL) { // possible?
200 if (name == info->name) return i;
207 PortAudioIO::get_default_input_device ()
209 const PaHostApiInfo* info = Pa_GetHostApiInfo (_host_api_index);
210 if (info == NULL) return -1;
211 return info->defaultInputDevice;
215 PortAudioIO::get_default_output_device ()
217 const PaHostApiInfo* info = Pa_GetHostApiInfo (_host_api_index);
218 if (info == NULL) return -1;
219 return info->defaultOutputDevice;
223 PortAudioIO::clear_device_lists ()
225 for (std::map<int, paDevice*>::const_iterator i = _input_devices.begin (); i != _input_devices.end(); ++i) {
228 _input_devices.clear();
230 for (std::map<int, paDevice*>::const_iterator i = _output_devices.begin (); i != _output_devices.end(); ++i) {
233 _output_devices.clear();
237 PortAudioIO::add_default_devices ()
239 const PaHostApiInfo* info = Pa_GetHostApiInfo (_host_api_index);
240 if (info == NULL) return;
242 const PaDeviceInfo* nfo_i = Pa_GetDeviceInfo(get_default_input_device());
243 const PaDeviceInfo* nfo_o = Pa_GetDeviceInfo(get_default_output_device());
244 if (nfo_i && nfo_o) {
245 _input_devices.insert (std::pair<int, paDevice*> (-1,
246 new paDevice("Default",
247 nfo_i->maxInputChannels,
248 nfo_o->maxOutputChannels
250 _output_devices.insert (std::pair<int, paDevice*> (-1,
251 new paDevice("Default",
252 nfo_i->maxInputChannels,
253 nfo_o->maxOutputChannels
259 PortAudioIO::add_devices ()
261 const PaHostApiInfo* info = Pa_GetHostApiInfo (_host_api_index);
262 if (info == NULL) return;
264 int n_devices = Pa_GetDeviceCount();
266 printf("PortAudio %d devices found:\n", n_devices);
269 for (int i = 0 ; i < n_devices; ++i) {
270 const PaDeviceInfo* nfo = Pa_GetDeviceInfo(i);
273 if (nfo->hostApi != _host_api_index) continue;
275 printf(" (%d) '%s' '%s' in: %d (lat: %.1f .. %.1f) out: %d (lat: %.1f .. %.1f) sr:%.2f\n",
276 i, info->name, nfo->name,
277 nfo->maxInputChannels,
278 nfo->defaultLowInputLatency * 1e3,
279 nfo->defaultHighInputLatency * 1e3,
280 nfo->maxOutputChannels,
281 nfo->defaultLowOutputLatency * 1e3,
282 nfo->defaultHighOutputLatency * 1e3,
283 nfo->defaultSampleRate);
285 if ( nfo->maxInputChannels == 0 && nfo->maxOutputChannels == 0) {
289 if (nfo->maxInputChannels > 0) {
290 _input_devices.insert (std::pair<int, paDevice*> (i, new paDevice(
292 nfo->maxInputChannels,
293 nfo->maxOutputChannels
296 if (nfo->maxOutputChannels > 0) {
297 _output_devices.insert (std::pair<int, paDevice*> (i, new paDevice(
299 nfo->maxInputChannels,
300 nfo->maxOutputChannels
307 PortAudioIO::discover()
309 if (!initialize_pa()) return;
311 clear_device_lists ();
312 add_default_devices ();
317 PortAudioIO::pcm_stop ()
320 Pa_CloseStream (_stream);
324 _capture_channels = 0;
325 _playback_channels = 0;
326 _cur_sample_rate = 0;
327 _cur_input_latency = 0;
328 _cur_output_latency = 0;
330 free (_input_buffer); _input_buffer = NULL;
331 free (_output_buffer); _output_buffer = NULL;
336 PortAudioIO::pcm_start()
338 PaError err = Pa_StartStream (_stream);
340 if (err != paNoError) {
348 static uint32_t lower_power_of_two (uint32_t v) {
361 PortAudioIO::pcm_setup (
362 int device_input, int device_output,
363 double sample_rate, uint32_t samples_per_period)
367 // TODO error reporting sans fprintf()
369 PaError err = paNoError;
370 const PaDeviceInfo *nfo_in;
371 const PaDeviceInfo *nfo_out;
372 const PaStreamInfo *nfo_s;
374 if (!initialize_pa()) {
375 fprintf(stderr, "PortAudio Initialization Failed\n");
379 if (device_input == -1) {
380 device_input = get_default_input_device ();
382 if (device_output == -1) {
383 device_output = get_default_output_device ();
386 _capture_channels = 0;
387 _playback_channels = 0;
388 _cur_sample_rate = 0;
389 _cur_input_latency = 0;
390 _cur_output_latency = 0;
393 printf("PortAudio Device IDs: i:%d o:%d\n", device_input, device_output);
396 nfo_in = Pa_GetDeviceInfo(device_input);
397 nfo_out = Pa_GetDeviceInfo(device_output);
399 if (!nfo_in && ! nfo_out) {
400 fprintf(stderr, "PortAudio Cannot Query Device Info\n");
405 _capture_channels = nfo_in->maxInputChannels;
408 _playback_channels = nfo_out->maxOutputChannels;
411 if(_capture_channels == 0 && _playback_channels == 0) {
412 fprintf(stderr, "PortAudio no Input and no output channels.\n");
418 // pa_mac_core_blocking.c pa_stable_v19_20140130
419 // BUG: ringbuffer alloc requires power-of-two chn count.
420 if ((_capture_channels & (_capture_channels - 1)) != 0) {
421 printf("Adjusted capture channes to power of two (portaudio rb bug)\n");
422 _capture_channels = lower_power_of_two (_capture_channels);
425 if ((_playback_channels & (_playback_channels - 1)) != 0) {
426 printf("Adjusted capture channes to power of two (portaudio rb bug)\n");
427 _playback_channels = lower_power_of_two (_playback_channels);
432 printf("PortAudio Channels: in:%d out:%d\n",
433 _capture_channels, _playback_channels);
436 PaStreamParameters inputParam;
437 PaStreamParameters outputParam;
440 inputParam.device = device_input;
441 inputParam.channelCount = _capture_channels;
442 #ifdef INTERLEAVED_INPUT
443 inputParam.sampleFormat = paFloat32;
445 inputParam.sampleFormat = paFloat32 | paNonInterleaved;
447 inputParam.suggestedLatency = nfo_in->defaultLowInputLatency;
448 inputParam.hostApiSpecificStreamInfo = NULL;
452 outputParam.device = device_output;
453 outputParam.channelCount = _playback_channels;
454 #ifdef INTERLEAVED_OUTPUT
455 outputParam.sampleFormat = paFloat32;
457 outputParam.sampleFormat = paFloat32 | paNonInterleaved;
459 outputParam.suggestedLatency = nfo_out->defaultLowOutputLatency;
460 outputParam.hostApiSpecificStreamInfo = NULL;
463 // XXX re-consider using callback API, testing needed.
464 err = Pa_OpenStream (
466 _capture_channels > 0 ? &inputParam: NULL,
467 _playback_channels > 0 ? &outputParam: NULL,
470 paClipOff | paDitherOff,
473 if (err != paNoError) {
474 fprintf(stderr, "PortAudio failed to start stream.\n");
478 nfo_s = Pa_GetStreamInfo (_stream);
480 fprintf(stderr, "PortAudio failed to query stream information.\n");
485 _cur_sample_rate = nfo_s->sampleRate;
486 _cur_input_latency = nfo_s->inputLatency * _cur_sample_rate;
487 _cur_output_latency = nfo_s->outputLatency * _cur_sample_rate;
490 printf("PA Sample Rate %.1f SPS\n", _cur_sample_rate);
491 printf("PA Input Latency %.1fms %d spl\n", 1e3 * nfo_s->inputLatency, _cur_input_latency);
492 printf("PA Output Latency %.1fms %d spl\n", 1e3 * nfo_s->outputLatency, _cur_output_latency);
497 if (_capture_channels > 0) {
498 _input_buffer = (float*) malloc (samples_per_period * _capture_channels * sizeof(float));
499 if (!_input_buffer) {
500 fprintf(stderr, "PortAudio failed to allocate input buffer.\n");
506 if (_playback_channels > 0) {
507 _output_buffer = (float*) calloc (samples_per_period * _playback_channels, sizeof(float));
508 if (!_output_buffer) {
509 fprintf(stderr, "PortAudio failed to allocate output buffer.\n");
518 _capture_channels = 0;
519 _playback_channels = 0;
520 free (_input_buffer); _input_buffer = NULL;
521 free (_output_buffer); _output_buffer = NULL;
526 PortAudioIO::next_cycle (uint32_t n_samples)
530 err = Pa_IsStreamActive (_stream);
532 // 0: inactive / aborted
537 // TODO, check drift.. process part with larger capacity first.
538 // Pa_GetStreamReadAvailable(_stream) < Pa_GetStreamWriteAvailable(_stream)
540 if (_playback_channels > 0) {
541 err = Pa_WriteStream (_stream, _output_buffer, n_samples);
542 if (err) xrun = true;
545 if (_capture_channels > 0) {
546 err = Pa_ReadStream (_stream, _input_buffer, n_samples);
548 memset (_input_buffer, 0, sizeof(float) * n_samples * _capture_channels);
558 #ifdef INTERLEAVED_INPUT
561 PortAudioIO::get_capture_channel (uint32_t chn, float *input, uint32_t n_samples)
563 assert(chn < _capture_channels);
564 const uint32_t stride = _capture_channels;
565 float *ptr = _input_buffer + chn;
566 while (n_samples-- > 0) {
576 PortAudioIO::get_capture_channel (uint32_t chn, float *input, uint32_t n_samples)
578 assert(chn < _capture_channels);
579 memcpy((void*)input, &(_input_buffer[chn * n_samples]), n_samples * sizeof(float));
586 #ifdef INTERLEAVED_OUTPUT
589 PortAudioIO::set_playback_channel (uint32_t chn, const float *output, uint32_t n_samples)
591 assert(chn < _playback_channels);
592 const uint32_t stride = _playback_channels;
593 float *ptr = _output_buffer + chn;
594 while (n_samples-- > 0) {
604 PortAudioIO::set_playback_channel (uint32_t chn, const float *output, uint32_t n_samples)
606 assert(chn < _playback_channels);
607 memcpy((void*)&(_output_buffer[chn * n_samples]), (void*)output, n_samples * sizeof(float));