3 * Copyright 2006 Free Software Foundation, Inc.
5 * This file is part of GNU Radio
7 * GNU Radio is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 3, or (at your option)
12 * GNU Radio is distributed in he hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with GNU Radio; see the file COPYING. If not, write to
19 * the Free Software Foundation, Inc., 51 Franklin Street,
20 * Boston, MA 02110-1301, USA.
27 #include <audio_portaudio_sink.h>
28 #include <gr_io_signature.h>
34 #include <gri_portaudio.h>
37 //#define LOGGING 0 // define to 0 or 1
39 #define SAMPLE_FORMAT paFloat32
40 typedef float sample_t;
42 // Number of portaudio buffers in the ringbuffer
43 static const unsigned int N_BUFFERS = 4;
46 default_device_name ()
48 return gr_prefs::singleton()->get_string("audio_portaudio", "default_output_device", "");
52 audio_portaudio_sink::create_ringbuffer(void)
54 int bufsize_samples = d_portaudio_buffer_size_frames * d_output_parameters.channelCount;
57 fprintf(stderr,"ring buffer size = %d frames\n",
58 N_BUFFERS*bufsize_samples/d_output_parameters.channelCount);
60 // FYI, the buffer indicies are in units of samples.
61 d_writer = gr_make_buffer(N_BUFFERS * bufsize_samples, sizeof(sample_t));
62 d_reader = gr_buffer_add_reader(d_writer, 0);
66 * This routine will be called by the PortAudio engine when audio is needed.
67 * It may called at interrupt level on some machines so don't do anything
68 * that could mess up the system like calling malloc() or free().
70 * Our job is to write framesPerBuffer frames into outputBuffer.
73 portaudio_sink_callback (const void *inputBuffer,
75 unsigned long framesPerBuffer,
76 const PaStreamCallbackTimeInfo* timeInfo,
77 PaStreamCallbackFlags statusFlags,
80 audio_portaudio_sink *self = (audio_portaudio_sink *)arg;
82 framesPerBuffer * self->d_output_parameters.channelCount;
84 int navail_samples = self->d_reader->items_available();
86 if (nreqd_samples <= navail_samples) { // We've got enough data...
88 gruel::scoped_lock guard(self->d_ringbuffer_mutex);
91 self->d_reader->read_pointer(),
92 nreqd_samples * sizeof(sample_t));
93 self->d_reader->update_read_pointer(nreqd_samples);
95 self->d_ringbuffer_ready = true;
98 // Tell the sink thread there is new room in the ringbuffer.
99 self->d_ringbuffer_cond.notify_one();
105 ::write(2, "aU", 2); // FIXME change to non-blocking call
107 // FIXME we should transfer what we've got and pad the rest
108 memset(outputBuffer, 0, nreqd_samples * sizeof(sample_t));
110 self->d_ringbuffer_ready = true;
111 self->d_ringbuffer_cond.notify_one(); // Tell the sink to get going!
118 // ----------------------------------------------------------------
120 audio_portaudio_sink_sptr
121 audio_portaudio_make_sink (int sampling_rate, const std::string dev, bool ok_to_block)
123 return audio_portaudio_sink_sptr (new audio_portaudio_sink (sampling_rate,
127 audio_portaudio_sink::audio_portaudio_sink(int sampling_rate,
128 const std::string device_name,
130 : gr_sync_block ("audio_portaudio_sink",
131 gr_make_io_signature(0, 0, 0),
132 gr_make_io_signature(0, 0, 0)),
133 d_sampling_rate(sampling_rate),
134 d_device_name(device_name.empty() ? default_device_name() : device_name),
135 d_ok_to_block(ok_to_block),
136 d_verbose(gr_prefs::singleton()->get_bool("audio_portaudio", "verbose", false)),
137 d_portaudio_buffer_size_frames(0),
139 d_ringbuffer_mutex(),
141 d_ringbuffer_ready(false),
144 memset(&d_output_parameters, 0, sizeof(d_output_parameters));
146 // d_log = gri_logger::singleton();
150 PaDeviceIndex device = 0;
151 const PaDeviceInfo *deviceInfo = NULL;
153 err = Pa_Initialize();
154 if (err != paNoError) {
155 bail ("Initialize failed", err);
161 numDevices = Pa_GetDeviceCount();
163 bail("Pa Device count failed", 0);
165 bail("no devices available", 0);
167 if (d_device_name.empty())
169 // FIXME Get smarter about picking something
170 fprintf(stderr,"\nUsing Default Device\n");
171 device = Pa_GetDefaultOutputDevice();
172 deviceInfo = Pa_GetDeviceInfo(device);
173 fprintf(stderr,"%s is the chosen device using %s as the host\n",
174 deviceInfo->name, Pa_GetHostApiInfo(deviceInfo->hostApi)->name);
179 fprintf(stderr,"\nTest Devices\n");
180 for (i=0;i<numDevices;i++) {
181 deviceInfo = Pa_GetDeviceInfo( i );
182 fprintf(stderr,"Testing device name: %s",deviceInfo->name);
183 if (deviceInfo->maxOutputChannels <= 0) {
184 fprintf(stderr,"\n");
187 if (strstr(deviceInfo->name, d_device_name.c_str())){
188 fprintf(stderr," Chosen!\n");
190 fprintf(stderr,"%s using %s as the host\n",d_device_name.c_str(),
191 Pa_GetHostApiInfo(deviceInfo->hostApi)->name), fflush(stderr);
193 deviceInfo = Pa_GetDeviceInfo(device);
194 i = numDevices; // force loop exit
197 fprintf(stderr,"\n"),fflush(stderr);
201 bail("Failed to find specified device name", 0);
207 d_output_parameters.device = device;
208 d_output_parameters.channelCount = deviceInfo->maxOutputChannels;
209 d_output_parameters.sampleFormat = SAMPLE_FORMAT;
210 d_output_parameters.suggestedLatency = deviceInfo->defaultLowOutputLatency;
211 d_output_parameters.hostApiSpecificStreamInfo = NULL;
213 // We fill in the real channelCount in check_topology when we know
214 // how many inputs are connected to us.
216 // Now that we know the maximum number of channels (allegedly)
217 // supported by the h/w, we can compute a reasonable input
218 // signature. The portaudio specs say that they'll accept any
219 // number of channels from 1 to max.
220 set_input_signature(gr_make_io_signature(1, deviceInfo->maxOutputChannels,
226 audio_portaudio_sink::check_topology (int ninputs, int noutputs)
230 if (Pa_IsStreamActive(d_stream))
232 Pa_CloseStream(d_stream);
234 d_reader.reset(); // boost::shared_ptr for d_reader = 0
235 d_writer.reset(); // boost::shared_ptr for d_write = 0
238 d_output_parameters.channelCount = ninputs; // # of channels we're really using
241 d_portaudio_buffer_size_frames = (int)(0.0213333333 * d_sampling_rate + 0.5); // Force 1024 frame buffers at 48000
242 fprintf(stderr, "Latency = %8.5f, requested sampling_rate = %g\n", // Force latency to 21.3333333.. ms
243 0.0213333333, (double)d_sampling_rate);
245 err = Pa_OpenStream(&d_stream,
247 &d_output_parameters,
249 d_portaudio_buffer_size_frames,
251 &portaudio_sink_callback,
254 if (err != paNoError) {
255 output_error_msg ("OpenStream failed", err);
260 const PaStreamInfo *psi = Pa_GetStreamInfo(d_stream);
262 d_portaudio_buffer_size_frames = (int)(d_output_parameters.suggestedLatency * psi->sampleRate);
263 fprintf(stderr, "Latency = %7.4f, psi->sampleRate = %g\n",
264 d_output_parameters.suggestedLatency, psi->sampleRate);
267 fprintf(stderr, "d_portaudio_buffer_size_frames = %d\n", d_portaudio_buffer_size_frames);
269 assert(d_portaudio_buffer_size_frames != 0);
273 err = Pa_StartStream(d_stream);
274 if (err != paNoError) {
275 output_error_msg ("StartStream failed", err);
282 audio_portaudio_sink::~audio_portaudio_sink ()
284 Pa_StopStream(d_stream); // wait for output to drain
285 Pa_CloseStream(d_stream);
290 * This version consumes everything sent to it, blocking if required.
291 * I think this will allow us better control of the total buffering/latency
295 audio_portaudio_sink::work (int noutput_items,
296 gr_vector_const_void_star &input_items,
297 gr_vector_void_star &output_items)
299 const float **in = (const float **) &input_items[0];
300 const unsigned nchan = d_output_parameters.channelCount; // # of channels == samples/frame
304 for (k = 0; k < noutput_items; ){
305 int nframes = d_writer->space_available() / nchan; // How much space in ringbuffer
306 if (nframes == 0){ // no room...
309 gruel::scoped_lock guard(d_ringbuffer_mutex);
310 while (!d_ringbuffer_ready)
311 d_ringbuffer_cond.wait(guard);
317 // There's no room and we're not allowed to block.
318 // (A USRP is most likely controlling the pacing through the pipeline.)
319 // We drop the samples on the ground, and say we processed them all ;)
321 // FIXME, there's probably room for a bit more finesse here.
322 return noutput_items;
326 // We can write the smaller of the request and the room we've got
328 gruel::scoped_lock guard(d_ringbuffer_mutex);
330 int nf = std::min(noutput_items - k, nframes);
331 float *p = (float *) d_writer->write_pointer();
333 for (int i = 0; i < nf; i++)
334 for (unsigned int c = 0; c < nchan; c++)
337 d_writer->update_write_pointer(nf * nchan);
340 d_ringbuffer_ready = false;
344 return k; // tell how many we actually did
348 audio_portaudio_sink::output_error_msg (const char *msg, int err)
350 fprintf (stderr, "audio_portaudio_sink[%s]: %s: %s\n",
351 d_device_name.c_str (), msg, Pa_GetErrorText(err));
355 audio_portaudio_sink::bail (const char *msg, int err) throw (std::runtime_error)
357 output_error_msg (msg, err);
358 throw std::runtime_error ("audio_portaudio_sink");