1 files changed, 1077 insertions, 0 deletions
diff --git a/gr-audio/lib/osx/osx_source.cc b/gr-audio/lib/osx/osx_source.cc
new file mode 100644
index 0000000000..ee057c8337
--- /dev/null
+++ b/gr-audio/lib/osx/osx_source.cc
@@ -0,0 +1,1077 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2006-2011 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio.
+ *
+ * GNU Radio 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, or (at your option)
+ * any later version.
+ *
+ * GNU Radio 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 GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "audio_registry.h"
+#include <osx_source.h>
+#include <osx_impl.h>
+#include <gr_io_signature.h>
+#include <stdexcept>
+
+namespace gr {
+  namespace audio {
+
+#define _OSX_AU_DEBUG_ 0
+#define _OSX_DO_LISTENERS_ 0
+
+    AUDIO_REGISTER_SOURCE(REG_PRIO_HIGH, osx)(int sampling_rate,
+                                              const std::string &device_name,
+                                              bool ok_to_block)
+    {
+      return audio_source::sptr
+        (new audio_osx_source(sampling_rate, device_name, ok_to_block));
+    }
+
+    void
+    PrintStreamDesc(AudioStreamBasicDescription *inDesc)
+    {
+      if(inDesc == NULL) {
+        std::cerr << "PrintStreamDesc: Can't print a NULL desc!" << std::endl;
+        return;
+      }
+
+      std::cerr << "  Sample Rate        : " << inDesc->mSampleRate << std::endl;
+      char format_id[4];
+      strncpy(format_id, (char*)(&inDesc->mFormatID), 4);
+      std::cerr << "  Format ID          : " << format_id << std::endl;
+      std::cerr << "  Format Flags       : " << inDesc->mFormatFlags << std::endl;
+      std::cerr << "  Bytes per Packet   : " << inDesc->mBytesPerPacket << std::endl;
+      std::cerr << "  Frames per Packet  : " << inDesc->mFramesPerPacket << std::endl;
+      std::cerr << "  Bytes per Frame    : " << inDesc->mBytesPerFrame << std::endl;
+      std::cerr << "  Channels per Frame : " << inDesc->mChannelsPerFrame << std::endl;
+      std::cerr << "  Bits per Channel   : " << inDesc->mBitsPerChannel << std::endl;
+    }
+
+    // FIXME these should query some kind of user preference
+
+    osx_source::osx_source(int sample_rate,
+                           const std::string device_name,
+                           bool do_block,
+                           int channel_config,
+                           int max_sample_count)
+      : gr_sync_block("audio_osx_source",
+                      gr_make_io_signature(0, 0, 0),
+                      gr_make_io_signature(0, 0, 0)),
+        d_deviceSampleRate(0.0), d_outputSampleRate(0.0),
+    d_channel_config(0),
+    d_inputBufferSizeFrames(0), d_inputBufferSizeBytes(0),
+    d_outputBufferSizeFrames(0), d_outputBufferSizeBytes(0),
+    d_deviceBufferSizeFrames(0), d_deviceBufferSizeBytes(0),
+    d_leadSizeFrames(0), d_leadSizeBytes(0),
+    d_trailSizeFrames(0), d_trailSizeBytes(0),
+    d_extraBufferSizeFrames(0), d_extraBufferSizeBytes(0),
+    d_queueSampleCount(0), d_max_sample_count(0),
+    d_n_AvailableInputFrames(0), d_n_ActualInputFrames(0),
+    d_n_user_channels(0), d_n_max_channels(0), d_n_deviceChannels(0),
+    d_do_block(do_block), d_passThrough(false),
+    d_internal(0), d_cond_data(0),
+    d_buffers(0),
+    d_InputAU(0), d_InputBuffer(0), d_OutputBuffer(0),
+    d_AudioConverter(0)
+    {
+      if(sample_rate <= 0) {
+        std::cerr << "Invalid Sample Rate: " << sample_rate << std::endl;
+        throw std::invalid_argument("audio_osx_source::audio_osx_source");
+      }
+      else
+        d_outputSampleRate = (Float64)sample_rate;
+
+      if(channel_config <= 0 & channel_config != -1) {
+        std::cerr << "Invalid Channel Config: " << channel_config << std::endl;
+        throw std::invalid_argument("audio_osx_source::audio_osx_source");
+      }
+      else if (channel_config == -1) {
+        // no user input; try "device name" instead
+        int l_n_channels = (int)strtol(device_name.data(), (char **)NULL, 10);
+        if(l_n_channels == 0 & errno) {
+          std::cerr << "Error Converting Device Name: " << errno << std::endl;
+          throw std::invalid_argument("audio_osx_source::audio_osx_source");
+        }
+        if(l_n_channels <= 0)
+          channel_config = 2;
+        else
+          channel_config = l_n_channels;
+      }
+
+      d_channel_config = channel_config;
+
+      // check that the max # of samples to store is valid
+
+      if(max_sample_count == -1)
+        max_sample_count = sample_rate;
+      else if(max_sample_count <= 0) {
+        std::cerr << "Invalid Max Sample Count: " << max_sample_count << std::endl;
+        throw std::invalid_argument("audio_osx_source::audio_osx_source");
+      }
+
+      d_max_sample_count = max_sample_count;
+
+#if _OSX_AU_DEBUG_
+      std::cerr << "source(): max # samples = " << d_max_sample_count << std::endl;
+#endif
+
+      OSStatus err = noErr;
+
+      // create the default AudioUnit for input
+
+      // Open the default input unit
+#ifndef GR_USE_OLD_AUDIO_UNIT
+      AudioComponentDescription InputDesc;
+#else
+      ComponentDescription InputDesc;
+#endif
+
+      InputDesc.componentType = kAudioUnitType_Output;
+      InputDesc.componentSubType = kAudioUnitSubType_HALOutput;
+      InputDesc.componentManufacturer = kAudioUnitManufacturer_Apple;
+      InputDesc.componentFlags = 0;
+      InputDesc.componentFlagsMask = 0;
+
+#ifndef GR_USE_OLD_AUDIO_UNIT
+      AudioComponent comp = AudioComponentFindNext(NULL, &InputDesc);
+#else
+      Component comp = FindNextComponent(NULL, &InputDesc);
+#endif
+
+      if(comp == NULL) {
+#ifndef GR_USE_OLD_AUDIO_UNIT
+        std::cerr << "AudioComponentFindNext Error" << std::endl;
+#else
+        std::cerr << "FindNextComponent Error" << std::endl;
+#endif
+        throw std::runtime_error("audio_osx_source::audio_osx_source");
+  }
+
+#ifndef GR_USE_OLD_AUDIO_UNIT
+      err = AudioComponentInstanceNew(comp, &d_InputAU);
+      CheckErrorAndThrow(err, "AudioComponentInstanceNew",
+                         "audio_osx_source::audio_osx_source");
+#else
+      err = OpenAComponent(comp, &d_InputAU);
+      CheckErrorAndThrow(err, "OpenAComponent",
+                         "audio_osx_source::audio_osx_source");
+#endif
+
+      UInt32 enableIO;
+
+      // must enable the AUHAL for input and disable output
+      // before setting the AUHAL's current device
+
+      // Enable input on the AUHAL
+      enableIO = 1;
+      err = AudioUnitSetProperty(d_InputAU,
+                                 kAudioOutputUnitProperty_EnableIO,
+                                 kAudioUnitScope_Input,
+                                 1, // input element
+                                 &enableIO,
+                                 sizeof(UInt32));
+      CheckErrorAndThrow(err, "AudioUnitSetProperty Input Enable",
+                         "audio_osx_source::audio_osx_source");
+
+      // Disable output on the AUHAL
+      enableIO = 0;
+      err = AudioUnitSetProperty(d_InputAU,
+                                 kAudioOutputUnitProperty_EnableIO,
+                                 kAudioUnitScope_Output,
+                                 0, // output element
+                                 &enableIO,
+                                 sizeof (UInt32));
+      CheckErrorAndThrow(err, "AudioUnitSetProperty Output Disable",
+                         "audio_osx_source::audio_osx_source");
+  
+      // set the default input device for our input AU
+
+      SetDefaultInputDeviceAsCurrent();
+
+#if _OSX_DO_LISTENERS_
+      // set up a listener if default hardware input device changes
+
+      err = AudioHardwareAddPropertyListener
+        (kAudioHardwarePropertyDefaultInputDevice,
+         (AudioHardwarePropertyListenerProc)HardwareListener,
+         this);
+
+      CheckErrorAndThrow(err, "AudioHardwareAddPropertyListener",
+                         "audio_osx_source::audio_osx_source");
+
+      // Add a listener for any changes in the input AU's output stream
+      // the function "UnitListener" will be called if the stream format
+      // changes for whatever reason
+
+      err = AudioUnitAddPropertyListener
+        (d_InputAU,
+         kAudioUnitProperty_StreamFormat,
+         (AudioUnitPropertyListenerProc)UnitListener,
+         this);
+      CheckErrorAndThrow(err, "Adding Unit Property Listener",
+                         "audio_osx_source::audio_osx_source");
+#endif
+
+      // Now find out if it actually can do input.
+
+      UInt32 hasInput = 0;
+      UInt32 dataSize = sizeof(hasInput);
+      err = AudioUnitGetProperty(d_InputAU,
+                                 kAudioOutputUnitProperty_HasIO,
+                                 kAudioUnitScope_Input,
+                                 1,
+                                 &hasInput,
+                                 &dataSize);
+      CheckErrorAndThrow(err, "AudioUnitGetProperty HasIO",
+                         "audio_osx_source::audio_osx_source");
+      if(hasInput == 0) {
+        std::cerr << "Selected Audio Device does not support Input." << std::endl;
+        throw std::runtime_error("audio_osx_source::audio_osx_source");
+      }
+
+      // Set up a callback function to retrieve input from the Audio Device
+
+      AURenderCallbackStruct AUCallBack;
+
+      AUCallBack.inputProc = (AURenderCallback)(audio_osx_source::AUInputCallback);
+      AUCallBack.inputProcRefCon = this;
+
+      err = AudioUnitSetProperty(d_InputAU,
+                                 kAudioOutputUnitProperty_SetInputCallback,
+                                 kAudioUnitScope_Global,
+                                 0,
+                                 &AUCallBack,
+                                 sizeof (AURenderCallbackStruct));
+      CheckErrorAndThrow(err, "AudioUnitSetProperty Input Callback",
+                         "audio_osx_source::audio_osx_source");
+
+      UInt32 propertySize;
+      AudioStreamBasicDescription asbd_device, asbd_client, asbd_user;
+
+      // asbd_device: ASBD of the device that is creating the input data stream
+      // asbd_client: ASBD of the client size (output) of the hardware device
+      // asbd_user:   ASBD of the user's arguments
+
+      // Get the Stream Format (device side)
+
+      propertySize = sizeof(asbd_device);
+      err = AudioUnitGetProperty(d_InputAU,
+                                 kAudioUnitProperty_StreamFormat,
+                                 kAudioUnitScope_Input,
+                                 1,
+                                 &asbd_device,
+                                 &propertySize);
+      CheckErrorAndThrow(err, "AudioUnitGetProperty Device Input Stream Format",
+                         "audio_osx_source::audio_osx_source");
+
+#if _OSX_AU_DEBUG_
+      std::cerr << std::endl << "---- Device Stream Format ----" << std::endl;
+      PrintStreamDesc(&asbd_device);
+#endif
+
+      // Get the Stream Format (client side)
+      propertySize = sizeof(asbd_client);
+      err = AudioUnitGetProperty(d_InputAU,
+                                 kAudioUnitProperty_StreamFormat,
+                                 kAudioUnitScope_Output,
+                                 1,
+                                 &asbd_client,
+                                 &propertySize);
+      CheckErrorAndThrow(err, "AudioUnitGetProperty Device Ouput Stream Format",
+                         "audio_osx_source::audio_osx_source");
+
+#if _OSX_AU_DEBUG_
+      std::cerr << std::endl << "---- Client Stream Format ----" << std::endl;
+      PrintStreamDesc(&asbd_client);
+#endif
+
+      // Set the format of all the AUs to the input/output devices channel count
+
+      // get the max number of input (& thus output) channels supported by
+      // this device
+      d_n_max_channels = asbd_device.mChannelsPerFrame;
+
+      // create the output io signature;
+      // no input siganture to set (source is hardware)
+      set_output_signature(gr_make_io_signature(1,
+                                                d_n_max_channels,
+                                                sizeof(float)));
+
+      // allocate the output circular buffer(s), one per channel
+      d_buffers = (circular_buffer<float>**)new
+        circular_buffer<float>* [d_n_max_channels];
+      UInt32 n_alloc = (UInt32)ceil((double)d_max_sample_count);
+      for(UInt32 n = 0; n < d_n_max_channels; n++) {
+        d_buffers[n] = new circular_buffer<float>(n_alloc, false, false);
+      }
+
+      d_deviceSampleRate = asbd_device.mSampleRate;
+      d_n_deviceChannels = asbd_device.mChannelsPerFrame;
+
+      asbd_client.mSampleRate = asbd_device.mSampleRate;
+      asbd_client.mFormatID = kAudioFormatLinearPCM;
+      asbd_client.mFormatFlags = (kAudioFormatFlagIsFloat |
+                                  kAudioFormatFlagIsPacked |
+                                  kAudioFormatFlagIsNonInterleaved);
+      if((asbd_client.mFormatID == kAudioFormatLinearPCM) &&
+         (d_n_deviceChannels == 1)) {
+        asbd_client.mFormatFlags &= ~kLinearPCMFormatFlagIsNonInterleaved;
+      }
+      asbd_client.mBytesPerFrame = sizeof(float);
+      asbd_client.mFramesPerPacket = 1;
+      asbd_client.mBitsPerChannel = asbd_client.mBytesPerFrame * 8;
+      asbd_client.mChannelsPerFrame = d_n_deviceChannels;
+      asbd_client.mBytesPerPacket = asbd_client.mBytesPerFrame;
+
+      propertySize = sizeof(AudioStreamBasicDescription);
+      err = AudioUnitSetProperty(d_InputAU,
+                                 kAudioUnitProperty_StreamFormat,
+                                 kAudioUnitScope_Output,
+                                 1,
+                                 &asbd_client,
+                                 propertySize);
+      CheckErrorAndThrow(err, "AudioUnitSetProperty Device Ouput Stream Format",
+                         "audio_osx_source::audio_osx_source");
+
+      // create an ASBD for the user's wants
+
+      asbd_user.mSampleRate = d_outputSampleRate;
+      asbd_user.mFormatID = kAudioFormatLinearPCM;
+      asbd_user.mFormatFlags = (kLinearPCMFormatFlagIsFloat |
+                                GR_PCM_ENDIANNESS |
+                                kLinearPCMFormatFlagIsPacked |
+                                kAudioFormatFlagIsNonInterleaved);
+      asbd_user.mBytesPerPacket = sizeof(float);
+      asbd_user.mFramesPerPacket = 1;
+      asbd_user.mBytesPerFrame = asbd_user.mBytesPerPacket;
+      asbd_user.mChannelsPerFrame = d_n_deviceChannels;
+      asbd_user.mBitsPerChannel = asbd_user.mBytesPerPacket * 8;
+
+      if(d_deviceSampleRate == d_outputSampleRate) {
+        // no need to do conversion if asbd_client matches user wants
+        d_passThrough = true;
+        d_leadSizeFrames = d_trailSizeFrames = 0L;
+      }
+      else {
+        d_passThrough = false;
+        // Create the audio converter
+
+        err = AudioConverterNew(&asbd_client, &asbd_user, &d_AudioConverter);
+        CheckErrorAndThrow(err, "AudioConverterNew",
+                           "audio_osx_source::audio_osx_source");
+
+        // Set the audio converter sample rate quality to "max" ...
+        // requires more samples, but should sound nicer
+
+        UInt32 ACQuality = kAudioConverterQuality_Max;
+        propertySize = sizeof(ACQuality);
+        err = AudioConverterSetProperty(d_AudioConverter,
+                                        kAudioConverterSampleRateConverterQuality,
+                                        propertySize,
+                                        &ACQuality);
+        CheckErrorAndThrow(err, "AudioConverterSetProperty "
+                           "SampleRateConverterQuality",
+                           "audio_osx_source::audio_osx_source");
+
+        // set the audio converter's prime method to "pre",
+        // which uses both leading and trailing frames
+        // from the "current input".  All of this is handled
+        // internally by the AudioConverter; we just supply
+        // the frames for conversion.
+
+        //   UInt32 ACPrimeMethod = kConverterPrimeMethod_None;
+        UInt32 ACPrimeMethod = kConverterPrimeMethod_Pre;
+        propertySize = sizeof (ACPrimeMethod);
+        err = AudioConverterSetProperty(d_AudioConverter,
+                                        kAudioConverterPrimeMethod,
+                                        propertySize,
+                                        &ACPrimeMethod);
+        CheckErrorAndThrow(err, "AudioConverterSetProperty PrimeMethod",
+                           "audio_osx_source::audio_osx_source");
+
+        // Get the size of the I/O buffer(s) to allow for pre-allocated buffers
+
+        // lead frame info (trail frame info is ignored)
+
+        AudioConverterPrimeInfo ACPrimeInfo = {0, 0};
+        propertySize = sizeof(ACPrimeInfo);
+        err = AudioConverterGetProperty(d_AudioConverter,
+                                        kAudioConverterPrimeInfo,
+                                        &propertySize,
+                                        &ACPrimeInfo);
+        CheckErrorAndThrow(err, "AudioConverterGetProperty PrimeInfo",
+                           "audio_osx_source::audio_osx_source");
+
+        switch(ACPrimeMethod) {
+        case(kConverterPrimeMethod_None):
+          d_leadSizeFrames =
+            d_trailSizeFrames = 0L;
+          break;
+        case(kConverterPrimeMethod_Normal):
+          d_leadSizeFrames = 0L;
+          d_trailSizeFrames = ACPrimeInfo.trailingFrames;
+          break;
+        default:
+          d_leadSizeFrames = ACPrimeInfo.leadingFrames;
+          d_trailSizeFrames = ACPrimeInfo.trailingFrames;
+        }
+      }
+      d_leadSizeBytes = d_leadSizeFrames * sizeof(Float32);
+      d_trailSizeBytes = d_trailSizeFrames * sizeof(Float32);
+
+      propertySize = sizeof(d_deviceBufferSizeFrames);
+      err = AudioUnitGetProperty(d_InputAU,
+                                 kAudioDevicePropertyBufferFrameSize,
+                                 kAudioUnitScope_Global,
+                                 0,
+                                 &d_deviceBufferSizeFrames,
+                                 &propertySize);
+      CheckErrorAndThrow(err, "AudioUnitGetProperty Buffer Frame Size",
+                         "audio_osx_source::audio_osx_source");
+
+      d_deviceBufferSizeBytes = d_deviceBufferSizeFrames * sizeof(Float32);
+      d_inputBufferSizeBytes = d_deviceBufferSizeBytes + d_leadSizeBytes;
+      d_inputBufferSizeFrames = d_deviceBufferSizeFrames + d_leadSizeFrames;
+
+      // outBufSizeBytes = floor (inBufSizeBytes * rate_out / rate_in)
+      // since this is rarely exact, we need another buffer to hold
+      // "extra" samples not processed at any given sampling period
+      // this buffer must be at least 4 floats in size, but generally
+      // follows the rule that
+      // extraBufSize =  ceil (rate_in / rate_out)*sizeof(float)
+
+      d_extraBufferSizeFrames = ((UInt32)ceil(d_deviceSampleRate
+                                              / d_outputSampleRate)
+                                 * sizeof(float));
+      if(d_extraBufferSizeFrames < 4)
+        d_extraBufferSizeFrames = 4;
+      d_extraBufferSizeBytes = d_extraBufferSizeFrames * sizeof(float);
+
+      d_outputBufferSizeFrames = (UInt32)ceil(((Float64)d_inputBufferSizeFrames)
+                                              * d_outputSampleRate
+                                              / d_deviceSampleRate);
+      d_outputBufferSizeBytes = d_outputBufferSizeFrames * sizeof(float);
+      d_inputBufferSizeFrames += d_extraBufferSizeFrames;
+
+      // pre-alloc all buffers
+
+      AllocAudioBufferList(&d_InputBuffer, d_n_deviceChannels,
+                           d_inputBufferSizeBytes);
+      if(d_passThrough == false) {
+        AllocAudioBufferList(&d_OutputBuffer, d_n_max_channels,
+                             d_outputBufferSizeBytes);
+      }
+      else {
+        d_OutputBuffer = d_InputBuffer;
+      }
+
+      // create the stuff to regulate I/O
+
+      d_cond_data = new gruel::condition_variable();
+      if(d_cond_data == NULL)
+        CheckErrorAndThrow(errno, "new condition (data)",
+                           "audio_osx_source::audio_osx_source");
+
+      d_internal = new gruel::mutex();
+      if(d_internal == NULL)
+        CheckErrorAndThrow(errno, "new mutex (internal)",
+                           "audio_osx_source::audio_osx_source");
+
+      // initialize the AU for input
+
+      err = AudioUnitInitialize(d_InputAU);
+      CheckErrorAndThrow(err, "AudioUnitInitialize",
+                         "audio_osx_source::audio_osx_source");
+
+#if _OSX_AU_DEBUG_
+      std::cerr << "audio_osx_source Parameters:" << std::endl;
+      std::cerr << "  Device Sample Rate is " << d_deviceSampleRate << std::endl;
+      std::cerr << "  User Sample Rate is " << d_outputSampleRate << std::endl;
+      std::cerr << "  Max Sample Count is " << d_max_sample_count << std::endl;
+      std::cerr << "  # Device Channels is " << d_n_deviceChannels << std::endl;
+      std::cerr << "  # Max Channels is " << d_n_max_channels << std::endl;
+      std::cerr << "  Device Buffer Size is Frames = " << d_deviceBufferSizeFrames << std::endl;
+      std::cerr << "  Lead Size is Frames = " << d_leadSizeFrames << std::endl;
+      std::cerr << "  Trail Size is Frames = " << d_trailSizeFrames << std::endl;
+      std::cerr << "  Input Buffer Size is Frames = " << d_inputBufferSizeFrames << std::endl;
+      std::cerr << "  Output Buffer Size is Frames = " << d_outputBufferSizeFrames << std::endl;
+#endif
+    }
+
+    void
+    osx_source::AllocAudioBufferList(AudioBufferList** t_ABL,
+                                     UInt32 n_channels,
+                                     UInt32 bufferSizeBytes)
+    {
+      FreeAudioBufferList(t_ABL);
+      UInt32 propertySize = (offsetof(AudioBufferList, mBuffers[0]) +
+                             (sizeof(AudioBuffer) * n_channels));
+      *t_ABL = (AudioBufferList*)calloc(1, propertySize);
+      (*t_ABL)->mNumberBuffers = n_channels;
+
+      int counter = n_channels;
+
+      while(--counter >= 0) {
+        (*t_ABL)->mBuffers[counter].mNumberChannels = 1;
+        (*t_ABL)->mBuffers[counter].mDataByteSize = bufferSizeBytes;
+        (*t_ABL)->mBuffers[counter].mData = calloc (1, bufferSizeBytes);
+      }
+    }
+
+    void
+    osx_source::FreeAudioBufferList(AudioBufferList** t_ABL)
+    {
+      // free pre-allocated audio buffer, if it exists
+      if(*t_ABL != NULL) {
+        int counter = (*t_ABL)->mNumberBuffers;
+        while(--counter >= 0)
+          free((*t_ABL)->mBuffers[counter].mData);
+        free(*t_ABL);
+        (*t_ABL) = 0;
+      }
+    }
+
+    bool
+    osx_source::IsRunning()
+    {
+      UInt32 AURunning = 0, AUSize = sizeof(UInt32);
+
+      OSStatus err = AudioUnitGetProperty(d_InputAU,
+                                          kAudioOutputUnitProperty_IsRunning,
+                                          kAudioUnitScope_Global,
+                                          0,
+                                          &AURunning,
+                                          &AUSize);
+      CheckErrorAndThrow(err, "AudioUnitGetProperty IsRunning",
+                         "audio_osx_source::IsRunning");
+
+      return (AURunning);
+    }
+
+    bool
+    osx_source::start()
+    {
+      if(! IsRunning ()) {
+        OSStatus err = AudioOutputUnitStart(d_InputAU);
+        CheckErrorAndThrow(err, "AudioOutputUnitStart",
+                           "audio_osx_source::start");
+      }
+
+      return (true);
+    }
+
+    bool
+    osx_source::stop()
+    {
+      if(IsRunning ()) {
+        OSStatus err = AudioOutputUnitStop(d_InputAU);
+        CheckErrorAndThrow(err, "AudioOutputUnitStart",
+                           "audio_osx_source::stop");
+        for(UInt32 n = 0; n < d_n_user_channels; n++) {
+          d_buffers[n]->abort ();
+        }
+      }
+
+      return (true);
+    }
+
+    osx_source::~osx_source()
+    {
+      OSStatus err = noErr;
+
+      // stop the AudioUnit
+      stop();
+
+#if _OSX_DO_LISTENERS_
+      // remove the listeners
+
+      err = AudioUnitRemovePropertyListener
+        (d_InputAU,
+         kAudioUnitProperty_StreamFormat,
+         (AudioUnitPropertyListenerProc)UnitListener);
+      CheckError(err, "~audio_osx_source: AudioUnitRemovePropertyListener");
+
+      err = AudioHardwareRemovePropertyListener
+        (kAudioHardwarePropertyDefaultInputDevice,
+         (AudioHardwarePropertyListenerProc)HardwareListener);
+      CheckError(err, "~audio_osx_source: AudioHardwareRemovePropertyListener");
+#endif
+
+      // free pre-allocated audio buffers
+      FreeAudioBufferList(&d_InputBuffer);
+
+      if(d_passThrough == false) {
+        err = AudioConverterDispose(d_AudioConverter);
+        CheckError(err, "~audio_osx_source: AudioConverterDispose");
+        FreeAudioBufferList(&d_OutputBuffer);
+      }
+
+      // remove the audio unit
+      err = AudioUnitUninitialize(d_InputAU);
+      CheckError(err, "~audio_osx_source: AudioUnitUninitialize");
+
+#ifndef GR_USE_OLD_AUDIO_UNIT
+      err = AudioComponentInstanceDispose(d_InputAU);
+      CheckError(err, "~audio_osx_source: AudioComponentInstanceDispose");
+#else
+      err = CloseComponent(d_InputAU);
+      CheckError(err, "~audio_osx_source: CloseComponent");
+#endif
+
+      // empty and delete the queues
+      for(UInt32 n = 0; n < d_n_max_channels; n++) {
+        delete d_buffers[n];
+        d_buffers[n] = 0;
+      }
+      delete [] d_buffers;
+      d_buffers = 0;
+
+      // close and delete the control stuff
+      delete d_cond_data;
+      d_cond_data = 0;
+      delete d_internal;
+      d_internal = 0;
+    }
+
+    bool
+    osx_source::check_topology(int ninputs, int noutputs)
+    {
+      // check # inputs to make sure it's valid
+      if(ninputs != 0) {
+        std::cerr << "audio_osx_source::check_topology(): number of input "
+                  << "streams provided (" << ninputs
+                  << ") should be 0." << std::endl;
+        throw std::runtime_error("audio_osx_source::check_topology()");
+      }
+
+      // check # outputs to make sure it's valid
+      if((noutputs < 1) | (noutputs > (int) d_n_max_channels)) {
+        std::cerr << "audio_osx_source::check_topology(): number of output "
+                  << "streams provided (" << noutputs << ") should be in [1,"
+                  << d_n_max_channels << "] for the selected audio device."
+                  << std::endl;
+        throw std::runtime_error("audio_osx_source::check_topology()");
+      }
+
+      // save the actual number of output (user) channels
+      d_n_user_channels = noutputs;
+
+#if _OSX_AU_DEBUG_
+      std::cerr << "chk_topo: Actual # user output channels = "
+                << noutputs << std::endl;
+#endif
+
+      return (true);
+    }
+
+    int
+    osx_source::work(int noutput_items,
+                     gr_vector_const_void_star &input_items,
+                     gr_vector_void_star &output_items)
+    {
+      // acquire control to do processing here only
+      gruel::scoped_lock l(*d_internal);
+
+#if _OSX_AU_DEBUG_
+      std::cerr << "work1: SC = " << d_queueSampleCount
+                << ", #OI = " << noutput_items
+                << ", #Chan = " << output_items.size() << std::endl;
+#endif
+
+      // set the actual # of output items to the 'desired' amount then
+      // verify that data is available; if not enough data is available,
+      // either wait until it is (is "do_block" is true), return (0) is no
+      // data is available and "do_block" is false, or process the actual
+      // amount of available data.
+
+      UInt32 actual_noutput_items = noutput_items;
+
+      if(d_queueSampleCount < actual_noutput_items) {
+        if(d_queueSampleCount == 0) {
+          // no data; do_block decides what to do
+          if(d_do_block == true) {
+            while(d_queueSampleCount == 0) {
+              // release control so-as to allow data to be retrieved;
+              // block until there is data to return
+              d_cond_data->wait(l);
+              // the condition's 'notify' was called; acquire control to
+              // keep thread safe
+            }
+          }
+          else {
+            // no data & not blocking; return nothing
+            return (0);
+          }
+        }
+        // use the actual amount of available data
+        actual_noutput_items = d_queueSampleCount;
+      }
+
+      // number of channels
+      int l_counter = (int)output_items.size();
+
+      // copy the items from the circular buffer(s) to 'work's output buffers
+      // verify that the number copied out is as expected.
+
+      while(--l_counter >= 0) {
+        size_t t_n_output_items = actual_noutput_items;
+        d_buffers[l_counter]->dequeue((float*)output_items[l_counter],
+                                      &t_n_output_items);
+        if(t_n_output_items != actual_noutput_items) {
+          std::cerr << "audio_osx_source::work(): ERROR: number of "
+                    << "available items changing unexpectedly; expecting "
+                    << actual_noutput_items << ", got "
+                    << t_n_output_items << "." << std::endl;
+          throw std::runtime_error("audio_osx_source::work()");
+        }
+      }
+
+      // subtract the actual number of items removed from the buffer(s)
+      // from the local accounting of the number of available samples
+
+      d_queueSampleCount -= actual_noutput_items;
+
+#if _OSX_AU_DEBUG_
+      std::cerr << "work2: SC = " << d_queueSampleCount
+                << ", act#OI = " << actual_noutput_items << std::endl
+                << "Returning." << std::endl;
+#endif
+
+      return (actual_noutput_items);
+    }
+
+    OSStatus
+    osx_source::ConverterCallback(AudioConverterRef inAudioConverter,
+                                  UInt32* ioNumberDataPackets,
+                                  AudioBufferList* ioData,
+                                  AudioStreamPacketDescription** ioASPD,
+                                  void* inUserData)
+    {
+      // take current device buffers and copy them to the tail of the
+      // input buffers the lead buffer is already there in the first
+      // d_leadSizeFrames slots
+
+      osx_source* This = static_cast<osx_source*>(inUserData);
+      AudioBufferList* l_inputABL = This->d_InputBuffer;
+      UInt32 totalInputBufferSizeBytes = ((*ioNumberDataPackets) * sizeof(float));
+      int counter = This->d_n_deviceChannels;
+      ioData->mNumberBuffers = This->d_n_deviceChannels;
+      This->d_n_ActualInputFrames = (*ioNumberDataPackets);
+
+#if _OSX_AU_DEBUG_
+      std::cerr << "cc1: io#DP = " << (*ioNumberDataPackets)
+                << ", TIBSB = " << totalInputBufferSizeBytes
+                << ", #C = " << counter << std::endl;
+#endif
+
+      while(--counter >= 0) {
+        AudioBuffer* l_ioD_AB = &(ioData->mBuffers[counter]);
+        l_ioD_AB->mNumberChannels = 1;
+        l_ioD_AB->mData = (float*)(l_inputABL->mBuffers[counter].mData);
+        l_ioD_AB->mDataByteSize = totalInputBufferSizeBytes;
+      }
+
+#if _OSX_AU_DEBUG_
+      std::cerr << "cc2: Returning." << std::endl;
+#endif
+
+      return (noErr);
+    }
+
+    OSStatus
+    osx_source::AUInputCallback(void* inRefCon,
+                                AudioUnitRenderActionFlags* ioActionFlags,
+                                const AudioTimeStamp* inTimeStamp,
+                                UInt32 inBusNumber,
+                                UInt32 inNumberFrames,
+                                AudioBufferList* ioData)
+    {
+      OSStatus err = noErr;
+      audio_osx_source* This = static_cast<audio_osx_source*>(inRefCon);
+
+      gruel::scoped_lock l(*This->d_internal);
+
+#if _OSX_AU_DEBUG_
+      std::cerr << "cb0: in#F = " << inNumberFrames
+                << ", inBN = " << inBusNumber
+                << ", SC = " << This->d_queueSampleCount << std::endl;
+#endif
+
+      // Get the new audio data from the input device
+
+      err = AudioUnitRender(This->d_InputAU,
+                            ioActionFlags,
+                            inTimeStamp,
+                            1, //inBusNumber,
+                            inNumberFrames,
+                            This->d_InputBuffer);
+      CheckErrorAndThrow(err, "AudioUnitRender",
+                         "audio_osx_source::AUInputCallback");
+
+      UInt32 AvailableInputFrames = inNumberFrames;
+      This->d_n_AvailableInputFrames = inNumberFrames;
+
+      // get the number of actual output frames,
+      // either via converting the buffer or not
+
+      UInt32 ActualOutputFrames;
+
+      if(This->d_passThrough == true) {
+        ActualOutputFrames = AvailableInputFrames;
+      }
+      else {
+        UInt32 AvailableInputBytes = AvailableInputFrames * sizeof(float);
+        UInt32 AvailableOutputBytes = AvailableInputBytes;
+        UInt32 AvailableOutputFrames = AvailableOutputBytes / sizeof(float);
+        UInt32 propertySize = sizeof (AvailableOutputBytes);
+        err = AudioConverterGetProperty(This->d_AudioConverter,
+                                        kAudioConverterPropertyCalculateOutputBufferSize,
+                                        &propertySize,
+                                        &AvailableOutputBytes);
+        CheckErrorAndThrow(err, "AudioConverterGetProperty CalculateOutputBufferSize",
+                           "audio_osx_source::audio_osx_source");
+
+        AvailableOutputFrames = AvailableOutputBytes / sizeof(float);
+
+#if 0
+        // when decimating too much, the output sounds warbly due to
+        // fluctuating # of output frames
+        // This should not be a surprise, but there's probably some
+        // clever programming that could lessed the effect ...
+        // like finding the "ideal" # of output frames, and keeping
+        // that number constant no matter the # of input frames
+        UInt32 l_InputBytes = AvailableOutputBytes;
+        propertySize = sizeof(AvailableOutputBytes);
+        err = AudioConverterGetProperty(This->d_AudioConverter,
+                                        kAudioConverterPropertyCalculateInputBufferSize,
+                                        &propertySize,
+                                        &l_InputBytes);
+        CheckErrorAndThrow(err, "AudioConverterGetProperty CalculateInputBufferSize",
+                           "audio_osx_source::audio_osx_source");
+
+        if(l_InputBytes < AvailableInputBytes) {
+          // OK to zero pad the input a little
+          AvailableOutputFrames += 1;
+          AvailableOutputBytes = AvailableOutputFrames * sizeof(float);
+        }
+#endif
+
+#if _OSX_AU_DEBUG_
+        std::cerr << "cb1:  avail: #IF = " << AvailableInputFrames
+                  << ", #OF = " << AvailableOutputFrames << std::endl;
+#endif
+        ActualOutputFrames = AvailableOutputFrames;
+
+        // convert the data to the correct rate
+        // on input, ActualOutputFrames is the number of available output frames
+
+        err = AudioConverterFillComplexBuffer(This->d_AudioConverter,
+                                              (AudioConverterComplexInputDataProc)
+                                              (This->ConverterCallback),
+                                              inRefCon,
+                                              &ActualOutputFrames,
+                                              This->d_OutputBuffer,
+                                              NULL);
+        CheckErrorAndThrow(err, "AudioConverterFillComplexBuffer",
+                           "audio_osx_source::AUInputCallback");
+
+        // on output, ActualOutputFrames is the actual number of output frames
+
+#if _OSX_AU_DEBUG_
+        std::cerr << "cb2: actual: #IF = " << This->d_n_ActualInputFrames
+                  << ", #OF = " << AvailableOutputFrames << std::endl;
+        if(This->d_n_ActualInputFrames != AvailableInputFrames)
+          std::cerr << "cb2.1: avail#IF = " << AvailableInputFrames
+                    << ", actual#IF = " << This->d_n_ActualInputFrames << std::endl;
+#endif
+      }
+
+      // add the output frames to the buffers' queue, checking for overflow
+
+      int l_counter = This->d_n_user_channels;
+      int res = 0;
+
+      while(--l_counter >= 0) {
+        float* inBuffer = (float*) This->d_OutputBuffer->mBuffers[l_counter].mData;
+
+#if _OSX_AU_DEBUG_
+        std::cerr << "cb3: enqueuing audio data." << std::endl;
+#endif
+
+        int l_res = This->d_buffers[l_counter]->enqueue(inBuffer, ActualOutputFrames);
+        if(l_res == -1)
+          res = -1;
+      }
+
+      if(res == -1) {
+        // data coming in too fast
+        // drop oldest buffer
+        fputs("aO", stderr);
+        fflush(stderr);
+        // set the local number of samples available to the max
+        This->d_queueSampleCount = This->d_buffers[0]->buffer_length_items();
+      }
+      else {
+        // keep up the local sample count
+        This->d_queueSampleCount += ActualOutputFrames;
+      }
+
+#if _OSX_AU_DEBUG_
+      std::cerr << "cb4: #OI = " << ActualOutputFrames
+                << ", #Cnt = " << This->d_queueSampleCount
+                << ", mSC = " << This->d_max_sample_count << std::endl;
+#endif
+
+      // signal that data is available, if appropraite
+      This->d_cond_data->notify_one();
+
+#if _OSX_AU_DEBUG_
+      std::cerr << "cb5: returning." << std::endl;
+#endif
+
+      return (err);
+    }
+
+    void
+    osx_source::SetDefaultInputDeviceAsCurrent()
+    {
+      // set the default input device
+      AudioDeviceID deviceID = 0;
+      UInt32 dataSize = sizeof (AudioDeviceID);
+      OSStatus err = noErr;
+
+#ifndef GR_USE_OLD_AUDIO_UNIT
+      AudioObjectPropertyAddress theAddress =
+        { kAudioHardwarePropertyDefaultInputDevice,
+          kAudioObjectPropertyScopeGlobal,
+          kAudioObjectPropertyElementMaster };
+
+      err = AudioObjectGetPropertyData(kAudioObjectSystemObject,
+                                       &theAddress,
+                                       0,
+                                       NULL,
+                                       &dataSize,
+                                       &deviceID);
+#else
+      err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice,
+                                     &dataSize,
+                                     &deviceID);
+#endif
+
+      CheckErrorAndThrow(err, "Get Audio Unit Property for Current Device",
+                         "audio_osx_source::SetDefaultInputDeviceAsCurrent");
+
+      err = AudioUnitSetProperty(d_InputAU,
+                                 kAudioOutputUnitProperty_CurrentDevice,
+                                 kAudioUnitScope_Global,
+                                 0,
+                                 &deviceID,
+                                 sizeof(AudioDeviceID));
+
+      CheckErrorAndThrow(err, "AudioUnitSetProperty Current Device",
+                         "audio_osx_source::SetDefaultInputDeviceAsCurrent");
+}
+
+#if _OSX_DO_LISTENERS_
+    OSStatus
+    osx_source::HardwareListener(AudioHardwarePropertyID inPropertyID,
+                                 void *inClientData)
+    {
+      OSStatus err = noErr;
+      osx_source* This = static_cast<osx_source*>(inClientData);
+
+      std::cerr << "a_o_s::HardwareListener" << std::endl;
+
+      // set the new default hardware input device for use by our AU
+
+      This->SetDefaultInputDeviceAsCurrent();
+
+      // reset the converter to tell it that the stream has changed
+
+      err = AudioConverterReset(This->d_AudioConverter);
+      CheckErrorAndThrow(err, "AudioConverterReset",
+                         "audio_osx_source::UnitListener");
+
+      return (err);
+    }
+
+    OSStatus
+    osx_source::UnitListener(void *inRefCon,
+                             AudioUnit ci,
+                             AudioUnitPropertyID inID,
+                             AudioUnitScope inScope,
+                             AudioUnitElement inElement)
+    {
+      OSStatus err = noErr;
+      osx_source* This = static_cast<osx_source*>(inRefCon);
+      AudioStreamBasicDescription asbd;
+
+      std::cerr << "a_o_s::UnitListener" << std::endl;
+
+      // get the converter's input ASBD (for printing)
+
+      UInt32 propertySize = sizeof(asbd);
+      err = AudioConverterGetProperty(This->d_AudioConverter,
+                                      kAudioConverterCurrentInputStreamDescription,
+                                      &propertySize,
+                                      &asbd);
+      CheckErrorAndThrow(err, "AudioConverterGetProperty "
+                         "CurrentInputStreamDescription",
+                         "audio_osx_source::UnitListener");
+
+      std::cerr << "UnitListener: Input Source changed." << std::endl
+                << "Old Source Output Info:" << std::endl;
+      PrintStreamDesc(&asbd);
+
+      // get the new input unit's output ASBD
+
+      propertySize = sizeof(asbd);
+      err = AudioUnitGetProperty(This->d_InputAU,
+                                 kAudioUnitProperty_StreamFormat,
+                                 kAudioUnitScope_Output, 1,
+                                 &asbd, &propertySize);
+      CheckErrorAndThrow(err, "AudioUnitGetProperty StreamFormat",
+                         "audio_osx_source::UnitListener");
+
+      std::cerr << "New Source Output Info:" << std::endl;
+      PrintStreamDesc(&asbd);
+
+      // set the converter's input ASBD to this
+
+      err = AudioConverterSetProperty(This->d_AudioConverter,
+                                      kAudioConverterCurrentInputStreamDescription,
+                                      propertySize,
+                                      &asbd);
+      CheckErrorAndThrow(err, "AudioConverterSetProperty "
+                         "CurrentInputStreamDescription",
+                         "audio_osx_source::UnitListener");
+
+      // reset the converter to tell it that the stream has changed
+
+      err = AudioConverterReset(This->d_AudioConverter);
+      CheckErrorAndThrow(err, "AudioConverterReset",
+                         "audio_osx_source::UnitListener");
+
+      return (err);
+    }
+#endif /* _OSX_DO_LISTENERS_ */
+
+  } /* namespace audio */
+} /* namespace gr */