diff --git a/.cproject b/.cproject
index b326155f..2e8a70c9 100644
--- a/.cproject
+++ b/.cproject
@@ -1,7 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<?fileVersion 4.0.0?>
-
-<cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage">
+<?fileVersion 4.0.0?><cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage">
 	<storageModule moduleId="org.eclipse.cdt.core.settings">
 		<cconfiguration id="com.qnx.qcc.toolChain.1426688628">
 			<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="com.qnx.qcc.toolChain.1426688628" moduleId="org.eclipse.cdt.core.settings" name="Default">
@@ -46,6 +44,7 @@
 									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/jack2/qnx}&quot;"/>
 									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/jack2/qnx/ioaudio}&quot;"/>
 									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/QNX Headers/usr_include}&quot;"/>
+									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/QNX Headers/usr_include/c++/4.7.3}&quot;"/>
 								</option>
 								<option id="gnu.cpp.compiler.option.preprocessor.def.1801463510" name="Defined symbols (-D)" superClass="gnu.cpp.compiler.option.preprocessor.def" valueType="definedSymbols">
 									<listOptionValue builtIn="false" value="__INT_BITS__=32"/>
diff --git a/qnx/JackTime.h b/qnx/JackTime.h
new file mode 100644
index 00000000..616d84f1
--- /dev/null
+++ b/qnx/JackTime.h
@@ -0,0 +1,24 @@
+/*
+ * JackTime.h
+ *
+ *  Created on: Jan 8, 2016
+ *      Author: coopera
+ */
+
+#ifndef JACKTIME_H_
+#define JACKTIME_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+jack_time_t jack_get_microseconds(
+    void );
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* JACKTIME_H_ */
diff --git a/qnx/driver.h b/qnx/driver.h
index 6e1466f4..f4bdb878 100644
--- a/qnx/driver.h
+++ b/qnx/driver.h
@@ -26,6 +26,11 @@
 #include "jslist.h"
 #include "driver_interface.h"
 
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
 typedef float gain_t;
 typedef long channel_t;
 
@@ -297,4 +302,8 @@ jack_driver_nt_t;
 void jack_driver_nt_init (jack_driver_nt_t * driver);
 void jack_driver_nt_finish (jack_driver_nt_t * driver);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* __jack_driver_h__ */
diff --git a/qnx/ioaudio/JackIoAudioDriver.cpp b/qnx/ioaudio/JackIoAudioDriver.cpp
index a4e313c3..d9794195 100644
--- a/qnx/ioaudio/JackIoAudioDriver.cpp
+++ b/qnx/ioaudio/JackIoAudioDriver.cpp
@@ -19,7 +19,9 @@
  */
 
 #define __STDC_FORMAT_MACROS   // For inttypes.h to work in C++
-#include <iostream>
+#define _GNU_SOURCE            /* for strcasestr() from string.h */
+
+#include <inttypes.h>
 #include <math.h>
 #include <stdio.h>
 #include <memory.h>
@@ -28,9 +30,32 @@
 #include <errno.h>
 #include <stdarg.h>
 #include <signal.h>
+#include <sys/mman.h>
+#include <sys/poll.h>
 #include <sys/types.h>
 #include <sys/time.h>
 #include <string.h>
+#include <limits>
+
+#include <sys/asoundlib.h>
+#include <sys/poll.h>
+#include "bitset.h"
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+#define IS_LE 0
+#define IS_BE 1
+#elif __BYTE_ORDER == __BIG_ENDIAN
+#define IS_LE 1
+#define IS_BE 0
+#endif
+
+#include "types.h"
+#include "hardware.h"
+//#include "driver.h"
+#include "memops.h"
+//#include "ioaudio_midi.h"
+
+#include <iostream>
 
 #include "JackIoAudioDriver.h"
 #include "JackEngineControl.h"
@@ -38,582 +63,787 @@
 #include "JackPort.h"
 #include "JackGraphManager.h"
 #include "JackLockedEngine.h"
-#ifdef __ANDROID__
-#include "JackAndroidThread.h"
-#else
 #include "JackPosixThread.h"
-#endif
 #include "JackCompilerDeps.h"
 #include "JackServerGlobals.h"
+#include "JackTime.h"
+
+#include "JackError.h"
 
 static struct jack_constraint_enum_str_descriptor midi_constraint_descr_array[] =
-    {
-      {
-        "none",
-        "no MIDI driver"
-      },
-      {
-        "seq",
-        "io-audio Sequencer driver"
-      },
-      {
-        "raw",
-        "io-audio RawMIDI driver"
-      },
-      {
-        0
-      }
-    };
+    { { "none", "no MIDI driver" }, { "seq", "io-audio Sequencer driver" }, {
+        "raw", "io-audio RawMIDI driver" },
+      { 0 } };
 
 static struct jack_constraint_enum_char_descriptor dither_constraint_descr_array[] =
-    {
-      {
-        'n',
-        "none"
-      },
-      {
-        'r',
-        "rectangular"
-      },
-      {
-        's',
-        "shaped"
-      },
-      {
-        't',
-        "triangular"
-      },
-      {
-        0
-      }
-    };
+    { { 'n', "none" }, { 'r', "rectangular" }, { 's', "shaped" },
+      { 't', "triangular" }, { 0 } };
 
 namespace Jack
 {
 
-    int JackIoAudioDriver::SetBufferSize(
-        jack_nframes_t buffer_size )
+///////////////////////////////////////////////////////////////////////////////
+// CONSTANTS
+///////////////////////////////////////////////////////////////////////////////
+
+#undef DEBUG_WAKEUP
+
+    /* Delay (in process calls) before jackd will report an xrun */
+#define XRUN_REPORT_DELAY 0
+
+//    const char driver_client_name[] = "ioaudio_pcm";
+
+    enum IoAudioDriverChannels
     {
-        jack_log( "JackIoAudioDriver::SetBufferSize %ld",
-                  buffer_size );
-        int res =
-            ioaudio_driver_reset_parameters( (ioaudio_driver_t *)fDriver,
-                                             buffer_size,
-                                             ( (ioaudio_driver_t *)fDriver )->user_nperiods,
-                                             ( (ioaudio_driver_t *)fDriver )->frame_rate );
-
-        if( res == 0 )
-            { // update fEngineControl and fGraphManager
-            JackAudioDriver::SetBufferSize( buffer_size ); // Generic change, never fails
-            // io-audio specific
-            UpdateLatencies();
-            }
-        else
-            {
-            // Restore old values
-            ioaudio_driver_reset_parameters( (ioaudio_driver_t *)fDriver,
-                                             fEngineControl->fBufferSize,
-                                             ( (ioaudio_driver_t *)fDriver )->user_nperiods,
-                                             ( (ioaudio_driver_t *)fDriver )->frame_rate );
-            }
+        Playback = SND_PCM_CHANNEL_PLAYBACK,
+        Capture = SND_PCM_CHANNEL_CAPTURE,
+        Extra = SND_PCM_CHANNEL_MAX,
+        IoAudioDriverChannels_COUNT
+    };
 
-        return res;
-    }
+//static Jack::JackIoAudioDriver* g_ioaudio_driver;
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+///////////////////////////////////////////////////////////////////////////////
+    typedef void (*ReadCopyFunction)(
+        jack_default_audio_sample_t *dst,
+        char *src,
+        unsigned long src_bytes,
+        unsigned long src_skip_bytes );
+    typedef void (*WriteCopyFunction)(
+        char *dst,
+        jack_default_audio_sample_t *src,
+        unsigned long src_bytes,
+        unsigned long dst_skip_bytes,
+        dither_state_t *state );
+
+    struct Voice
+    {
+        unsigned long interleave_skip;
+        char* addr;
+        unsigned long silent;
+        dither_state_t dither_state;
+    };
 
-    void JackIoAudioDriver::UpdateLatencies()
+    struct Channel
     {
-        jack_latency_range_t range;
-        ioaudio_driver_t* ioaudio_driver = (ioaudio_driver_t*)fDriver;
+        Voice* voices;
+        unsigned int nperiods;
+        snd_pcm_t *handle;
+        snd_pcm_channel_params_t params;
+        snd_pcm_channel_setup_t setup;
+        snd_pcm_mmap_control_t *mmap;
+        void *mmap_buf;
+        void *buffer;
+
+        ReadCopyFunction read;
+        WriteCopyFunction write;
+
+        ssize_t sample_bytes()
+        {
+        return snd_pcm_format_size( setup.format.format,
+                                    1 );
+        }
+        ssize_t frame_bytes()
+        {
+        return snd_pcm_format_size( setup.format.format,
+                                    setup.format.voices );
+        }
+
+        ssize_t frag_bytes()
+        {
+        return setup.buf.block.frag_size;
+        }
+
+        ssize_t frag_frames()
+        {
+        return frag_bytes() / frame_bytes();
+        }
 
-        for( int i = 0; i < fCaptureChannels; i++ )
-            {
-            range.min = range.max = ioaudio_driver->frames_per_cycle
-                + ioaudio_driver->capture_frame_latency;
-            fGraphManager->GetPort( fCapturePortList[i] )->SetLatencyRange(
-                                                                            JackCaptureLatency,
-                                                                            &range );
-            }
+    };
 
-        for( int i = 0; i < fPlaybackChannels; i++ )
-            {
-            // Add one buffer more latency if "async" mode is used...
-            range.min = range.max =
-                ( ioaudio_driver->frames_per_cycle
-                    * ( ioaudio_driver->user_nperiods - 1 ) )
-                    + ( ( fEngineControl->fSyncMode ) ?
-                        0 : fEngineControl->fBufferSize )
-                    + ioaudio_driver->playback_frame_latency;
-            fGraphManager->GetPort( fPlaybackPortList[i] )->SetLatencyRange(
-                                                                             JackPlaybackLatency,
-                                                                             &range );
-            // Monitor port
-            if( fWithMonitorPorts )
-                {
-                range.min = range.max = ioaudio_driver->frames_per_cycle;
-                fGraphManager->GetPort( fMonitorPortList[i] )->SetLatencyRange(
-                                                                                JackCaptureLatency,
-                                                                                &range );
-                }
-            }
-    }
+    struct ioaudio_driver_t
+    {
 
-    int JackIoAudioDriver::Attach()
+        //JACK_DRIVER_NT_DECL
+
+        int poll_timeout_msecs;
+        jack_time_t poll_last;
+        jack_time_t poll_next;
+        int poll_late;
+
+        struct pollfd pfd[IoAudioDriverChannels_COUNT];
+        unsigned long interleave_unit;
+        unsigned int max_nchannels;
+        unsigned int user_nchannels;
+//        int user_capture_nchnls;
+//        int user_playback_nchnls;
+
+        jack_nframes_t frame_rate;
+//        jack_nframes_t frames_per_cycle;
+//        jack_nframes_t capture_frame_latency;
+//        jack_nframes_t playback_frame_latency;
+
+//        unsigned long *silent;
+//        char *ioaudio_driver;
+        bitset_t channels_not_done;
+        bitset_t channels_done;
+//        float max_sample_val;
+//        unsigned long user_nperiods;
+//        unsigned long last_mask;
+//        snd_ctl_t *ctl_handle;
+
+        Channel playback;
+
+        Channel capture;
+
+//        Voice* playback_voices;
+////        char *ioaudio_name_playback;
+////        unsigned long *playback_interleave_skip;
+//        unsigned int playback_nperiods;
+//        snd_pcm_t *playback_handle;
+//        snd_pcm_channel_params_t playback_params;
+//        snd_pcm_channel_setup_t playback_setup;
+//        snd_pcm_mmap_control_t *playback_mmap;
+//        void *playback_mmap_buf;
+//        void *playback_buffer;
+////        char **playback_addr;
+//        WriteCopyFunction write_via_copy;
+//
+//        Voice* capture_voices;
+////        char *ioaudio_name_capture;
+////        unsigned long *capture_interleave_skip;
+//        unsigned int capture_nperiods;
+//        snd_pcm_t *capture_handle;
+//        snd_pcm_channel_params_t capture_params;
+//        snd_pcm_channel_setup_t capture_setup;
+//        snd_pcm_mmap_control_t *capture_mmap;
+//        void *capture_buffer;
+////        char **capture_addr;
+//        ReadCopyFunction read_via_copy;
+
+        jack_hardware_t *hw;
+//        ClockSyncStatus *clock_sync_data;
+        jack_client_t *client;
+//        JSList *capture_ports;
+//        JSList *playback_ports;
+//        JSList *monitor_ports;
+
+//        char soft_mode;
+//        bool all_monitor_in;
+        bool capture_and_playback_not_synced;
+//        char with_monitor_ports;
+        bool has_clock_sync_reporting;
+
+        bool has_hw_monitoring;
+        bool do_hw_monitoring;
+        unsigned long input_monitor_mask;
+
+        bool has_hw_metering;
+        bool do_hw_metering;
+        bool quirk_bswap;
+
+//        int dither;
+//        dither_state_t *dither_state;
+
+//        SampleClockMode clock_mode;
+//        JSList *clock_sync_listeners;
+//        pthread_mutex_t clock_sync_lock;
+//        unsigned long next_clock_sync_listener_id;
+
+//        int running;
+//        int run;
+
+        int xrun_count;
+        int process_count;
+
+//        ioaudio_midi_t *midi;
+//        char *midi;
+        int xrun_recovery;
+
+    };
+
+    class generic_hardware: public jack_hardware_t
     {
-        JackPort* port;
-        jack_port_id_t port_index;
-        unsigned long port_flags = (unsigned long) CaptureDriverFlags;
-        char name[REAL_JACK_PORT_NAME_SIZE];
-        char alias[REAL_JACK_PORT_NAME_SIZE];
+        virtual double get_hardware_peak(
+            jack_port_t *port,
+            jack_nframes_t frames )
+        {
+        return -1;
+        }
+
+        virtual double get_hardware_power(
+            jack_port_t *port,
+            jack_nframes_t frames )
+        {
+        return -1;
+        }
+
+        virtual int set_input_monitor_mask(
+            unsigned long mask )
+        {
+        return -1;
+        }
+
+        virtual int change_sample_clock(
+            SampleClockMode mode )
+        {
+        return -1;
+        }
+
+        virtual void release()
+        {
+        return;
+        }
 
-        assert( fCaptureChannels < DRIVER_PORT_NUM );
-        assert( fPlaybackChannels < DRIVER_PORT_NUM );
+    };
 
-        ioaudio_driver_t* ioaudio_driver = (ioaudio_driver_t*)fDriver;
+///////////////////////////////////////////////////////////////////////////////
+// PROTOTYPES
+///////////////////////////////////////////////////////////////////////////////
 
-        if( ioaudio_driver->has_hw_monitoring )
-            port_flags |= JackPortCanMonitor;
+//    jack_hardware_t *
+//    jack_ioaudio_generic_hw_new(
+//        ioaudio_driver_t *fDriver );
+//
+//    jack_time_t jack_get_microseconds(
+//        void );
+
+// Code implemented in JackioaudioDriver.cpp
+
+//void ReadInput(jack_nframes_t orig_nframes, ssize_t contiguous,
+    //        ssize_t nread);
+//void MonitorInput();
+//void ClearOutput();
+//void WriteOutput(jack_nframes_t orig_nframes, ssize_t contiguous,
+//        ssize_t nwritten);
+//void SetTime(jack_time_t time);
+//int Restart();
+
+//    extern void store_work_time(
+//        int );
+//    extern void store_wait_time(
+//        int );
+//    extern void show_wait_times();
+//    extern void show_work_times();
+//
+//    char* strcasestr(
+//        const char* haystack,
+//        const char* needle );
 
-        // io-audio driver may have changed the values
-        JackAudioDriver::SetBufferSize( ioaudio_driver->frames_per_cycle );
-        JackAudioDriver::SetSampleRate( ioaudio_driver->frame_rate );
+///////////////////////////////////////////////////////////////////////////////
+// IMPLEMENTATIONS
+///////////////////////////////////////////////////////////////////////////////
 
-        jack_log( "JackIoAudioDriver::Attach fBufferSize %ld fSampleRate %ld",
-                  fEngineControl->fBufferSize,
-                  fEngineControl->fSampleRate );
+    /* DRIVER "PLUGIN" INTERFACE */
 
-        for( int i = 0; i < fCaptureChannels; i++ )
+    int JackIoAudioDriver::Attach()
+    {
+    JackPort* port;
+    jack_port_id_t port_index;
+    unsigned long port_flags = (unsigned long) CaptureDriverFlags;
+    char name[REAL_JACK_PORT_NAME_SIZE];
+    char alias[REAL_JACK_PORT_NAME_SIZE];
+
+    assert( fCaptureChannels < DRIVER_PORT_NUM );
+    assert( fPlaybackChannels < DRIVER_PORT_NUM );
+
+    if( fDriver->has_hw_monitoring )
+        port_flags |= JackPortCanMonitor;
+
+    // io-audio driver may have changed the values
+    JackAudioDriver::SetBufferSize( fArgs.frames_per_interrupt );
+    JackAudioDriver::SetSampleRate( fDriver->frame_rate );
+
+    jack_log( "JackIoAudioDriver::Attach fBufferSize %ld fSampleRate %ld",
+              fEngineControl->fBufferSize,
+              fEngineControl->fSampleRate );
+
+    for( int i = 0; i < fCaptureChannels; i++ )
+        {
+        snprintf( alias,
+                  sizeof( alias ),
+                  "%s:%s:out%d",
+                  fAliasName,
+                  fCaptureDriverName,
+                  i + 1 );
+        snprintf( name,
+                  sizeof( name ),
+                  "%s:capture_%d",
+                  fClientControl.fName,
+                  i + 1 );
+        if( fEngine->PortRegister( fClientControl.fRefNum,
+                                   name,
+                                   JACK_DEFAULT_AUDIO_TYPE,
+                                   (JackPortFlags)port_flags,
+                                   fEngineControl->fBufferSize,
+                                   &port_index ) < 0 )
             {
-            snprintf( alias,
-                      sizeof( alias ),
-                      "%s:%s:out%d",
-                      fAliasName,
-                      fCaptureDriverName,
-                      i + 1 );
-            snprintf( name,
-                      sizeof( name ),
-                      "%s:capture_%d",
-                      fClientControl.fName,
-                      i + 1 );
-            if( fEngine->PortRegister( fClientControl.fRefNum,
-                                       name,
-                                       JACK_DEFAULT_AUDIO_TYPE,
-                                       (JackPortFlags)port_flags,
-                                       fEngineControl->fBufferSize,
-                                       &port_index ) < 0 )
-                {
-                jack_error( "driver: cannot register port for %s",
-                            name );
-                return -1;
-                }
-            port = fGraphManager->GetPort( port_index );
-            port->SetAlias( alias );
-            fCapturePortList[i] = port_index;
-            jack_log( "JackIoAudioDriver::Attach fCapturePortList[i] %ld ",
-                      port_index );
+            jack_error( "driver: cannot register port for %s",
+                        name );
+            return -1;
             }
-
-        port_flags = (unsigned long) PlaybackDriverFlags;
-
-        for( int i = 0; i < fPlaybackChannels; i++ )
+        port = fGraphManager->GetPort( port_index );
+        port->SetAlias( alias );
+        fCapturePortList[i] = port_index;
+        jack_log( "JackIoAudioDriver::Attach fCapturePortList[i] %ld ",
+                  port_index );
+        }
+
+    port_flags = (unsigned long) PlaybackDriverFlags;
+
+    for( int i = 0; i < fPlaybackChannels; i++ )
+        {
+        snprintf( alias,
+                  sizeof( alias ),
+                  "%s:%s:in%d",
+                  fAliasName,
+                  fPlaybackDriverName,
+                  i + 1 );
+        snprintf( name,
+                  sizeof( name ),
+                  "%s:playback_%d",
+                  fClientControl.fName,
+                  i + 1 );
+        if( fEngine->PortRegister( fClientControl.fRefNum,
+                                   name,
+                                   JACK_DEFAULT_AUDIO_TYPE,
+                                   (JackPortFlags)port_flags,
+                                   fEngineControl->fBufferSize,
+                                   &port_index ) < 0 )
             {
-            snprintf( alias,
-                      sizeof( alias ),
-                      "%s:%s:in%d",
-                      fAliasName,
-                      fPlaybackDriverName,
-                      i + 1 );
+            jack_error( "driver: cannot register port for %s",
+                        name );
+            return -1;
+            }
+        port = fGraphManager->GetPort( port_index );
+        port->SetAlias( alias );
+        fPlaybackPortList[i] = port_index;
+        jack_log( "JackIoAudioDriver::Attach fPlaybackPortList[i] %ld ",
+                  port_index );
+
+        // Monitor ports
+        if( fWithMonitorPorts )
+            {
+            jack_log( "Create monitor port" );
             snprintf( name,
                       sizeof( name ),
-                      "%s:playback_%d",
+                      "%s:monitor_%d",
                       fClientControl.fName,
                       i + 1 );
             if( fEngine->PortRegister( fClientControl.fRefNum,
                                        name,
                                        JACK_DEFAULT_AUDIO_TYPE,
-                                       (JackPortFlags)port_flags,
-                                       fEngineControl->fBufferSize,
-                                       &port_index ) < 0 )
+                                       MonitorDriverFlags, fEngineControl->fBufferSize, &port_index) <0 )
                 {
-                jack_error( "driver: cannot register port for %s",
-                            name );
-                return -1;
+                jack_error("io-audio: cannot register monitor port for %s", name);
                 }
-            port = fGraphManager->GetPort( port_index );
-            port->SetAlias( alias );
-            fPlaybackPortList[i] = port_index;
-            jack_log( "JackIoAudioDriver::Attach fPlaybackPortList[i] %ld ",
-                      port_index );
-
-            // Monitor ports
-            if( fWithMonitorPorts )
+            else
                 {
-                jack_log( "Create monitor port" );
-                snprintf( name,
-                          sizeof( name ),
-                          "%s:monitor_%d",
-                          fClientControl.fName,
-                          i + 1 );
-                if( fEngine->PortRegister( fClientControl.fRefNum,
-                                           name,
-                                           JACK_DEFAULT_AUDIO_TYPE,
-                                           MonitorDriverFlags, fEngineControl->fBufferSize, &port_index) <0 )
-                    {
-                    jack_error("io-audio: cannot register monitor port for %s", name);
-                    }
-                else
-                    {
-                    fMonitorPortList[i] = port_index;
-                    }
+                fMonitorPortList[i] = port_index;
                 }
             }
+        }
 
-        UpdateLatencies();
+    UpdateLatencies();
 
-//    if (ioaudio_driver->midi) {
-//        int err = (ioaudio_driver->midi->attach)(ioaudio_driver->midi);
-//        if (err)
-//            jack_error ("io-audio: cannot attach MIDI: %d", err);
-//    }
+    //if (fDriver->midi) {
+    //    int err = (fDriver->midi->attach)(fDriver->midi);
+    //    if (err)
+    //        jack_error ("io-audio: cannot attach MIDI: %d", err);
+    //}
 
-        return 0;
+    return 0;
     }
 
-    int JackIoAudioDriver::Detach()
+    void JackIoAudioDriver::ClearOutputAux()
     {
-//    ioaudio_driver_t* ioaudio_driver = (ioaudio_driver_t*)fDriver;
-//    if (ioaudio_driver->midi)
-//        (ioaudio_driver->midi->detach)(ioaudio_driver->midi);
-
-        return JackAudioDriver::Detach();
+    for( int chn = 0; chn < fPlaybackChannels; chn++ )
+        {
+        jack_default_audio_sample_t* buf =
+            (jack_default_audio_sample_t*)fGraphManager->GetBuffer( fPlaybackPortList[chn],
+                                                                    fEngineControl->fBufferSize );
+        memset( buf,
+                0,
+                sizeof(jack_default_audio_sample_t)
+                    * fEngineControl->fBufferSize );
+        }
     }
 
-//static int card_to_num(const char* device)
-//{
-//    int err;
-//    char* ctl_name;
-//    snd_ctl_card_info_t *card_info;
-//    snd_ctl_t* ctl_handle;
-//    int i = -1;
-//
-//    snd_ctl_card_info_alloca (&card_info);
-//
-//    ctl_name = get_control_device_name(device);
-//    if (ctl_name == NULL) {
-//        jack_error("get_control_device_name() failed.");
-//        goto fail;
-//    }
-//
-//    if ((err = snd_ctl_open (&ctl_handle, ctl_name, 0)) < 0) {
-//        jack_error ("control open \"%s\" (%s)", ctl_name,
-//                    snd_strerror(err));
-//        goto free;
-//    }
-//
-//    if ((err = snd_ctl_card_info(ctl_handle, card_info)) < 0) {
-//        jack_error ("control hardware info \"%s\" (%s)",
-//                    device, snd_strerror (err));
-//        goto close;
-//    }
-//
-//    i = snd_ctl_card_info_get_card(card_info);
-//
-//close:
-//    snd_ctl_close(ctl_handle);
-//
-//free:
-//    free(ctl_name);
-//
-//fail:
-//    return i;
-//}
-
-//int JackIoAudioDriver::Open(jack_nframes_t nframes,
-//                         jack_nframes_t user_nperiods,
-//                         jack_nframes_t samplerate,
-//                         bool hw_monitoring,
-//                         bool hw_metering,
-//                         bool capturing,
-//                         bool playing,
-//                         DitherAlgorithm dither,
-//                         bool soft_mode,
-//                         bool monitor,
-//                         int inchannels,
-//                         int outchannels,
-//                         bool shorts_first,
-//                         const char* capture_driver_name,
-//                         const char* playback_driver_name,
-//                         jack_nframes_t capture_latency,
-//                         jack_nframes_t playback_latency,
-//                         const char* midi_driver_name)
-    int JackIoAudioDriver::Open(
-        ioaudio_driver_args_t args )
+    int JackIoAudioDriver::Close()
     {
-        // Generic JackAudioDriver Open
-        if( JackAudioDriver::Open( args.frames_per_interrupt,
-                                   args.srate,
-                                   args.capture,
-                                   args.playback,
-                                   args.user_capture_nchnls,
-                                   args.user_playback_nchnls,
-                                   args.monitor,
-                                   args.capture_pcm_name,
-                                   args.playback_pcm_name,
-                                   args.systemic_input_latency,
-                                   args.systemic_output_latency ) != 0 )
+    // Generic audio driver close
+    int res = JackAudioDriver::Close();
+
+    destroy();
+
+    if( JackServerGlobals::on_device_release != NULL )
+        {
+        char audio_name[32];
+        int capture_card = snd_card_name( fCaptureDriverName );
+        if( capture_card >= 0 )
             {
-            return -1;
+            snprintf( audio_name,
+                      sizeof( audio_name ),
+                      "Audio%d",
+                      capture_card );
+            JackServerGlobals::on_device_release( audio_name );
+            }
+
+        int playback_card = snd_card_name( fPlaybackDriverName );
+        if( playback_card >= 0 && playback_card != capture_card )
+            {
+            snprintf( audio_name,
+                      sizeof( audio_name ),
+                      "Audio%d",
+                      playback_card );
+            JackServerGlobals::on_device_release( audio_name );
             }
+        }
+
+    return res;
+    }
+
+    int JackIoAudioDriver::Detach()
+    {
+    //ioaudio_driver_t* ioaudio_driver = (ioaudio_driver_t*)fDriver;
+    //if (fDriver->midi)
+    //    (fDriver->midi->detach)(fDriver->midi);
 
-//    ioaudio_midi_t *midi = 0;
-//#ifndef __ANDROID__
-//    if (strcmp(midi_driver_name, "seq") == 0)
-//        midi = ioaudio_seqmidi_new((jack_client_t*)this, 0);
-//    else if (strcmp(midi_driver_name, "raw") == 0)
-//        midi = ioaudio_rawmidi_new((jack_client_t*)this);
-//#endif
+    return JackAudioDriver::Detach();
+    }
 
-        if( JackServerGlobals::on_device_acquire != NULL )
+    void JackIoAudioDriver::MonitorInputAux()
+    {
+    for( int chn = 0; chn < fCaptureChannels; chn++ )
+        {
+        JackPort* port = fGraphManager->GetPort( fCapturePortList[chn] );
+        if( port->MonitoringInput() )
             {
-            int capture_card = snd_card_name( args.capture_pcm_name );
-            int playback_card = snd_card_name( args.playback_pcm_name );
-            char audio_name[32];
+            ( (ioaudio_driver_t *)fDriver )->input_monitor_mask |= ( 1 << chn );
+            }
+        }
+    }
 
-            if( capture_card >= 0 )
+    int JackIoAudioDriver::Open(
+        ioaudio_driver_args_t args )
+    {
+    // Generic JackAudioDriver Open
+    if( JackAudioDriver::Open( args.frames_per_interrupt,
+                               args.srate,
+                               args.capture,
+                               args.playback,
+                               args.user_capture_nchnls,
+                               args.user_playback_nchnls,
+                               args.monitor,
+                               args.capture_pcm_name,
+                               args.playback_pcm_name,
+                               args.systemic_input_latency,
+                               args.systemic_output_latency ) != 0 )
+        {
+        return -1;
+        }
+
+    memcpy( &fArgs,
+            &args,
+            sizeof(ioaudio_driver_args_t) );
+
+    //ioaudio_midi_t *midi = 0;
+    //if (strcmp(midi_driver_name, "seq") == 0)
+    //    midi = ioaudio_seqmidi_new((jack_client_t*)this, 0);
+    //else if (strcmp(midi_driver_name, "raw") == 0)
+    //    midi = ioaudio_rawmidi_new((jack_client_t*)this);
+
+    if( JackServerGlobals::on_device_acquire != NULL )
+        {
+        int capture_card = snd_card_name( args.capture_pcm_name );
+        int playback_card = snd_card_name( args.playback_pcm_name );
+        char audio_name[32];
+
+        if( capture_card >= 0 )
+            {
+            snprintf( audio_name,
+                      sizeof( audio_name ),
+                      "Audio%d",
+                      capture_card );
+            if( !JackServerGlobals::on_device_acquire( audio_name ) )
                 {
-                snprintf( audio_name,
-                          sizeof( audio_name ),
-                          "Audio%d",
-                          capture_card );
-                if( !JackServerGlobals::on_device_acquire( audio_name ) )
-                    {
-                    jack_error( "Audio device %s cannot be acquired...",
-                                args.capture_pcm_name );
-                    return -1;
-                    }
+                jack_error( "Audio device %s cannot be acquired...",
+                            args.capture_pcm_name );
+                return -1;
                 }
+            }
 
-            if( playback_card >= 0 && playback_card != capture_card )
+        if( playback_card >= 0 && playback_card != capture_card )
+            {
+            snprintf( audio_name,
+                      sizeof( audio_name ),
+                      "Audio%d",
+                      playback_card );
+            if( !JackServerGlobals::on_device_acquire( audio_name ) )
                 {
-                snprintf( audio_name,
-                          sizeof( audio_name ),
-                          "Audio%d",
-                          playback_card );
-                if( !JackServerGlobals::on_device_acquire( audio_name ) )
+                jack_error( "Audio device %s cannot be acquired...",
+                            args.playback_pcm_name );
+                if( capture_card >= 0 )
                     {
-                    jack_error( "Audio device %s cannot be acquired...",
-                                args.playback_pcm_name );
-                    if( capture_card >= 0 )
-                        {
-                        snprintf( audio_name,
-                                  sizeof( audio_name ),
-                                  "Audio%d",
-                                  capture_card );
-                        JackServerGlobals::on_device_release( audio_name );
-                        }
-                    return -1;
+                    snprintf( audio_name,
+                              sizeof( audio_name ),
+                              "Audio%d",
+                              capture_card );
+                    JackServerGlobals::on_device_release( audio_name );
                     }
+                return -1;
                 }
             }
-
-        fDriver = ioaudio_driver_new( (char*)"ioaudio_pcm",
-                                      NULL,
-                                      args );
-//                                      (char*)playback_driver_name,
-//                                      (char*)capture_driver_name,
-//                                      NULL,
-//                                      nframes,
-//                                      user_nperiods,
-//                                      samplerate,
-//                                      hw_monitoring,
-//                                      hw_metering,
-//                                      capturing,
-//                                      playing,
-//                                      dither,
-//                                      soft_mode,
-//                                      monitor,
-//                                      inchannels,
-//                                      outchannels,
-//                                      shorts_first,
-//                                      capture_latency,
-//                                      playback_latency /*,
-//                                       midi             */
-//                                      );
-        if( fDriver )
-            {
-            // io-audio driver may have changed the in/out values
-            fCaptureChannels =
-                ( (ioaudio_driver_t *)fDriver )->capture_setup.format.voices;
-            fPlaybackChannels =
-                ( (ioaudio_driver_t *)fDriver )->playback_setup.format.voices;
-            return 0;
-            }
-        else
-            {
-            JackAudioDriver::Close();
-            return -1;
-            }
+        }
+
+    create( (char*)"ioaudio_pcm",
+            NULL );
+    if( fDriver )
+        {
+        // io-audio driver may have changed the in/out values
+        fCaptureChannels = fDriver->capture.setup.format.voices;
+        fPlaybackChannels = fDriver->playback.setup.format.voices;
+        return 0;
+        }
+    else
+        {
+        JackAudioDriver::Close();
+        return -1;
+        }
     }
 
-    int JackIoAudioDriver::Close()
+    int JackIoAudioDriver::Read()
     {
-        // Generic audio driver close
-        int res = JackAudioDriver::Close();
+    /* Taken from ioaudio_driver_run_cycle */
+    int wait_status;
+    jack_nframes_t nframes;
+    fDelayedUsecs = 0.f;
+
+    retry:
+
+    nframes = wait( &wait_status,
+                    &fDelayedUsecs );
+
+    if( wait_status < 0 )
+        return -1; /* driver failed */
+
+    if( nframes == 0 )
+        {
+        /* we detected an xrun and restarted: notify
+         * clients about the delay.
+         */
+        jack_log( "io-audio XRun wait_status = %d",
+                  wait_status );
+        NotifyXRun( fBeginDateUst,
+                    fDelayedUsecs );
+        goto retry;
+        /* recoverable error*/
+        }
+
+    if( nframes != fEngineControl->fBufferSize )
+        jack_log( "JackIoAudioDriver::Read warning fBufferSize = %ld nframes = %ld",
+                  fEngineControl->fBufferSize,
+                  nframes );
 
-        ioaudio_driver_delete( (ioaudio_driver_t*)fDriver );
+    // Has to be done before read
+    JackDriver::CycleIncTime();
 
-        if( JackServerGlobals::on_device_release != NULL )
-            {
-            char audio_name[32];
-            int capture_card = snd_card_name( fCaptureDriverName );
-            if( capture_card >= 0 )
-                {
-                snprintf( audio_name,
-                          sizeof( audio_name ),
-                          "Audio%d",
-                          capture_card );
-                JackServerGlobals::on_device_release( audio_name );
-                }
+    return read( fEngineControl->fBufferSize );
+    }
 
-            int playback_card = snd_card_name( fPlaybackDriverName );
-            if( playback_card >= 0 && playback_card != capture_card )
-                {
-                snprintf( audio_name,
-                          sizeof( audio_name ),
-                          "Audio%d",
-                          playback_card );
-                JackServerGlobals::on_device_release( audio_name );
-                }
+    void JackIoAudioDriver::ReadInputAux(
+        jack_nframes_t orig_nframes,
+        ssize_t contiguous,
+        ssize_t nread )
+    {
+    for( int chn = 0; chn < fCaptureChannels; chn++ )
+        {
+        if( fGraphManager->GetConnectionsNum( fCapturePortList[chn] ) > 0 )
+            {
+            jack_default_audio_sample_t* buf =
+                (jack_default_audio_sample_t*)fGraphManager->GetBuffer( fCapturePortList[chn],
+                                                                        orig_nframes );
+            fDriver->capture.read( buf + nread,
+                                   fDriver->capture.voices[chn].addr,
+                                   contiguous,
+                                   fDriver->capture.voices[chn].interleave_skip );
             }
+        }
+    }
 
-        return res;
+    int JackIoAudioDriver::SetBufferSize(
+        jack_nframes_t buffer_size )
+    {
+    jack_log( "JackIoAudioDriver::SetBufferSize %ld",
+              buffer_size );
+    fArgs.frames_per_interrupt = buffer_size;
+    int res = reset_parameters();
+
+    if( res == 0 )
+        {
+        // update fEngineControl and fGraphManager
+        JackAudioDriver::SetBufferSize( buffer_size ); // Generic change, never fails
+        // io-audio specific
+        UpdateLatencies();
+        }
+    else
+        {
+        // Restore old values
+        fArgs.frames_per_interrupt = fEngineControl->fBufferSize;
+        reset_parameters();
+        }
+
+    return res;
     }
 
+//    void JackIoAudioDriver::SetTimetAux(
+//        jack_time_t time )
+//    {
+//    fBeginDateUst = time;
+//    }
+
     int JackIoAudioDriver::Start()
     {
-        int res = JackAudioDriver::Start();
-        if( res >= 0 )
+    int res = JackAudioDriver::Start();
+    if( res >= 0 )
+        {
+        res = start();
+        if( res < 0 )
             {
-            res = ioaudio_driver_start( (ioaudio_driver_t *)fDriver );
-            if( res < 0 )
-                {
-                JackAudioDriver::Stop();
-                }
+            JackAudioDriver::Stop();
             }
-        return res;
+        }
+    return res;
     }
 
     int JackIoAudioDriver::Stop()
     {
-        int res = ioaudio_driver_stop( (ioaudio_driver_t *)fDriver );
-        if( JackAudioDriver::Stop() < 0 )
+    int res = stop();
+    if( JackAudioDriver::Stop() < 0 )
+        {
+        res = -1;
+        }
+    return res;
+    }
+
+    void JackIoAudioDriver::UpdateLatencies()
+    {
+    jack_latency_range_t range;
+
+    for( int i = 0; i < fCaptureChannels; i++ )
+        {
+        range.min = range.max = fArgs.frames_per_interrupt
+            + fArgs.systemic_input_latency;
+        fGraphManager->GetPort( fCapturePortList[i] )->SetLatencyRange( JackCaptureLatency,
+                                                                        &range );
+        }
+
+    for( int i = 0; i < fPlaybackChannels; i++ )
+        {
+        // Add one buffer more latency if "async" mode is used...
+        range.min = range.max =
+            ( fArgs.frames_per_interrupt * ( fArgs.user_nperiods - 1 ) )
+                + ( ( fEngineControl->fSyncMode ) ?
+                    0 : fEngineControl->fBufferSize )
+                + fArgs.systemic_output_latency;
+        fGraphManager->GetPort( fPlaybackPortList[i] )->SetLatencyRange( JackPlaybackLatency,
+                                                                         &range );
+        // Monitor port
+        if( fWithMonitorPorts )
             {
-            res = -1;
+            range.min = range.max = fArgs.frames_per_interrupt;
+            fGraphManager->GetPort( fMonitorPortList[i] )->SetLatencyRange( JackCaptureLatency,
+                                                                            &range );
             }
-        return res;
+        }
     }
 
-    int JackIoAudioDriver::Read()
+    int JackIoAudioDriver::Write()
     {
-        /* Taken from ioaudio_driver_run_cycle */
-        int wait_status;
-        jack_nframes_t nframes;
-        fDelayedUsecs = 0.f;
+    jack_nframes_t nframes = fEngineControl->fBufferSize;
 
-        retry:
+    jack_nframes_t orig_nframes;
+    ssize_t nwritten;
+    ssize_t contiguous;
+    size_t offset = 0;
+    //jack_port_t *port;
+    int err;
 
-        nframes = ioaudio_driver_wait( (ioaudio_driver_t *)fDriver,
-                                       -1,
-                                       &wait_status,
-                                       &fDelayedUsecs );
+    fDriver->process_count++;
 
-        if( wait_status < 0 )
-            return -1; /* driver failed */
+    if( !fDriver->playback.handle )
+        {
+        return 0;
+        }
 
-        if( nframes == 0 )
-            {
-            /* we detected an xrun and restarted: notify
-             * clients about the delay.
-             */
-            jack_log( "io-audio XRun wait_status = %d",
-                      wait_status );
-            NotifyXRun( fBeginDateUst,
-                        fDelayedUsecs );
-            goto retry;
-            /* recoverable error*/
-            }
+    if( nframes > fArgs.frames_per_interrupt )
+        {
+        return -1;
+        }
 
-        if( nframes != fEngineControl->fBufferSize )
-            jack_log(
-                      "JackIoAudioDriver::Read warning fBufferSize = %ld nframes = %ld",
-                      fEngineControl->fBufferSize,
-                      nframes );
+    //if (fDriver->midi)
+    //    (fDriver->midi->write)(fDriver->midi, nframes);
 
-        // Has to be done before read
-        JackDriver::CycleIncTime();
+    nwritten = 0;
+    contiguous = 0;
+    orig_nframes = nframes;
 
-        return ioaudio_driver_read( (ioaudio_driver_t *)fDriver,
-                                    fEngineControl->fBufferSize );
-    }
+    /* check current input monitor request status */
 
-    int JackIoAudioDriver::Write()
-    {
-        return ioaudio_driver_write( (ioaudio_driver_t *)fDriver,
-                                     fEngineControl->fBufferSize );
-    }
+    fDriver->input_monitor_mask = 0;
 
-    void JackIoAudioDriver::ReadInputAux(
-        jack_nframes_t orig_nframes,
-        ssize_t contiguous,
-        ssize_t nread )
-    {
-        for( int chn = 0; chn < fCaptureChannels; chn++ )
+    MonitorInputAux();
+
+    if( fDriver->do_hw_monitoring )
+        {
+        if( fDriver->hw->input_monitor_mask != fDriver->input_monitor_mask )
             {
-            if( fGraphManager->GetConnectionsNum( fCapturePortList[chn] ) > 0 )
-                {
-                jack_default_audio_sample_t* buf =
-                    (jack_default_audio_sample_t*)fGraphManager->GetBuffer(
-                                                                            fCapturePortList[chn],
-                                                                            orig_nframes );
-                ioaudio_driver_read_from_channel( (ioaudio_driver_t *)fDriver,
-                                                  chn,
-                                                  buf + nread,
-                                                  contiguous );
-                }
+            fDriver->hw->set_input_monitor_mask( fDriver->input_monitor_mask );
             }
-    }
+        }
 
-    void JackIoAudioDriver::MonitorInputAux()
-    {
-        for( int chn = 0; chn < fCaptureChannels; chn++ )
+    while( nframes )
+        {
+
+        contiguous = nframes;
+
+        if( get_channel_addresses( (size_t *)0,
+                                   (size_t *)&contiguous,
+                                   0,
+                                   &offset ) < 0 )
             {
-            JackPort* port = fGraphManager->GetPort( fCapturePortList[chn] );
-            if( port->MonitoringInput() )
-                {
-                ( (ioaudio_driver_t *)fDriver )->input_monitor_mask |=
-                    ( 1 << chn );
-                }
+            return -1;
             }
-    }
 
-    void JackIoAudioDriver::ClearOutputAux()
-    {
-        for( int chn = 0; chn < fPlaybackChannels; chn++ )
+        WriteOutputAux( orig_nframes,
+                        contiguous,
+                        nwritten );
+
+        if( !bitset_empty( fDriver->channels_not_done ) )
             {
-            jack_default_audio_sample_t* buf =
-                (jack_default_audio_sample_t*)fGraphManager->GetBuffer(
-                                                                        fPlaybackPortList[chn],
-                                                                        fEngineControl->fBufferSize );
-            memset( buf,
-                    0,
-                    sizeof(jack_default_audio_sample_t)
-                        * fEngineControl->fBufferSize );
+            silence_untouched_channels( contiguous );
             }
-    }
 
-    void JackIoAudioDriver::SetTimetAux(
-        jack_time_t time )
-    {
-        fBeginDateUst = time;
+        err = snd_pcm_write( fDriver->playback.handle,
+                             fDriver->playback.buffer,
+                             fDriver->playback.frag_bytes() );
+        if( err < 0 )
+            {
+            jack_error( "io-audio: could not complete playback of %"
+                        PRIu32 " frames: error = %d",
+                        contiguous,
+                        err );
+            if( err != -EPIPE && err != -ESTRPIPE )
+                return -1;
+            }
+
+        nframes -= contiguous;
+        nwritten += contiguous;
+        }
+
+    return 0;
     }
 
     void JackIoAudioDriver::WriteOutputAux(
@@ -621,700 +851,2120 @@ namespace Jack
         ssize_t contiguous,
         ssize_t nwritten )
     {
-        for( int chn = 0; chn < fPlaybackChannels; chn++ )
+    for( int chn = 0; chn < fPlaybackChannels; chn++ )
+        {
+        // Output ports
+        if( fGraphManager->GetConnectionsNum( fPlaybackPortList[chn] ) > 0 )
             {
-            // Output ports
-            if( fGraphManager->GetConnectionsNum( fPlaybackPortList[chn] ) > 0 )
+            jack_default_audio_sample_t* buf =
+                (jack_default_audio_sample_t*)fGraphManager->GetBuffer( fPlaybackPortList[chn],
+                                                                        orig_nframes );
+            fDriver->playback.write( fDriver->playback.voices[chn].addr,
+                                     buf + nwritten,
+                                     contiguous,
+                                     fDriver->playback.voices[chn].interleave_skip,
+                                     &fDriver->playback.voices[chn].dither_state );
+            mark_channel_done( chn );
+
+            // Monitor ports
+            if( fWithMonitorPorts
+                && fGraphManager->GetConnectionsNum( fMonitorPortList[chn] )
+                    > 0 )
                 {
-                jack_default_audio_sample_t* buf =
-                    (jack_default_audio_sample_t*)fGraphManager->GetBuffer(
-                                                                            fPlaybackPortList[chn],
+                jack_default_audio_sample_t* monbuf =
+                    (jack_default_audio_sample_t*)fGraphManager->GetBuffer( fMonitorPortList[chn],
                                                                             orig_nframes );
-                ioaudio_driver_write_to_channel( ( (ioaudio_driver_t *)fDriver ),
-                                                 chn,
-                                                 buf + nwritten,
-                                                 contiguous );
-                // Monitor ports
-                if( fWithMonitorPorts
-                    && fGraphManager->GetConnectionsNum(
-                                                         fMonitorPortList[chn] )
-                        > 0 )
-                    {
-                    jack_default_audio_sample_t* monbuf =
-                        (jack_default_audio_sample_t*)fGraphManager->GetBuffer(
-                                                                                fMonitorPortList[chn],
-                                                                                orig_nframes );
-                    memcpy( monbuf + nwritten,
-                            buf + nwritten,
-                            contiguous * sizeof(jack_default_audio_sample_t) );
-                    }
+                memcpy( monbuf + nwritten,
+                        buf + nwritten,
+                        contiguous * sizeof(jack_default_audio_sample_t) );
                 }
             }
+        }
     }
+//
+//    ssize_t JackIoAudioDriver::capture_sample_bytes()
+//    {
+//    return snd_pcm_format_size( fDriver->capture.setup.format.format,
+//                                1 );
+//    }
+//    ssize_t JackIoAudioDriver::capture_frame_bytes()
+//    {
+//    return snd_pcm_format_size( fDriver->capture.setup.format.format,
+//                                fDriver->capture.setup.format.voices );
+//    }
+//    ssize_t JackIoAudioDriver::capture_frag_bytes()
+//    {
+//    return snd_pcm_format_size( fDriver->capture.setup.format.format,
+//                                fDriver->capture.setup.format.voices
+//                                    * fArgs.frames_per_interrupt );
+//    }
+//    ssize_t JackIoAudioDriver::capture_frag_frames()
+//    {
+//    return capture_frag_bytes()
+//        / snd_pcm_format_size( fDriver->capture.setup.format.format,
+//                               fDriver->capture.setup.format.voices );
+//    }
+//
+//    ssize_t JackIoAudioDriver::playback_sample_bytes()
+//    {
+//    return snd_pcm_format_size( fDriver->playback.setup.format.format,
+//                                1 );
+//    }
+//    ssize_t JackIoAudioDriver::playback_frame_bytes()
+//    {
+//    return snd_pcm_format_size( fDriver->playback.setup.format.format,
+//                                fDriver->playback.setup.format.voices );
+//    }
+//    ssize_t JackIoAudioDriver::playback_frag_bytes()
+//    {
+//    return snd_pcm_format_size( fDriver->playback.setup.format.format,
+//                                fDriver->playback.setup.format.voices
+//                                    * fArgs.frames_per_interrupt );
+//    }
+//    ssize_t JackIoAudioDriver::playback_frag_frames()
+//    {
+//    return playback_frag_bytes()
+//        / snd_pcm_format_size( fDriver->playback.setup.format.format,
+//                               fDriver->playback.setup.format.voices );
+//    }
 
-    int JackIoAudioDriver::is_realtime() const
+    int JackIoAudioDriver::check_capabilities(
+        const char *devicename,
+        int mode )
     {
-        return fEngineControl->fRealTime;
+    int ret = 0;
+    int err;
+    snd_pcm_t* device;
+    snd_pcm_info_t info;
+    snd_ctl_t* ctl;
+    snd_ctl_hw_info_t hw_info;
+
+    err = snd_pcm_open_name( &device,
+                             devicename,
+                             mode );
+    if( err )
+        {
+        jack_error( "device open name:(%s) error:(%s)",
+                    devicename,
+                    snd_strerror( err ) );
+        return err;
+        }
+
+    err = snd_pcm_info( device,
+                        &info );
+    if( err )
+        {
+        jack_error( "device info error:(%s)",
+                    devicename,
+                    snd_strerror( err ) );
+        snd_pcm_close( device );
+        return err;
+        }
+
+    err = snd_ctl_open( &ctl,
+                        info.card );
+    if( err )
+        {
+        jack_error( "control open card:(%d) error:(%s)",
+                    info.card,
+                    snd_strerror( err ) );
+        snd_pcm_close( device );
+        return err;
+        }
+
+    err = snd_ctl_hw_info( ctl,
+                           &hw_info );
+    if( err )
+        {
+        jack_error( "control hardware error:(%s)",
+                    snd_strerror( err ) );
+        snd_ctl_close( ctl );
+        snd_pcm_close( device );
+        return err;
+        }
+
+    if( ( SND_PCM_OPEN_CAPTURE == mode )
+        && !( info.flags & SND_PCM_INFO_CAPTURE ) )
+        {
+        jack_error( "Capture channels required but not available" );
+        ret = -EINVAL;
+        }
+    if( ( SND_PCM_OPEN_PLAYBACK == mode )
+        && !( info.flags & SND_PCM_INFO_PLAYBACK ) )
+        {
+        jack_error( "Playback channels required but not available" );
+        ret = -EINVAL;
+        }
+
+    snd_ctl_close( ctl );
+    snd_pcm_close( device );
+    return ret;
     }
 
-    int JackIoAudioDriver::create_thread(
-        pthread_t *thread,
-        int priority,
-        int realtime,
-        void *(*start_routine)(
-            void* ),
-        void *arg )
+    int JackIoAudioDriver::check_card_type()
     {
-#ifdef __ANDROID__
-        return JackAndroidThread::StartImp(thread, priority, realtime, start_routine, arg);
-#else
-        return JackPosixThread::StartImp( thread,
-                                          priority,
-                                          realtime,
-                                          start_routine,
-                                          arg );
-#endif
+    int err;
+
+    // Check capture device can be opened
+    if( fArgs.capture )
+        {
+        err = check_capabilities( fArgs.capture_pcm_name,
+                                  SND_PCM_OPEN_CAPTURE );
+        if( err )
+            return err;
+        }
+
+    // Check playback device can be opened
+    if( fArgs.playback )
+        {
+        err = check_capabilities( fArgs.playback_pcm_name,
+                                  SND_PCM_OPEN_PLAYBACK );
+        if( err )
+            return err;
+        }
+
+    return 0;
     }
 
-    jack_port_id_t JackIoAudioDriver::port_register(
-        const char *port_name,
-        const char *port_type,
-        unsigned long flags,
-        unsigned long buffer_size )
+    int JackIoAudioDriver::configure_stream(
+        const char *device_name,
+        const char *stream_name,
+        snd_pcm_t *handle,
+        snd_pcm_channel_params_t *params,
+        unsigned int *nperiodsp )
     {
-        jack_port_id_t port_index;
-        int res = fEngine->PortRegister( fClientControl.fRefNum,
-                                         port_name,
-                                         port_type,
-                                         flags,
-                                         buffer_size,
-                                         &port_index );
-        return ( res == 0 ) ? port_index : 0;
-    }
+    int err;
+    size_t format;
+    snd_pcm_channel_info_t info;
+    int32_t formats[] = {
+    SND_PCM_SFMT_FLOAT_LE,
+                          SND_PCM_SFMT_S32_LE,
+                          SND_PCM_SFMT_S32_BE,
+                          SND_PCM_SFMT_S24_LE,
+                          SND_PCM_SFMT_S24_BE,
+                          SND_PCM_SFMT_S16_LE,
+                          SND_PCM_SFMT_S16_BE };
+#define NUMFORMATS (sizeof(formats)/sizeof(formats[0]))
+
+    info.channel = params->channel;
+
+    err = snd_pcm_channel_info( handle,
+                                &info );
+
+    if( SND_PCM_CHNINFO_NONINTERLEAVE & info.flags )
+        {
+        params->format.interleave = 0;
+        }
+    else if( SND_PCM_CHNINFO_INTERLEAVE & info.flags )
+        {
+        params->format.interleave = 1;
+        }
+
+    if( !( SND_PCM_CHNINFO_MMAP & info.flags ) )
+        {
+        jack_error( "io-audio: mmap-based access is not possible"
+                    " for the %s "
+                    "stream of this audio interface",
+                    stream_name );
+        return -1;
+        }
+
+    params->mode = SND_PCM_MODE_BLOCK;
+
+    for( format = 0; format < NUMFORMATS; ++format )
+        {
+        if( info.formats & ( 1 << formats[format] ) )
+            {
+            jack_log( "io-audio: final selected sample format for %s: %s",
+                      stream_name,
+                      snd_pcm_get_format_name( formats[format] ) );
+            params->format.format = formats[format];
+            break;
+            }
+        }
+    if( NUMFORMATS == format )
+        {
+        jack_error( "Sorry. The audio interface \"%s\""
+                    " doesn't support any of the"
+                    " hardware sample formats that"
+                    " JACK's ioaudio-driver can use.",
+                    device_name );
+        return -1;
+        }
+
+#if defined(SND_LITTLE_ENDIAN)
+    fDriver->quirk_bswap = snd_pcm_format_big_endian(formats[format]);
+#elif defined(SND_BIG_ENDIAN)
+    fDriver->quirk_bswap = snd_pcm_format_little_endian( formats[format] );
+#else
+    fDriver->quirk_bswap = 0;
+#endif
 
-    int JackIoAudioDriver::port_unregister(
-        jack_port_id_t port_index )
-    {
-        return fEngine->PortUnRegister( fClientControl.fRefNum,
-                                        port_index );
-    }
+    params->format.rate = fDriver->frame_rate;
 
-    void* JackIoAudioDriver::port_get_buffer(
-        int port,
-        jack_nframes_t nframes )
-    {
-        return fGraphManager->GetBuffer( port,
-                                         nframes );
-    }
+    if( 0 == params->format.voices )
+        {
+        /*if not user-specified, try to find the maximum
+         * number of channels */
+        params->format.voices = info.max_voices;
+        }
 
-    int JackIoAudioDriver::port_set_alias(
-        int port,
-        const char* name )
-    {
-        return fGraphManager->GetPort( port )->SetAlias( name );
-    }
+    params->start_mode = SND_PCM_START_DATA;
 
-    jack_nframes_t JackIoAudioDriver::get_sample_rate() const
-    {
-        return fEngineControl->fSampleRate;
-    }
+    params->stop_mode = SND_PCM_STOP_STOP;
 
-    jack_nframes_t JackIoAudioDriver::frame_time() const
-    {
-        JackTimer timer;
-        fEngineControl->ReadFrameTime( &timer );
-        return timer.Time2Frames( GetMicroSeconds(),
-                                  fEngineControl->fBufferSize );
-    }
+    params->time = 1;
 
-    jack_nframes_t JackIoAudioDriver::last_frame_time() const
-    {
-        JackTimer timer;
-        fEngineControl->ReadFrameTime( &timer );
-        return timer.CurFrame();
-    }
+    params->buf.block.frag_size =
+        snd_pcm_format_size( formats[format],
+                             params->format.voices
+                                 * fArgs.frames_per_interrupt );
 
-} // end of namespace
+    *nperiodsp = fArgs.user_nperiods;
+    params->buf.block.frags_min = fArgs.user_nperiods;
+    params->buf.block.frags_max = fArgs.user_nperiods;
 
-#ifdef __cplusplus
-extern "C"
-{
-#endif
+    jack_log( "io-audio: use %d periods for %s",
+              *nperiodsp,
+              stream_name );
 
-    static jack_driver_param_constraint_desc_t *
-    enum_ioaudio_devices()
-    {
-        snd_ctl_t * handle;
-        snd_ctl_hw_info_t hwinfo;
-        snd_pcm_info_t pcminfo;
-        int card_no = -1;
-        jack_driver_param_value_t card_id;
-        jack_driver_param_value_t device_id;
-        char description[64];
-        uint32_t device_no;
-        bool has_capture;
-        bool has_playback;
-        jack_driver_param_constraint_desc_t * constraint_ptr;
-        uint32_t array_size = 0;
-
-        constraint_ptr = NULL;
-
-        int cards_over = 0;
-        int numcards = snd_cards_list( NULL,
-                                       0,
-                                       &cards_over );
-        int* cards = static_cast<int*>( malloc( cards_over * sizeof(int) ) );
-        numcards = snd_cards_list( cards,
-                                   cards_over,
-                                   &cards_over );
+    int subchn_len = sizeof( params->sw_mixer_subchn_name );
+    strncpy( params->sw_mixer_subchn_name,
+             stream_name,
+             subchn_len );
+    params->sw_mixer_subchn_name[subchn_len - 1] = '\0';
 
-        for( int c = 0; c < numcards; ++c )
-            {
-            card_no = cards[c];
+    if( ( err = snd_pcm_channel_params( handle,
+                                        params ) ) < 0 )
+        {
+        jack_error( "io-audio: cannot set hardware parameters for %s, why_failed=%d",
+                    stream_name,
+                    params->why_failed );
+        return -1;
+        }
+
+    return 0;
+    }
 
-            if( snd_ctl_open( &handle,
-                              card_no ) >= 0
-                && snd_ctl_hw_info( handle,
-                                    &hwinfo ) >= 0 )
+    void JackIoAudioDriver::create(
+        char *name,
+        jack_client_t *client )
+    {
+    int err;
+
+    jack_log( "creating ioaudio driver ... %s|%s|%" PRIu32 "|%" PRIu32
+              "|%" PRIu32"|%" PRIu32"|%" PRIu32 "|%s|%s|%s|%s",
+              fArgs.playback ? fArgs.playback_pcm_name : "-",
+              fArgs.capture ? fArgs.capture_pcm_name : "-",
+              fArgs.frames_per_interrupt,
+              fArgs.user_nperiods,
+              fArgs.srate,
+              fArgs.user_capture_nchnls,
+              fArgs.user_playback_nchnls,
+              fArgs.hw_monitoring ? "hwmon" : "nomon",
+              fArgs.hw_metering ? "hwmeter" : "swmeter",
+              fArgs.soft_mode ? "soft-mode" : "-",
+              fArgs.shorts_first ? "16bit" : "32bit" );
+
+//    fDriver = (ioaudio_driver_t *)calloc( 1,
+//                                          sizeof(ioaudio_driver_t) );
+    fDriver = new ioaudio_driver_t;
+
+//    fDriver->user_playback_nchnls = fArgs.user_playback_nchnls;
+//    fDriver->user_capture_nchnls = fArgs.user_capture_nchnls;
+//    fDriver->capture.frame_latency = fArgs.systemic_input_latency;
+//    fDriver->playback.frame_latency = fArgs.systemic_output_latency;
+
+//    fDriver->with_monitor_ports = fArgs.monitor;
+
+//    fDriver->clock_mode = ClockMaster; /* XXX is it? */
+
+//    fDriver->dither = fArgs.dither;
+//    fDriver->soft_mode = fArgs.soft_mode;
+
+//    pthread_mutex_init( &fDriver->clock_sync_lock,
+//                        0 );
+
+//        fDriver->ioaudio_name_playback = strdup(fArgs.playback_pcm_name);
+//        fDriver->ioaudio_name_capture = strdup(fArgs.capture_pcm_name);
+
+    //fDriver->midi = midi_driver;
+
+    if( check_card_type() )
+        {
+        destroy();
+        return;
+        }
+
+    hw_specific();
+
+    if( fArgs.playback )
+        {
+        err =
+            snd_pcm_open_name( &fDriver->playback.handle,
+                               fArgs.playback_pcm_name,
+                               SND_PCM_OPEN_PLAYBACK | SND_PCM_OPEN_NONBLOCK );
+        if( err < 0 )
+            {
+            switch( errno )
                 {
-                strncpy( card_id.str,
-                         hwinfo.id,
-                         sizeof( card_id.str ) );
-                strncpy( description,
-                         hwinfo.longname,
-                         sizeof( description ) );
-                if( !jack_constraint_add_enum( &constraint_ptr,
-                                               &array_size,
-                                               &card_id,
-                                               description ) )
-                    goto fail;
+                case EBUSY:
+                    jack_error( "\n\nATTENTION: The playback device \"%s\" is "
+                                "already in use. Please stop the"
+                                " application using it and "
+                                "run JACK again",
+                                fArgs.playback_pcm_name );
+                    destroy();
+                    return;
+
+                case EPERM:
+                    jack_error( "you do not have permission to open "
+                                "the audio device \"%s\" for playback",
+                                fArgs.playback_pcm_name );
+                    destroy();
+                    return;
+                }
 
-                device_no = -1;
+            fDriver->playback.handle = NULL;
+            }
 
-                for( device_no = 0; device_no < hwinfo.pcmdevs; ++device_no )
-                    {
-                    snprintf( device_id.str,
-                              sizeof( device_id.str ),
-                              "%s,%d",
-                              card_id.str,
-                              device_no );
-
-                    snd_ctl_pcm_info( handle,
-                                      device_no,
-                                      &pcminfo );
-                    has_capture = pcminfo.flags & SND_PCM_INFO_CAPTURE;
-                    has_playback = pcminfo.flags & SND_PCM_INFO_PLAYBACK;
-
-                    if( has_capture && has_playback )
-                        {
-                        snprintf( description,
-                                  sizeof( description ),
-                                  "%s (duplex)",
-                                  pcminfo.name );
-                        }
-                    else if( has_capture )
-                        {
-                        snprintf( description,
-                                  sizeof( description ),
-                                  "%s (capture)",
-                                  pcminfo.name );
-                        }
-                    else if( has_playback )
-                        {
-                        snprintf( description,
-                                  sizeof( description ),
-                                  "%s (playback)",
-                                  pcminfo.name );
-                        }
-                    else
-                        {
-                        continue;
-                        }
+        if( fDriver->playback.handle )
+            {
+            snd_pcm_nonblock_mode( fDriver->playback.handle,
+                                   0 );
+            }
+        else
+            {
 
-                    if( !jack_constraint_add_enum( &constraint_ptr,
-                                                   &array_size,
-                                                   &device_id,
-                                                   description ) )
-                        goto fail;
-                    }
+            /* they asked for playback, but we can't do it */
+
+            jack_error( "io-audio: Cannot open PCM device %s for "
+                        "playback. Falling back to capture-only"
+                        " mode",
+                        name );
+            fArgs.playback = false;
+            }
+
+        }
 
-                snd_ctl_close( handle );
+    if( fArgs.capture )
+        {
+        err = snd_pcm_open_name( &fDriver->capture.handle,
+                                 fArgs.capture_pcm_name,
+                                 SND_PCM_OPEN_CAPTURE | SND_PCM_OPEN_NONBLOCK );
+        if( err < 0 )
+            {
+            switch( errno )
+                {
+                case EBUSY:
+                    jack_error( "\n\nATTENTION: The capture (recording) device \"%s\" is "
+                                "already in use. Please stop the"
+                                " application using it and "
+                                "run JACK again",
+                                fArgs.capture_pcm_name );
+                    destroy();
+                    return;
+
+                case EPERM:
+                    jack_error( "you do not have permission to open "
+                                "the audio device \"%s\" for capture",
+                                fArgs.capture_pcm_name );
+                    destroy();
+                    return;
                 }
+
+            fDriver->capture.handle = NULL;
             }
 
-        return constraint_ptr;
-        fail: jack_constraint_free( constraint_ptr );
-        return NULL;
+        if( fDriver->capture.handle )
+            {
+            snd_pcm_nonblock_mode( fDriver->capture.handle,
+                                   0 );
+            }
+        else
+            {
+
+            /* they asked for capture, but we can't do it */
+
+            jack_error( "io-audio: Cannot open PCM device %s for "
+                        "capture. Falling back to playback-only"
+                        " mode",
+                        name );
+
+            fArgs.capture = false;
+            }
+        }
+
+    if( fDriver->playback.handle == NULL && fDriver->capture.handle == NULL )
+        {
+        /* can't do anything */
+        destroy();
+        return;
+        }
+
+    err = set_parameters();
+    if( 0 != err )
+        {
+        destroy();
+        return;
+        }
+
+    fDriver->capture_and_playback_not_synced = false;
+
+    if( fDriver->capture.handle && fDriver->playback.handle )
+        {
+        if( snd_pcm_link( fDriver->playback.handle,
+                          fDriver->capture.handle ) != 0 )
+            {
+            fDriver->capture_and_playback_not_synced = true;
+            }
+        }
+
+    fDriver->client = client;
     }
 
-    static int dither_opt(
-        char c,
-        DitherAlgorithm* dither )
+    void JackIoAudioDriver::destroy()
     {
-        switch( c )
-            {
-            case '-':
-                case 'n':
-                *dither = None;
-                break;
+//    JSList *node;
+
+    //if (ffDriver->midi)
+    //        (fDriver->midi->destroy)(fDriver->midi);
+
+//    for( node = fDriver->clock_sync_listeners; node;
+//        node = jack_slist_next( node ) )
+//        {
+//        free( node->data );
+//        }
+//    jack_slist_free( fDriver->clock_sync_listeners );
+
+//        if (fDriver->ctl_handle)
+//            {
+//            snd_ctl_close(fDriver->ctl_handle);
+//            fDriver->ctl_handle = 0;
+//            }
+
+    if( fDriver->capture.handle )
+        {
+        snd_pcm_close( fDriver->capture.handle );
+        fDriver->capture.handle = 0;
+        }
+
+    if( fDriver->playback.handle )
+        {
+        snd_pcm_close( fDriver->playback.handle );
+        fDriver->capture.handle = 0;
+        }
+
+    if( fDriver->hw )
+        {
+        fDriver->hw->release();
+        delete fDriver->hw;
+        fDriver->hw = 0;
+        }
+//        free(fDriver->ioaudio_name_playback);
+//        free(fDriver->ioaudio_name_capture);
+//        free(fDriver->ioaudio_driver);
+
+    release_channel_dependent_memory();
+//    free( fDriver );
+    delete fDriver;
+    fDriver = NULL;
+    }
 
-            case 'r':
-                *dither = Rectangular;
-                break;
+//    int JackIoAudioDriver::generic_hardware()
+//    {
+//    jack_hardware_t *hw;
+//
+//    hw = (jack_hardware_t *)malloc( sizeof(jack_hardware_t) );
+//
+//    hw->capabilities = 0;
+//    hw->input_monitor_mask = 0;
+//
+//    hw->set_input_monitor_mask = generic_set_input_monitor_mask;
+//    hw->change_sample_clock = generic_change_sample_clock;
+//    hw->release = generic_release;
+//
+//    fDriver->hw = hw;
+//
+//    return 0;
+//    }
 
-            case 's':
-                *dither = Shaped;
-                break;
+    int JackIoAudioDriver::get_channel_addresses(
+        size_t *capture_avail,
+        size_t *playback_avail,
+        size_t *capture_offset,
+        size_t *playback_offset )
+    {
+    int chn;
 
-            case 't':
-                *dither = Triangular;
-                break;
+    if( capture_avail )
+        {
+        ssize_t samp_bytes = fDriver->capture.sample_bytes();
+        ssize_t frame_bytes = fDriver->capture.frame_bytes();
+        for( chn = 0; chn < fDriver->capture.setup.format.voices; chn++ )
+            {
+            fDriver->capture.voices[chn].addr = (char*)fDriver->capture.buffer
+                + chn * samp_bytes;
+            fDriver->capture.voices[chn].interleave_skip = frame_bytes;
+            }
+        }
+
+    if( playback_avail )
+        {
+        ssize_t samp_bytes = fDriver->playback.sample_bytes();
+        ssize_t frame_bytes = fDriver->playback.frame_bytes();
+        for( chn = 0; chn < fDriver->playback.setup.format.voices; chn++ )
+            {
+            fDriver->playback.voices[chn].addr = (char*)fDriver->playback.buffer
+                + chn * samp_bytes;
+            fDriver->playback.voices[chn].interleave_skip = frame_bytes;
 
-            default:
-                fprintf( stderr,
-                         "io-audio driver: illegal dithering mode %c\n",
-                         c );
-                return -1;
             }
+        }
+
+    return 0;
+    }
+
+    int JackIoAudioDriver::hw_specific()
+    {
+    int err;
+
+    fDriver->hw = new Jack::generic_hardware;
+    if( NULL == fDriver->hw )
+        {
+        return -ENOMEM;
+        }
+
+    if( fDriver->hw->capabilities & Cap_HardwareMonitoring )
+        {
+        fDriver->has_hw_monitoring = true;
+        /* XXX need to ensure that this is really false or
+         * true or whatever*/
+        fDriver->do_hw_monitoring = fArgs.hw_monitoring;
+        }
+    else
+        {
+        fDriver->has_hw_monitoring = false;
+        fDriver->do_hw_monitoring = false;
+        }
+
+    if( fDriver->hw->capabilities & Cap_ClockLockReporting )
+        {
+        fDriver->has_clock_sync_reporting = true;
+        }
+    else
+        {
+        fDriver->has_clock_sync_reporting = false;
+        }
+
+    if( fDriver->hw->capabilities & Cap_HardwareMetering )
+        {
+        fDriver->has_hw_metering = true;
+        fDriver->do_hw_metering = fArgs.hw_metering;
+        }
+    else
+        {
+        fDriver->has_hw_metering = false;
+        fDriver->do_hw_metering = false;
+        }
+
+    return 0;
+    }
+
+    void JackIoAudioDriver::mark_channel_done(
+        int chn )
+    {
+    bitset_remove( fDriver->channels_not_done,
+                   chn );
+    fDriver->playback.voices[chn].silent = 0;
+    }
+
+    int JackIoAudioDriver::read(
+        jack_nframes_t nframes )
+    {
+    ssize_t contiguous;
+    ssize_t nread;
+    size_t offset = 0;
+    jack_nframes_t orig_nframes;
+    int err;
+
+    if( nframes > fArgs.frames_per_interrupt )
+        {
+        return -1;
+        }
+
+    //if (fDriver->midi)
+    //    (fDriver->midi->read)(fDriver->midi, nframes);
+
+    if( !fDriver->capture.handle )
+        {
         return 0;
+        }
+
+    nread = 0;
+    contiguous = 0;
+    orig_nframes = nframes;
+
+    while( nframes )
+        {
+
+        contiguous = nframes;
+
+        if( get_channel_addresses( (size_t *)&contiguous,
+                                   (size_t *)0,
+                                   &offset,
+                                   0 ) < 0 )
+            {
+            return -1;
+            }
+
+        err = snd_pcm_read( fDriver->capture.handle,
+                            fDriver->capture.buffer,
+                            fDriver->capture.frag_bytes() );
+        if( err < 0 )
+            {
+            jack_error( "io-audio: could not complete read of %"
+                        PRIu32 " frames: error = %d",
+                        contiguous,
+                        err );
+            return -1;
+            }
+
+        ReadInputAux( orig_nframes,
+                      contiguous,
+                      nread );
+
+        nframes -= contiguous;
+        nread += contiguous;
+        }
+
+    return 0;
     }
 
-    SERVER_EXPORT const jack_driver_desc_t* driver_get_descriptor()
+    void JackIoAudioDriver::release_channel_dependent_memory()
     {
-        jack_driver_desc_t * desc;
-        jack_driver_desc_filler_t filler;
-        jack_driver_param_value_t value;
-
-        desc =
-            jack_driver_descriptor_construct( "io-audio",
-                                              JackDriverMaster,
-                                              "QNX io-audio API based audio backend",
-                                              &filler );
-
-        strcpy( value.str,
-                "pcmPreferredp" );
-#ifdef __ANDROID__
-        jack_driver_descriptor_add_parameter(desc, &filler, "device", 'd', JackDriverParamString, &value, NULL, "io-audio device name", NULL);
-#else
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "device",
-                                              'd',
-                                              JackDriverParamString,
-                                              &value,
-                                              enum_ioaudio_devices(),
-                                              "io-audio device name",
-                                              NULL );
-#endif
+    bitset_destroy( &fDriver->channels_done );
+    bitset_destroy( &fDriver->channels_not_done );
+
+    delete[] fDriver->capture.voices;
+    delete[] fDriver->playback.voices;
 
-        strcpy( value.str,
-                "none" );
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "capture",
-                                              'C',
-                                              JackDriverParamString,
-                                              &value,
-                                              NULL,
-                                              "Provide capture ports.  Optionally set device",
-                                              NULL );
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "playback",
-                                              'P',
-                                              JackDriverParamString,
-                                              &value,
-                                              NULL,
-                                              "Provide playback ports.  Optionally set device",
-                                              NULL );
-
-        value.ui = 48000U;
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "rate",
-                                              'r',
-                                              JackDriverParamUInt,
-                                              &value,
-                                              NULL,
-                                              "Sample rate",
-                                              NULL );
-
-        value.ui = 1024U;
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "period",
-                                              'p',
-                                              JackDriverParamUInt,
-                                              &value,
-                                              NULL,
-                                              "Frames per period",
-                                              NULL );
-
-        value.ui = 2U;
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "nperiods",
-                                              'n',
-                                              JackDriverParamUInt,
-                                              &value,
-                                              NULL,
-                                              "Number of periods of playback latency",
-                                              NULL );
-
-        value.i = 0;
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "hwmon",
-                                              'H',
-                                              JackDriverParamBool,
-                                              &value,
-                                              NULL,
-                                              "Hardware monitoring, if available",
-                                              NULL );
-
-        value.i = 0;
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "hwmeter",
-                                              'M',
-                                              JackDriverParamBool,
-                                              &value,
-                                              NULL,
-                                              "Hardware metering, if available",
-                                              NULL );
-
-        value.i = 1;
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "duplex",
-                                              'D',
-                                              JackDriverParamBool,
-                                              &value,
-                                              NULL,
-                                              "Provide both capture and playback ports",
-                                              NULL );
-
-        value.i = 0;
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "softmode",
-                                              's',
-                                              JackDriverParamBool,
-                                              &value,
-                                              NULL,
-                                              "Soft-mode, no xrun handling",
-                                              NULL );
-
-        value.i = 0;
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "monitor",
-                                              'm',
-                                              JackDriverParamBool,
-                                              &value,
-                                              NULL,
-                                              "Provide monitor ports for the output",
-                                              NULL );
-
-        value.c = 'n';
-        jack_driver_descriptor_add_parameter(
-                                              desc,
-                                              &filler,
-                                              "dither",
-                                              'z',
-                                              JackDriverParamChar,
-                                              &value,
-                                              jack_constraint_compose_enum_char(
-                                                                                 JACK_CONSTRAINT_FLAG_STRICT
-                                                                                     | JACK_CONSTRAINT_FLAG_FAKE_VALUE,
-                                                                                 dither_constraint_descr_array ),
-                                              "Dithering mode",
-                                              NULL );
-
-        value.ui = 0;
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "inchannels",
-                                              'i',
-                                              JackDriverParamUInt,
-                                              &value,
-                                              NULL,
-                                              "Number of capture channels (defaults to hardware max)",
-                                              NULL );
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "outchannels",
-                                              'o',
-                                              JackDriverParamUInt,
-                                              &value,
-                                              NULL,
-                                              "Number of playback channels (defaults to hardware max)",
-                                              NULL );
-
-        value.i = FALSE;
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "shorts",
-                                              'S',
-                                              JackDriverParamBool,
-                                              &value,
-                                              NULL,
-                                              "Try 16-bit samples before 32-bit",
-                                              NULL );
-
-        value.ui = 0;
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "input-latency",
-                                              'I',
-                                              JackDriverParamUInt,
-                                              &value,
-                                              NULL,
-                                              "Extra input latency (frames)",
-                                              NULL );
-        jack_driver_descriptor_add_parameter( desc,
-                                              &filler,
-                                              "output-latency",
-                                              'O',
-                                              JackDriverParamUInt,
-                                              &value,
-                                              NULL,
-                                              "Extra output latency (frames)",
-                                              NULL );
-
-        strcpy( value.str,
-                "none" );
-        jack_driver_descriptor_add_parameter(
-                                              desc,
-                                              &filler,
-                                              "midi-driver",
-                                              'X',
-                                              JackDriverParamString,
-                                              &value,
-                                              jack_constraint_compose_enum_str(
-                                                                                JACK_CONSTRAINT_FLAG_STRICT
-                                                                                    | JACK_CONSTRAINT_FLAG_FAKE_VALUE,
-                                                                                midi_constraint_descr_array ),
-                                              "io-audio MIDI driver",
-                                              NULL );
-
-        return desc;
+//    if( fDriver->playback.addr )
+//        {
+//        free( fDriver->playback.addr );
+//        fDriver->playback.addr = 0;
+//        }
+//
+//    if( fDriver->capture.addr )
+//        {
+//        free( fDriver->capture.addr );
+//        fDriver->capture.addr = 0;
+//        }
+//
+//    if( fDriver->playback.interleave_skip )
+//        {
+//        free( fDriver->playback.interleave_skip );
+//        fDriver->playback.interleave_skip = NULL;
+//        }
+//
+//    if( fDriver->capture.interleave_skip )
+//        {
+//        free( fDriver->capture.interleave_skip );
+//        fDriver->capture.interleave_skip = NULL;
+//        }
+//
+//    if( fDriver->silent )
+//        {
+//        free( fDriver->silent );
+//        fDriver->silent = 0;
+//        }
+//
+//    if( fDriver->dither_state )
+//        {
+//        free( fDriver->dither_state );
+//        fDriver->dither_state = 0;
+//        }
     }
 
-    static Jack::JackIoAudioDriver* g_ioaudio_driver;
+    int JackIoAudioDriver::reset_parameters()
+    {
+    /* XXX unregister old ports ? */
+    release_channel_dependent_memory();
+    return set_parameters();
+    }
 
-    SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize(
-        Jack::JackLockedEngine* engine,
-        Jack::JackSynchro* table,
-        const JSList* params )
+    int JackIoAudioDriver::restart()
     {
-        ioaudio_driver_args_t args;
-        args.srate = 48000;
-        args.frames_per_interrupt = 1024;
-        args.user_nperiods = 2;
-        args.playback_pcm_name = "pcmPreferredp";
-        args.capture_pcm_name = "pcmPreferredc";
-        args.hw_monitoring = FALSE;
-        args.hw_metering = FALSE;
-        args.capture = FALSE;
-        args.playback = FALSE;
-        args.soft_mode = FALSE;
-        args.monitor = FALSE;
-        args.dither = None;
-        args.user_capture_nchnls = 0;
-        args.user_playback_nchnls = 0;
-        args.shorts_first = FALSE;
-        args.systemic_input_latency = 0;
-        args.systemic_output_latency = 0;
-        args.midi_driver = "none";
-
-        const JSList * node;
-        const jack_driver_param_t * param;
-
-        for( node = params; node; node = jack_slist_next( node ) )
-            {
-            param = (const jack_driver_param_t *)node->data;
-
-            switch( param->character )
+    int res;
+
+    fDriver->xrun_recovery = 1;
+    if( ( res = Stop() ) == 0 )
+        {
+        res = Start();
+        }
+    fDriver->xrun_recovery = 0;
+
+    //if (res && fDriver->midi)
+    //    (fDriver->midi->stop)(fDriver->midi);
+
+    return res;
+    }
+
+    int JackIoAudioDriver::set_parameters()
+    {
+    ssize_t p_period_size = 0;
+    size_t c_period_size = 0;
+    int chn;
+    unsigned int pr = 0;
+    unsigned int cr = 0;
+    int err;
+
+    fDriver->frame_rate = fArgs.srate;
+//        fArgs.frames_per_interrupt = fArgs.frames_per_interrupt;
+//        fArgs.user_nperiods = fArgs.user_nperiods;
+
+    jack_log( "configuring for %" PRIu32 "Hz, period = %"
+              PRIu32 " frames (%.1f ms), buffer = %" PRIu32 " periods",
+              fArgs.srate,
+              fArgs.frames_per_interrupt,
+              ( ( (float)fArgs.frames_per_interrupt / (float)fArgs.srate )
+                  * 1000.0f ),
+              fArgs.user_nperiods );
+
+    if( fDriver->capture.handle )
+        {
+        memset( &fDriver->capture.params,
+                0,
+                sizeof(snd_pcm_channel_params_t) );
+        fDriver->capture.params.channel = SND_PCM_CHANNEL_CAPTURE;
+        if( configure_stream( fArgs.capture_pcm_name,
+                              "capture",
+                              fDriver->capture.handle,
+                              &fDriver->capture.params,
+                              &fDriver->capture.nperiods ) )
+            {
+            jack_error( "io-audio: cannot configure capture channel" );
+            return -1;
+            }
+        fDriver->capture.setup.channel = SND_PCM_CHANNEL_CAPTURE;
+        snd_pcm_channel_setup( fDriver->capture.handle,
+                               &fDriver->capture.setup );
+        cr = fDriver->capture.setup.format.rate;
+
+        /* check the fragment size, since thats non-negotiable */
+        c_period_size = fDriver->capture.setup.buf.block.frag_size;
+
+        if( c_period_size != fArgs.frames_per_interrupt )
+            {
+            jack_error( "ioaudio_pcm: requested an interrupt every %"
+                        PRIu32
+                        " frames but got %uc frames for capture",
+                        fArgs.frames_per_interrupt,
+                        p_period_size );
+            return -1;
+            }
+
+        /* check the sample format */
+        switch( fDriver->capture.setup.format.format )
+            {
+            case SND_PCM_SFMT_FLOAT_LE:
+            case SND_PCM_SFMT_S32_LE:
+            case SND_PCM_SFMT_S24_LE:
+            case SND_PCM_SFMT_S24_BE:
+            case SND_PCM_SFMT_S16_LE:
+            case SND_PCM_SFMT_S32_BE:
+            case SND_PCM_SFMT_S16_BE:
+                break;
+
+            default:
+                jack_error( "programming error: unhandled format "
+                            "type for capture" );
+                return -1;
+            }
+
+        if( fDriver->capture.setup.format.interleave )
+            {
+            if( ( err = snd_pcm_mmap( fDriver->capture.handle,
+                                      SND_PCM_CHANNEL_CAPTURE,
+                                      &fDriver->capture.mmap,
+                                      &fDriver->capture.buffer ) ) < 0 )
                 {
+                jack_error( "io-audio: %s: mmap areas info error",
+                            fArgs.capture_pcm_name );
+                return -1;
+                }
+            }
+        }
+
+    if( fDriver->playback.handle )
+        {
+        memset( &fDriver->playback.params,
+                0,
+                sizeof(snd_pcm_channel_params_t) );
+        fDriver->playback.params.channel = SND_PCM_CHANNEL_PLAYBACK;
+
+        if( configure_stream( fArgs.playback_pcm_name,
+                              "playback",
+                              fDriver->playback.handle,
+                              &fDriver->playback.params,
+                              &fDriver->playback.nperiods ) )
+            {
+            jack_error( "io-audio: cannot configure playback channel" );
+            return -1;
+            }
 
-                case 'C':
-                    args.capture = TRUE;
-                    if( strcmp( param->value.str,
-                                "none" ) != 0 )
-                        {
-                        args.capture_pcm_name = strdup( param->value.str );
-                        jack_log( "capture device %s",
-                                  args.capture_pcm_name );
-                        }
-                    break;
+        fDriver->playback.setup.channel = SND_PCM_CHANNEL_PLAYBACK;
+        snd_pcm_channel_setup( fDriver->playback.handle,
+                               &fDriver->playback.setup );
+        pr = fDriver->playback.setup.format.rate;
 
-                case 'P':
-                    args.playback = TRUE;
-                    if( strcmp( param->value.str,
-                                "none" ) != 0 )
-                        {
-                        args.playback_pcm_name = strdup( param->value.str );
-                        jack_log( "playback device %s",
-                                  args.playback_pcm_name );
-                        }
-                    break;
+        /* check the fragment size, since thats non-negotiable */
+        p_period_size = fDriver->playback.setup.buf.block.frag_size;
 
-                case 'D':
-                    args.playback = TRUE;
-                    args.capture = TRUE;
-                    break;
+        if( p_period_size != fDriver->playback.frag_bytes() )
+            {
+            jack_error( "ioaudio_pcm: requested an interrupt every %"
+                        PRIu32
+                        " frames but got %u frames for playback",
+                        fArgs.frames_per_interrupt,
+                        p_period_size );
+            return -1;
+            }
 
-                case 'd':
-                    if( strcmp( param->value.str,
-                                "none" ) != 0 )
-                        {
-                        args.playback_pcm_name = strdup( param->value.str );
-                        args.capture_pcm_name = strdup( param->value.str );
-                        jack_log( "playback device %s",
-                                  args.playback_pcm_name );
-                        jack_log( "capture device %s",
-                                  args.capture_pcm_name );
-                        }
-                    break;
+        /* check the sample format */
+        switch( fDriver->playback.setup.format.format )
+            {
+            case SND_PCM_SFMT_FLOAT_LE:
+            case SND_PCM_SFMT_S32_LE:
+            case SND_PCM_SFMT_S24_LE:
+            case SND_PCM_SFMT_S24_BE:
+            case SND_PCM_SFMT_S16_LE:
+            case SND_PCM_SFMT_S32_BE:
+            case SND_PCM_SFMT_S16_BE:
+                break;
 
-                case 'H':
-                    args.hw_monitoring = param->value.i;
-                    break;
+            default:
+                jack_error( "programming error: unhandled format "
+                            "type for playback" );
+                return -1;
+            }
 
-                case 'm':
-                    args.monitor = param->value.i;
-                    break;
+        fDriver->playback.buffer = malloc( fArgs.user_nperiods
+            * p_period_size );
+        if( fDriver->playback.setup.format.interleave )
+            {
+            fDriver->interleave_unit = fDriver->playback.sample_bytes();
+            }
+        else
+            {
+            fDriver->interleave_unit = 0; /* NOT USED */
+            }
+        }
 
-                case 'M':
-                    args.hw_metering = param->value.i;
-                    break;
+    /* check the rate, since thats rather important */
+    if( fDriver->capture.handle && fDriver->playback.handle )
+        {
+        if( cr != pr )
+            {
+            jack_error( "playback and capture sample rates do "
+                        "not match (%d vs. %d)",
+                        pr,
+                        cr );
+            }
 
-                case 'r':
-                    args.srate = param->value.ui;
-                    jack_log( "apparent rate = %d",
-                              args.srate );
-                    break;
+        /* only change if *both* capture and playback rates
+         * don't match requested certain hardware actually
+         * still works properly in full-duplex with slightly
+         * different rate values between adc and dac
+         */
+        if( cr != fDriver->frame_rate && pr != fDriver->frame_rate )
+            {
+            jack_error( "sample rate in use (%d Hz) does not "
+                        "match requested rate (%d Hz)",
+                        cr,
+                        fDriver->frame_rate );
+            fDriver->frame_rate = cr;
+            }
 
-                case 'p':
-                    args.frames_per_interrupt = param->value.ui;
-                    jack_log( "frames per period = %d",
-                              args.frames_per_interrupt );
-                    break;
+        }
+    else if( fDriver->capture.handle && cr != fDriver->frame_rate )
+        {
+        jack_error( "capture sample rate in use (%d Hz) does not "
+                    "match requested rate (%d Hz)",
+                    cr,
+                    fDriver->frame_rate );
+        fDriver->frame_rate = cr;
+        }
+    else if( fDriver->playback.handle && pr != fDriver->frame_rate )
+        {
+        jack_error( "playback sample rate in use (%d Hz) does not "
+                    "match requested rate (%d Hz)",
+                    pr,
+                    fDriver->frame_rate );
+        fDriver->frame_rate = pr;
+        }
+
+    fDriver->max_nchannels = std::max( fDriver->playback.setup.format.voices,
+                                       fDriver->capture.setup.format.voices );
+    fDriver->user_nchannels = std::min( fDriver->playback.setup.format.voices,
+                                        fDriver->capture.setup.format.voices );
+
+    setup_io_function_pointers();
+
+    /* Allocate and initialize structures that rely on the
+     channels counts.
+
+     Set up the bit pattern that is used to record which
+     channels require action on every cycle. any bits that are
+     not set after the engine's process() call indicate channels
+     that potentially need to be silenced.
+     */
+
+    bitset_create( &fDriver->channels_done,
+                   fDriver->max_nchannels );
+    bitset_create( &fDriver->channels_not_done,
+                   fDriver->max_nchannels );
+
+    if( fDriver->playback.handle )
+        {
+        fDriver->playback.voices = new Voice[fDriver->max_nchannels];
+//        fDriver->playback.addr = (char **)calloc( fDriver->max_nchannels,
+//                                                  sizeof(char *) );
+
+//        fDriver->playback.interleave_skip =
+//            (unsigned long *)calloc( fDriver->max_nchannels,
+//                                     sizeof(unsigned long) );
+
+//        fDriver->silent = (unsigned long *)calloc( fDriver->max_nchannels,
+//                                                   sizeof(unsigned long) );
+
+        for( chn = 0; chn < fDriver->playback.setup.format.voices; chn++ )
+            {
+            bitset_add( fDriver->channels_done,
+                        chn );
+            }
 
-                case 'n':
-                    args.user_nperiods = param->value.ui;
-                    if( args.user_nperiods < 2 )
-                        { /* enforce minimum value */
-                        args.user_nperiods = 2;
-                        }
-                    break;
+//        fDriver->dither_state =
+//            (dither_state_t *)calloc( fDriver->max_nchannels,
+//                                      sizeof(dither_state_t) );
+        }
 
-                case 's':
-                    args.soft_mode = param->value.i;
-                    break;
+    if( fDriver->capture.handle )
+        {
+        fDriver->capture.voices = new Voice[fDriver->max_nchannels];
+//        fDriver->capture.addr = (char **)calloc( fDriver->max_nchannels,
+//                                                 sizeof(char *) );
 
-                case 'z':
-                    if( dither_opt( param->value.c,
-                                    &args.dither ) )
+//        fDriver->capture.interleave_skip =
+//            (unsigned long *)calloc( fDriver->max_nchannels,
+//                                     sizeof(unsigned long) );
+        }
+
+//    fDriver->clock_sync_data =
+//        (ClockSyncStatus *)calloc( fDriver->max_nchannels,
+//                                   sizeof(ClockSyncStatus) );
+
+    float period_usecs = ( ( (float)fArgs.frames_per_interrupt )
+        / fDriver->frame_rate ) * 1000000.0f;
+
+    fDriver->poll_timeout_msecs = (int)floor( 1.5f * period_usecs / 1000.0f );
+
+    return 0;
+    }
+
+    void JackIoAudioDriver::setup_io_function_pointers()
+    {
+    if( fDriver->playback.handle )
+        {
+        if( SND_PCM_FMT_FLOAT_LE == fDriver->playback.setup.format.format )
+            {
+            fDriver->playback.write = sample_move_dS_floatLE;
+            }
+        else
+            {
+            ssize_t bytes = fDriver->playback.sample_bytes();
+            switch( bytes )
+                {
+                case 2:
+                    switch( fArgs.dither )
                         {
-                        return NULL;
+                        case Rectangular:
+                            jack_log( "Rectangular dithering at 16 bits" );
+                            fDriver->playback.write =
+                                fDriver->quirk_bswap ?
+                                    sample_move_dither_rect_d16_sSs :
+                                    sample_move_dither_rect_d16_sS;
+                            break;
+
+                        case Triangular:
+                            jack_log( "Triangular dithering at 16 bits" );
+                            fDriver->playback.write =
+                                fDriver->quirk_bswap ?
+                                    sample_move_dither_tri_d16_sSs :
+                                    sample_move_dither_tri_d16_sS;
+                            break;
+
+                        case Shaped:
+                            jack_log( "Noise-shaped dithering at 16 bits" );
+                            fDriver->playback.write =
+                                fDriver->quirk_bswap ?
+                                    sample_move_dither_shaped_d16_sSs :
+                                    sample_move_dither_shaped_d16_sS;
+                            break;
+
+                        default:
+                            fDriver->playback.write =
+                                fDriver->quirk_bswap ?
+                                    sample_move_d16_sSs : sample_move_d16_sS;
+                            break;
                         }
                     break;
 
-                case 'i':
-                    args.user_capture_nchnls = param->value.ui;
-                    break;
+                case 3: /* NO DITHER */
+                    fDriver->playback.write =
+                        fDriver->quirk_bswap ?
+                            sample_move_d24_sSs : sample_move_d24_sS;
 
-                case 'o':
-                    args.user_playback_nchnls = param->value.ui;
                     break;
 
-                case 'S':
-                    args.shorts_first = param->value.i;
+                case 4: /* NO DITHER */
+                    fDriver->playback.write =
+                        fDriver->quirk_bswap ?
+                            sample_move_d32u24_sSs : sample_move_d32u24_sS;
                     break;
 
-                case 'I':
-                    args.systemic_input_latency = param->value.ui;
-                    break;
+                default:
+                    jack_error( "impossible sample width (%d) discovered!",
+                                bytes );
+                    exit( 1 );
+                }
+            }
+        }
 
-                case 'O':
-                    args.systemic_output_latency = param->value.ui;
+    if( fDriver->capture.handle )
+        {
+        if( SND_PCM_FMT_FLOAT_LE == fDriver->capture.setup.format.format )
+            {
+            fDriver->capture.read = sample_move_floatLE_sSs;
+            }
+        else
+            {
+            ssize_t bytes = fDriver->capture.sample_bytes();
+            switch( bytes )
+                {
+                case 2:
+                    fDriver->capture.read =
+                        fDriver->quirk_bswap ?
+                            sample_move_dS_s16s : sample_move_dS_s16;
                     break;
-
-                case 'X':
-                    args.midi_driver = strdup( param->value.str );
+                case 3:
+                    fDriver->capture.read =
+                        fDriver->quirk_bswap ?
+                            sample_move_dS_s24s : sample_move_dS_s24;
+                    break;
+                case 4:
+                    fDriver->capture.read =
+                        fDriver->quirk_bswap ?
+                            sample_move_dS_s32u24s : sample_move_dS_s32u24;
                     break;
                 }
             }
+        }
+    }
 
-        /* duplex is the default */
-        if( !args.capture && !args.playback )
+    void JackIoAudioDriver::silence_on_channel(
+        int chn,
+        jack_nframes_t nframes )
+    {
+    silence_on_channel_no_mark( chn,
+                                nframes );
+    mark_channel_done( chn );
+    }
+
+    void JackIoAudioDriver::silence_on_channel_no_mark(
+        int chn,
+        jack_nframes_t nframes )
+    {
+    if( fDriver->playback.setup.format.interleave )
+        {
+        memset_interleave( fDriver->playback.voices[chn].addr,
+                           0,
+                           fDriver->playback.sample_bytes() * nframes,
+                           fDriver->interleave_unit,
+                           fDriver->playback.voices[chn].interleave_skip );
+        }
+    else
+        {
+        memset( fDriver->playback.voices[chn].addr,
+                0,
+                fDriver->playback.sample_bytes() * nframes );
+        }
+    }
+
+    void JackIoAudioDriver::silence_untouched_channels(
+        jack_nframes_t nframes )
+    {
+    int chn;
+    jack_nframes_t buffer_frames = fArgs.frames_per_interrupt
+        * fDriver->playback.nperiods;
+
+    for( chn = 0; chn < fDriver->playback.setup.format.voices; chn++ )
+        {
+        if( bitset_contains( fDriver->channels_not_done,
+                             chn ) )
+            {
+            if( fDriver->playback.voices[chn].silent < buffer_frames )
+                {
+                silence_on_channel_no_mark( chn,
+                                            nframes );
+                fDriver->playback.voices[chn].silent += nframes;
+                }
+            }
+        }
+    }
+
+    int JackIoAudioDriver::start()
+    {
+    int err;
+    size_t poffset, pavail;
+    int chn;
+
+    fDriver->poll_last = 0;
+    fDriver->poll_next = 0;
+
+    if( fDriver->playback.handle )
+        {
+        if( ( err = snd_pcm_playback_prepare( fDriver->playback.handle ) ) < 0 )
             {
-            args.capture = TRUE;
-            args.playback = TRUE;
+            jack_error( "io-audio: prepare error for playback on "
+                        "\"%s\" (%s)",
+                        fArgs.playback_pcm_name,
+                        snd_strerror( err ) );
+            return -1;
             }
+        }
 
-        g_ioaudio_driver = new Jack::JackIoAudioDriver( "system",
-                                                        "ioaudio_pcm",
-                                                        engine,
-                                                        table );
-        Jack::JackDriverClientInterface* threaded_driver =
-            new Jack::JackThreadedDriver( g_ioaudio_driver );
-        // Special open for io-audio driver...
-        if( g_ioaudio_driver->Open( args ) == 0 )
+    if( ( fDriver->capture.handle && fDriver->capture_and_playback_not_synced )
+        || !fDriver->playback.handle )
+        {
+        if( ( err = snd_pcm_capture_prepare( fDriver->capture.handle ) ) < 0 )
             {
-            return threaded_driver;
+            jack_error( "io-audio: prepare error for capture on \"%s\""
+                        " (%s)",
+                        fArgs.capture_pcm_name,
+                        snd_strerror( err ) );
+            return -1;
             }
-        else
+        }
+
+    if( fDriver->do_hw_monitoring )
+        {
+        fDriver->hw->set_input_monitor_mask( fDriver->input_monitor_mask );
+        }
+
+    if( fDriver->playback.handle )
+        {
+        /* fill playback buffer with zeroes, and mark
+         all fragments as having data.
+         */
+
+        pavail = fArgs.frames_per_interrupt * fDriver->playback.nperiods;
+
+        if( pavail != fArgs.frames_per_interrupt * fDriver->playback.nperiods )
             {
-            delete threaded_driver; // Delete the decorated driver
-            return NULL;
+            jack_error( "io-audio: full buffer not available at start" );
+            return -1;
             }
+
+        if( get_channel_addresses( 0,
+                                   &pavail,
+                                   0,
+                                   &poffset ) )
+            {
+            return -1;
+            }
+
+        for( chn = 0; chn < fDriver->playback.setup.format.voices; chn++ )
+            {
+            silence_on_channel( chn,
+                                fArgs.user_nperiods
+                                    * fArgs.frames_per_interrupt );
+            }
+
+        snd_pcm_write( fDriver->playback.handle,
+                       fDriver->playback.buffer,
+                       fDriver->playback.frag_bytes() * fArgs.user_nperiods );
+
+        }
+
+    return 0;
     }
 
-// Code to be used in ioaudio_driver.c
+    int JackIoAudioDriver::stop()
+    {
+    int err;
 
-    void ReadInput(
-        jack_nframes_t orig_nframes,
-        ssize_t contiguous,
-        ssize_t nread )
+    /* silence all capture port buffers, because we might
+     be entering offline mode.
+     */
+    ClearOutputAux();
+
+    if( fDriver->playback.handle )
+        {
+        err = snd_pcm_playback_flush( fDriver->playback.handle );
+        if( err < 0 )
+            {
+            jack_error( "io-audio: channel flush for playback "
+                        "failed (%s)",
+                        snd_strerror( err ) );
+            return -1;
+            }
+        }
+
+    if( !fDriver->playback.handle || fDriver->capture_and_playback_not_synced )
+        {
+        if( fDriver->capture.handle )
+            {
+            err = snd_pcm_capture_flush( fDriver->capture.handle );
+            if( err < 0 )
+                {
+                jack_error( "io-audio: channel flush for "
+                            "capture failed (%s)",
+                            snd_strerror( err ) );
+                return -1;
+                }
+            }
+        }
+
+    if( fDriver->do_hw_monitoring )
+        {
+        fDriver->hw->set_input_monitor_mask( 0 );
+        }
+
+    //if (fDriver->midi && !fDriver->xrun_recovery)
+    //    (fDriver->midi->stop)(fDriver->midi);
+
+    return 0;
+    }
+
+    jack_nframes_t JackIoAudioDriver::wait(
+        int *status,
+        float *delayed_usecs )
     {
-        g_ioaudio_driver->ReadInputAux( orig_nframes,
-                                        contiguous,
-                                        nread );
+    static int under_gdb = 0;
+    ssize_t avail = 0;
+    ssize_t capture_avail = 0;
+    ssize_t playback_avail = 0;
+    bool xrun_detected = false;
+    bool need_capture;
+    bool need_playback;
+    jack_time_t poll_enter;
+    jack_time_t poll_ret = 0;
+
+    *status = -1;
+    *delayed_usecs = 0;
+
+    need_capture = fDriver->capture.handle ? true : false;
+
+    need_playback = fDriver->playback.handle ? true : false;
+
+    again:
+
+    while( need_playback || need_capture )
+        {
+
+        int poll_result;
+        unsigned short revents;
+
+        if( need_playback )
+            {
+            int fd = snd_pcm_file_descriptor( fDriver->playback.handle,
+                                              SND_PCM_CHANNEL_PLAYBACK );
+
+            fDriver->pfd[Playback].fd = fd;
+            fDriver->pfd[Playback].events = POLLOUT;
+            }
+        else
+            {
+            fDriver->pfd[Playback].fd = -1;
+            }
+
+        if( need_capture )
+            {
+            int fd = snd_pcm_file_descriptor( fDriver->capture.handle,
+                                              SND_PCM_CHANNEL_CAPTURE );
+
+            fDriver->pfd[Capture].fd = fd;
+            fDriver->pfd[Capture].events = POLLIN;
+            }
+        else
+            {
+            fDriver->pfd[Capture].fd = -1;
+            }
+
+        poll_enter = jack_get_microseconds();
+
+        if( poll_enter > fDriver->poll_next )
+            {
+            /*
+             * This processing cycle was delayed past the
+             * next due interrupt!  Do not account this as
+             * a wakeup delay:
+             */
+            fDriver->poll_next = 0;
+            fDriver->poll_late++;
+            }
+
+        poll_result = poll( fDriver->pfd,
+                            SND_PCM_CHANNEL_MAX,
+                            fDriver->poll_timeout_msecs );
+
+        if( poll_result < 0 )
+            {
+
+            if( errno == EINTR )
+                {
+                jack_log( "poll interrupt" );
+                // this happens mostly when run
+                // under gdb, or when exiting due to a signal
+                if( under_gdb )
+                    {
+                    goto again;
+                    }
+                *status = -2;
+                return 0;
+                }
+
+            jack_error( "io-audio: poll call failed (%s)",
+                        strerror( errno ) );
+            *status = -3;
+            return 0;
+
+            }
+
+        poll_ret = jack_get_microseconds();
+
+        // JACK2
+        JackDriver::CycleTakeBeginTime();
+//        SetTimetAux( poll_ret );
+
+        if( need_playback )
+            {
+            snd_pcm_channel_status_t chstatus;
+            chstatus.channel = SND_PCM_CHANNEL_PLAYBACK;
+            snd_pcm_channel_status( fDriver->playback.handle,
+                                    &chstatus );
+
+            revents = fDriver->pfd[Playback].revents;
+
+            if( revents & POLLERR )
+                {
+                xrun_detected = true;
+                }
+
+            if( revents & POLLOUT )
+                {
+                need_playback = 0;
+#ifdef DEBUG_WAKEUP
+                fprintf (stderr, "%" PRIu64
+                    " playback stream ready\n",
+                    poll_ret);
+#endif
+                }
+            }
+
+        if( need_capture )
+            {
+            snd_pcm_channel_status_t chstatus;
+            chstatus.channel = SND_PCM_CHANNEL_CAPTURE;
+            snd_pcm_channel_status( fDriver->playback.handle,
+                                    &chstatus );
+
+            revents = fDriver->pfd[Capture].revents;
+
+            if( revents & POLLERR )
+                {
+                xrun_detected = true;
+                }
+
+            if( revents & POLLIN )
+                {
+                need_capture = 0;
+#ifdef DEBUG_WAKEUP
+                fprintf (stderr, "%" PRIu64
+                    " capture stream ready\n",
+                    poll_ret);
+#endif
+                }
+            }
+
+        if( poll_result == 0 )
+            {
+            jack_error( "io-audio: poll time out, polled for %" PRIu64
+                        " usecs",
+                        poll_ret - poll_enter );
+            *status = -5;
+            return 0;
+            }
+
+        }
+
+    if( fDriver->capture.handle )
+        {
+        capture_avail = fDriver->capture.frag_bytes() / fDriver->capture.frame_bytes();
+        }
+    else
+        {
+        capture_avail = std::numeric_limits < ssize_t > ::max();
+        }
+
+    if( fDriver->playback.handle )
+        {
+        playback_avail = fDriver->playback.frag_bytes() / fDriver->playback.frame_bytes();
+        }
+    else
+        {
+        /* odd, but see min() computation below */
+        playback_avail = std::numeric_limits < ssize_t > ::max();
+        }
+
+    if( xrun_detected )
+        {
+        *status = xrun_recovery( delayed_usecs );
+        return 0;
+        }
+
+    *status = 0;
+//        fDriver->last_wait_ust = poll_ret;
+
+    avail = capture_avail < playback_avail ? capture_avail : playback_avail;
+
+#ifdef DEBUG_WAKEUP
+    fprintf (stderr, "wakeup complete, avail = %lu, pavail = %lu "
+        "cavail = %lu\n",
+        avail, playback_avail, capture_avail);
+#endif
+
+    /* mark all channels not done for now. read/write will change this */
+
+    bitset_copy( fDriver->channels_not_done,
+                 fDriver->channels_done );
+
+    /* constrain the available count to the nearest (round down) number of
+     periods.
+     */
+
+    return avail - ( avail % fArgs.frames_per_interrupt );
     }
-    void MonitorInput()
+
+    int JackIoAudioDriver::xrun_recovery(
+        float *delayed_usecs )
     {
-        g_ioaudio_driver->MonitorInputAux();
+    snd_pcm_channel_status_t status;
+    int res;
+
+    if( fDriver->capture.handle )
+        {
+        status.channel = SND_PCM_CHANNEL_CAPTURE;
+        if( ( res = snd_pcm_channel_status( fDriver->capture.handle,
+                                            &status ) ) < 0 )
+            {
+            jack_error( "status error: %s",
+                        snd_strerror( res ) );
+            }
+        }
+    else
+        {
+        status.channel = SND_PCM_CHANNEL_PLAYBACK;
+        if( ( res = snd_pcm_channel_status( fDriver->playback.handle,
+                                            &status ) ) < 0 )
+            {
+            jack_error( "status error: %s",
+                        snd_strerror( res ) );
+            }
+        }
+
+    if( status.status == SND_PCM_STATUS_READY )
+        {
+        jack_log( "**** ioaudio_pcm: pcm in suspended state, resuming it" );
+        if( fDriver->capture.handle )
+            {
+            if( ( res = snd_pcm_capture_prepare( fDriver->capture.handle ) )
+                < 0 )
+                {
+                jack_error( "error preparing after suspend: %s",
+                            snd_strerror( res ) );
+                }
+            }
+        else
+            {
+            if( ( res = snd_pcm_playback_prepare( fDriver->playback.handle ) )
+                < 0 )
+                {
+                jack_error( "error preparing after suspend: %s",
+                            snd_strerror( res ) );
+                }
+            }
+        }
+
+    if( status.status == SND_PCM_STATUS_OVERRUN
+        && fDriver->process_count > XRUN_REPORT_DELAY )
+        {
+        struct timeval now, diff, tstamp;
+        fDriver->xrun_count++;
+        gettimeofday( &now,
+                      NULL );
+        tstamp = status.stop_time;
+        timersub( &now,
+                  &tstamp,
+                  &diff );
+        *delayed_usecs = diff.tv_sec * 1000000.0 + diff.tv_usec;
+        jack_log( "**** ioaudio_pcm: xrun of at least %.3f msecs",
+                  *delayed_usecs / 1000.0 );
+        }
+
+    if( restart() )
+        {
+        return -1;
+        }
+    return 0;
     }
-    void ClearOutput()
+
+}
+// end of namespace
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    static int dither_opt(
+        char c,
+        DitherAlgorithm* dither )
     {
-        g_ioaudio_driver->ClearOutputAux();
+    switch( c )
+        {
+        case '-':
+        case 'n':
+            *dither = None;
+            break;
+
+        case 'r':
+            *dither = Rectangular;
+            break;
+
+        case 's':
+            *dither = Shaped;
+            break;
+
+        case 't':
+            *dither = Triangular;
+            break;
+
+        default:
+            fprintf( stderr,
+                     "io-audio driver: illegal dithering mode %c\n",
+                     c );
+            return -1;
+        }
+    return 0;
     }
-    void WriteOutput(
-        jack_nframes_t orig_nframes,
-        ssize_t contiguous,
-        ssize_t nwritten )
+
+    static jack_driver_param_constraint_desc_t *
+    enum_ioaudio_devices()
     {
-        g_ioaudio_driver->WriteOutputAux( orig_nframes,
-                                          contiguous,
-                                          nwritten );
+    snd_ctl_t * handle;
+    snd_ctl_hw_info_t hwinfo;
+    snd_pcm_info_t pcminfo;
+    int card_no = -1;
+    jack_driver_param_value_t card_id;
+    jack_driver_param_value_t device_id;
+    char description[64];
+    uint32_t device_no;
+    bool has_capture;
+    bool has_playback;
+    jack_driver_param_constraint_desc_t * constraint_ptr;
+    uint32_t array_size = 0;
+
+    constraint_ptr = NULL;
+
+    int cards_over = 0;
+    int numcards = snd_cards_list( NULL,
+                                   0,
+                                   &cards_over );
+    int* cards = new int[cards_over];
+    numcards = snd_cards_list( cards,
+                               cards_over,
+                               &cards_over );
+
+    for( int c = 0; c < numcards; ++c )
+        {
+        card_no = cards[c];
+
+        if( snd_ctl_open( &handle,
+                          card_no ) >= 0 && snd_ctl_hw_info( handle,
+                                                             &hwinfo ) >= 0 )
+            {
+            strncpy( card_id.str,
+                     hwinfo.id,
+                     sizeof( card_id.str ) );
+            strncpy( description,
+                     hwinfo.longname,
+                     sizeof( description ) );
+            if( !jack_constraint_add_enum( &constraint_ptr,
+                                           &array_size,
+                                           &card_id,
+                                           description ) )
+                goto fail;
+
+            device_no = -1;
+
+            for( device_no = 0; device_no < hwinfo.pcmdevs; ++device_no )
+                {
+                snprintf( device_id.str,
+                          sizeof( device_id.str ),
+                          "%s,%d",
+                          card_id.str,
+                          device_no );
+
+                snd_ctl_pcm_info( handle,
+                                  device_no,
+                                  &pcminfo );
+                has_capture = pcminfo.flags & SND_PCM_INFO_CAPTURE;
+                has_playback = pcminfo.flags & SND_PCM_INFO_PLAYBACK;
+
+                if( has_capture && has_playback )
+                    {
+                    snprintf( description,
+                              sizeof( description ),
+                              "%s (duplex)",
+                              pcminfo.name );
+                    }
+                else if( has_capture )
+                    {
+                    snprintf( description,
+                              sizeof( description ),
+                              "%s (capture)",
+                              pcminfo.name );
+                    }
+                else if( has_playback )
+                    {
+                    snprintf( description,
+                              sizeof( description ),
+                              "%s (playback)",
+                              pcminfo.name );
+                    }
+                else
+                    {
+                    continue;
+                    }
+
+                if( !jack_constraint_add_enum( &constraint_ptr,
+                                               &array_size,
+                                               &device_id,
+                                               description ) )
+                    goto fail;
+                }
+
+            snd_ctl_close( handle );
+            }
+        }
+
+    delete[] cards;
+    return constraint_ptr;
+
+    fail: jack_constraint_free( constraint_ptr );
+    delete[] cards;
+    return NULL;
     }
-    void SetTime(
-        jack_time_t time )
+
+    SERVER_EXPORT const jack_driver_desc_t* driver_get_descriptor()
     {
-        g_ioaudio_driver->SetTimetAux( time );
+    jack_driver_desc_t * desc;
+    jack_driver_desc_filler_t filler;
+    jack_driver_param_value_t value;
+
+    desc =
+        jack_driver_descriptor_construct( "io-audio",
+                                          JackDriverMaster,
+                                          "QNX io-audio API based audio backend",
+                                          &filler );
+
+    strcpy( value.str,
+            "pcmPreferredp" );
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "device",
+                                          'd',
+                                          JackDriverParamString,
+                                          &value,
+                                          enum_ioaudio_devices(),
+                                          "io-audio device name",
+                                          NULL );
+
+    strcpy( value.str,
+            "none" );
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "capture",
+                                          'C',
+                                          JackDriverParamString,
+                                          &value,
+                                          NULL,
+                                          "Provide capture ports.  Optionally set device",
+                                          NULL );
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "playback",
+                                          'P',
+                                          JackDriverParamString,
+                                          &value,
+                                          NULL,
+                                          "Provide playback ports.  Optionally set device",
+                                          NULL );
+
+    value.ui = 48000U;
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "rate",
+                                          'r',
+                                          JackDriverParamUInt,
+                                          &value,
+                                          NULL,
+                                          "Sample rate",
+                                          NULL );
+
+    value.ui = 1024U;
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "period",
+                                          'p',
+                                          JackDriverParamUInt,
+                                          &value,
+                                          NULL,
+                                          "Frames per period",
+                                          NULL );
+
+    value.ui = 2U;
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "nperiods",
+                                          'n',
+                                          JackDriverParamUInt,
+                                          &value,
+                                          NULL,
+                                          "Number of periods of playback latency",
+                                          NULL );
+
+    value.i = 0;
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "hwmon",
+                                          'H',
+                                          JackDriverParamBool,
+                                          &value,
+                                          NULL,
+                                          "Hardware monitoring, if available",
+                                          NULL );
+
+    value.i = 0;
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "hwmeter",
+                                          'M',
+                                          JackDriverParamBool,
+                                          &value,
+                                          NULL,
+                                          "Hardware metering, if available",
+                                          NULL );
+
+    value.i = 1;
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "duplex",
+                                          'D',
+                                          JackDriverParamBool,
+                                          &value,
+                                          NULL,
+                                          "Provide both capture and playback ports",
+                                          NULL );
+
+    value.i = 0;
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "softmode",
+                                          's',
+                                          JackDriverParamBool,
+                                          &value,
+                                          NULL,
+                                          "Soft-mode, no xrun handling",
+                                          NULL );
+
+    value.i = 0;
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "monitor",
+                                          'm',
+                                          JackDriverParamBool,
+                                          &value,
+                                          NULL,
+                                          "Provide monitor ports for the output",
+                                          NULL );
+
+    value.c = 'n';
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "dither",
+                                          'z',
+                                          JackDriverParamChar,
+                                          &value,
+                                          jack_constraint_compose_enum_char(
+                                                                             JACK_CONSTRAINT_FLAG_STRICT
+                                                                                 | JACK_CONSTRAINT_FLAG_FAKE_VALUE,
+                                                                             dither_constraint_descr_array ),
+                                          "Dithering mode",
+                                          NULL );
+
+    value.ui = 0;
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "inchannels",
+                                          'i',
+                                          JackDriverParamUInt,
+                                          &value,
+                                          NULL,
+                                          "Number of capture channels (defaults to hardware max)",
+                                          NULL );
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "outchannels",
+                                          'o',
+                                          JackDriverParamUInt,
+                                          &value,
+                                          NULL,
+                                          "Number of playback channels (defaults to hardware max)",
+                                          NULL );
+
+    value.i = false;
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "shorts",
+                                          'S',
+                                          JackDriverParamBool,
+                                          &value,
+                                          NULL,
+                                          "Try 16-bit samples before 32-bit",
+                                          NULL );
+
+    value.ui = 0;
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "input-latency",
+                                          'I',
+                                          JackDriverParamUInt,
+                                          &value,
+                                          NULL,
+                                          "Extra input latency (frames)",
+                                          NULL );
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "output-latency",
+                                          'O',
+                                          JackDriverParamUInt,
+                                          &value,
+                                          NULL,
+                                          "Extra output latency (frames)",
+                                          NULL );
+
+    strcpy( value.str,
+            "none" );
+    jack_driver_descriptor_add_parameter( desc,
+                                          &filler,
+                                          "midi-driver",
+                                          'X',
+                                          JackDriverParamString,
+                                          &value,
+                                          jack_constraint_compose_enum_str(
+                                                                            JACK_CONSTRAINT_FLAG_STRICT
+                                                                                | JACK_CONSTRAINT_FLAG_FAKE_VALUE,
+                                                                            midi_constraint_descr_array ),
+                                          "io-audio MIDI driver",
+                                          NULL );
+
+    return desc;
     }
 
-    int Restart()
+    SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize(
+        Jack::JackLockedEngine* engine,
+        Jack::JackSynchro* table,
+        const JSList* params )
     {
-        int res;
-        if( ( res = g_ioaudio_driver->Stop() ) == 0 )
+    ioaudio_driver_args_t args;
+    args.srate = 48000;
+    args.frames_per_interrupt = 1024;
+    args.user_nperiods = 2;
+    args.playback_pcm_name = "pcmPreferredp";
+    args.capture_pcm_name = "pcmPreferredc";
+    args.hw_monitoring = false;
+    args.hw_metering = false;
+    args.capture = false;
+    args.playback = false;
+    args.soft_mode = false;
+    args.monitor = false;
+    args.dither = None;
+    args.user_capture_nchnls = 0;
+    args.user_playback_nchnls = 0;
+    args.shorts_first = false;
+    args.systemic_input_latency = 0;
+    args.systemic_output_latency = 0;
+    args.midi_driver = "none";
+
+    const JSList * node;
+    const jack_driver_param_t * param;
+
+    for( node = params; node; node = jack_slist_next( node ) )
+        {
+        param = (const jack_driver_param_t *)node->data;
+
+        switch( param->character )
             {
-            res = g_ioaudio_driver->Start();
+
+            case 'C':
+                if( strcmp( param->value.str,
+                            "none" ) != 0 )
+                    {
+                    args.capture = true;
+                    args.capture_pcm_name = strdup( param->value.str );
+                    jack_log( "capture device %s",
+                              args.capture_pcm_name );
+                    }
+                break;
+
+            case 'P':
+                if( strcmp( param->value.str,
+                            "none" ) != 0 )
+                    {
+                    args.playback = true;
+                    args.playback_pcm_name = strdup( param->value.str );
+                    jack_log( "playback device %s",
+                              args.playback_pcm_name );
+                    }
+                break;
+
+            case 'D':
+                args.playback = true;
+                args.capture = true;
+                break;
+
+            case 'd':
+                if( strcmp( param->value.str,
+                            "none" ) != 0 )
+                    {
+                    args.playback = true;
+                    args.playback_pcm_name = strdup( param->value.str );
+                    args.capture = true;
+                    args.capture_pcm_name = strdup( param->value.str );
+                    jack_log( "playback device %s",
+                              args.playback_pcm_name );
+                    jack_log( "capture device %s",
+                              args.capture_pcm_name );
+                    }
+                break;
+
+            case 'H':
+                args.hw_monitoring = param->value.i;
+                break;
+
+            case 'm':
+                args.monitor = param->value.i;
+                break;
+
+            case 'M':
+                args.hw_metering = param->value.i;
+                break;
+
+            case 'r':
+                args.srate = param->value.ui;
+                jack_log( "apparent rate = %d",
+                          args.srate );
+                break;
+
+            case 'p':
+                args.frames_per_interrupt = param->value.ui;
+                jack_log( "frames per period = %d",
+                          args.frames_per_interrupt );
+                break;
+
+            case 'n':
+                args.user_nperiods = param->value.ui;
+                if( args.user_nperiods < 2 )
+                    { /* enforce minimum value */
+                    args.user_nperiods = 2;
+                    }
+                break;
+
+            case 's':
+                args.soft_mode = param->value.i;
+                break;
+
+            case 'z':
+                if( dither_opt( param->value.c,
+                                &args.dither ) )
+                    {
+                    return NULL;
+                    }
+                break;
+
+            case 'i':
+                args.user_capture_nchnls = param->value.ui;
+                break;
+
+            case 'o':
+                args.user_playback_nchnls = param->value.ui;
+                break;
+
+            case 'S':
+                args.shorts_first = param->value.i;
+                break;
+
+            case 'I':
+                args.systemic_input_latency = param->value.ui;
+                break;
+
+            case 'O':
+                args.systemic_output_latency = param->value.ui;
+                break;
+
+            case 'X':
+                args.midi_driver = strdup( param->value.str );
+                break;
             }
-        return res;
+        }
+
+    /* duplex is the default */
+    if( !args.capture && !args.playback )
+        {
+        args.capture = true;
+        args.playback = true;
+        }
+
+    Jack::JackIoAudioDriver* ioaudio_driver =
+        new Jack::JackIoAudioDriver( "system",
+                                     "ioaudio_pcm",
+                                     engine,
+                                     table );
+    Jack::JackDriverClientInterface* threaded_driver =
+        new Jack::JackThreadedDriver( ioaudio_driver );
+    // Special open for io-audio driver
+    if( ioaudio_driver->Open( args ) == 0 )
+        {
+        return threaded_driver;
+        }
+    else
+        {
+        delete threaded_driver; // Delete the decorated driver
+        return NULL;
+        }
     }
 
 #ifdef __cplusplus
diff --git a/qnx/ioaudio/JackIoAudioDriver.h b/qnx/ioaudio/JackIoAudioDriver.h
index bbb34e19..5630d4bb 100644
--- a/qnx/ioaudio/JackIoAudioDriver.h
+++ b/qnx/ioaudio/JackIoAudioDriver.h
@@ -1,22 +1,22 @@
 /*
-Copyright (C) 2001 Paul Davis
-Copyright (C) 2004 Grame
+ Copyright (C) 2001 Paul Davis
+ Copyright (C) 2004 Grame
 
-This program 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 2 of the License, or
-(at your option) any later version.
+ This program 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 2 of the License, or
+ (at your option) any later version.
 
-This program 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.
+ This program 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 this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-*/
+ */
 
 #ifndef __JackIoAudioDriver__
 #define __JackIoAudioDriver__
@@ -24,33 +24,70 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #include "JackAudioDriver.h"
 #include "JackThreadedDriver.h"
 #include "JackTime.h"
-#include "ioaudio_backend.h"
+#include "driver.h"
+#include "memops.h"
 
-namespace Jack
+typedef struct _ioaudio_driver_args
 {
+    char* device;
+
+    bool capture;
+    const char* capture_pcm_name;
+    size_t user_capture_nchnls;
+
+    bool playback;
+    const char* playback_pcm_name;
+    size_t user_playback_nchnls;
+
+    size_t srate;
+    size_t frames_per_interrupt;
+    size_t user_nperiods;
+    DitherAlgorithm dither;
+    bool hw_monitoring;
+    bool hw_metering;
+    bool duplex;
+    bool soft_mode;
+    bool monitor;
+    bool shorts_first;
+    size_t systemic_input_latency;
+    size_t systemic_output_latency;
+    const char* midi_driver;
+} ioaudio_driver_args_t;
 
-/*!
-\brief The IoAudio driver.
-*/
 
-class JackIoAudioDriver : public JackAudioDriver
+namespace Jack
 {
 
-    private:
+    struct ioaudio_driver_t;
 
-        jack_driver_t* fDriver;
+    /*!
+     \brief The IoAudio driver.
+     */
 
-        void UpdateLatencies();
+    class JackIoAudioDriver: public JackAudioDriver
+    {
 
     public:
 
-        JackIoAudioDriver(const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table)
-                : JackAudioDriver(name, alias, engine, table),fDriver(NULL)
-        {}
+        JackIoAudioDriver(
+            const char* name,
+            const char* alias,
+            JackLockedEngine* engine,
+            JackSynchro* table ) :
+                JackAudioDriver( name,
+                                 alias,
+                                 engine,
+                                 table ),
+                fDriver( NULL )
+        {
+        }
+
         virtual ~JackIoAudioDriver()
-        {}
+        {
+        }
 
-        int Open(ioaudio_driver_args_t args);
+        int Open(
+            ioaudio_driver_args_t args );
 
         int Close();
         int Attach();
@@ -65,30 +102,125 @@ class JackIoAudioDriver : public JackAudioDriver
         // BufferSize can be changed
         bool IsFixedBufferSize()
         {
-            return false;
+        return false;
         }
 
-        int SetBufferSize(jack_nframes_t buffer_size);
+        int SetBufferSize(
+            jack_nframes_t buffer_size );
 
-        void ReadInputAux(jack_nframes_t orig_nframes, ssize_t contiguous, ssize_t nread);
+        void ReadInputAux(
+            jack_nframes_t orig_nframes,
+            ssize_t contiguous,
+            ssize_t nread );
         void MonitorInputAux();
         void ClearOutputAux();
-        void WriteOutputAux(jack_nframes_t orig_nframes, ssize_t contiguous, ssize_t nwritten);
-        void SetTimetAux(jack_time_t time);
-
-        // JACK API emulation for the midi driver
-        int is_realtime() const;
-        int create_thread(pthread_t *thread, int prio, int rt, void *(*start_func)(void*), void *arg);
-
-        jack_port_id_t port_register(const char *port_name, const char *port_type, unsigned long flags, unsigned long buffer_size);
-        int port_unregister(jack_port_id_t port_index);
-        void* port_get_buffer(int port, jack_nframes_t nframes);
-        int port_set_alias(int port, const char* name);
-
-        jack_nframes_t get_sample_rate() const;
-        jack_nframes_t frame_time() const;
-        jack_nframes_t last_frame_time() const;
-};
+        void WriteOutputAux(
+            jack_nframes_t orig_nframes,
+            ssize_t contiguous,
+            ssize_t nwritten );
+//        void SetTimetAux(
+//            jack_time_t time );
+
+    private:
+        ioaudio_driver_args_t fArgs;
+        ioaudio_driver_t* fDriver;
+
+        void UpdateLatencies();
+
+        ssize_t capture_sample_bytes();
+        ssize_t capture_frame_bytes();
+        ssize_t capture_frag_bytes();
+        ssize_t capture_frag_frames();
+
+        ssize_t playback_sample_bytes();
+        ssize_t playback_frame_bytes();
+        ssize_t playback_frag_bytes();
+        ssize_t playback_frag_frames();
+
+        void
+        create(
+            char *name,
+            jack_client_t *client );
+
+        void
+        destroy();
+
+        int
+        start();
+
+        int
+        stop();
+
+        jack_nframes_t
+        wait(
+            int *status,
+            float *delayed_usecs );
+
+        int
+        read(
+            jack_nframes_t nframes );
+
+        void silence_untouched_channels(
+            jack_nframes_t nframes );
+
+        int
+        reset_parameters();
+
+        void mark_channel_done(
+            int chn );
+
+        void silence_on_channel(
+            int chn,
+            jack_nframes_t nframes );
+
+        void silence_on_channel_no_mark(
+            int chn,
+            jack_nframes_t nframes );
+
+//        void read_from_channel(
+//            int chn,
+//            jack_default_audio_sample_t *buf,
+//            jack_nframes_t nsamples );
+
+//        void write_to_channel(
+//            int chn,
+//            jack_default_audio_sample_t *buf,
+//            jack_nframes_t nsamples );
+
+        void release_channel_dependent_memory();
+
+        int check_capabilities(
+            const char *devicename,
+            int mode );
+
+        int check_card_type();
+
+        int generic_hardware();
+
+        int hw_specific();
+
+        void setup_io_function_pointers();
+
+        int configure_stream(
+            const char *device_name,
+            const char *stream_name,
+            snd_pcm_t *handle,
+            snd_pcm_channel_params_t *params,
+            unsigned int *nperiodsp );
+
+        int set_parameters();
+
+        int get_channel_addresses(
+            size_t *capture_avail,
+            size_t *playback_avail,
+            size_t *capture_offset,
+            size_t *playback_offset );
+
+        int restart();
+
+        int xrun_recovery(
+            float *delayed_usecs );
+    };
 
 } // end of namespace
 
diff --git a/qnx/ioaudio/generic.h b/qnx/ioaudio/generic.h
deleted file mode 100644
index ee1a8290..00000000
--- a/qnx/ioaudio/generic.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
-   Copyright (C) 2001 Paul Davis
-
-   This program 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 2 of the License, or
-   (at your option) any later version.
-
-   This program 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 this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-   $Id: generic.h,v 1.3 2005/11/23 11:24:29 letz Exp $
-*/
-
-#ifndef __jack_generic_h__
-#define __jack_generic_h__
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    jack_hardware_t *
-    jack_ioaudio_generic_hw_new (ioaudio_driver_t *driver);
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif /* __jack_generic_h__*/
diff --git a/qnx/ioaudio/generic_hw.c b/qnx/ioaudio/generic_hw.c
deleted file mode 100644
index f50c90e5..00000000
--- a/qnx/ioaudio/generic_hw.c
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-    Copyright (C) 2001 Paul Davis 
-
-    This program 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 2 of the License, or
-    (at your option) any later version.
-
-    This program 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 this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-    $Id: generic_hw.c,v 1.2 2005/08/29 10:36:28 letz Exp $
-*/
-
-#include "hardware.h"
-#include "ioaudio_backend.h"
-
-static int generic_set_input_monitor_mask (jack_hardware_t *hw, unsigned long mask)
-{
-	return -1;
-}
-
-static int generic_change_sample_clock (jack_hardware_t *hw, SampleClockMode mode) 
-{
-	return -1;
-}
-
-static void
-generic_release (jack_hardware_t *hw)
-{
-	return;
-}
-
-jack_hardware_t *
-jack_ioaudio_generic_hw_new (ioaudio_driver_t *driver)
-
-{
-	jack_hardware_t *hw;
-
-	hw = (jack_hardware_t *) malloc (sizeof (jack_hardware_t));
-
-	hw->capabilities = 0;
-	hw->input_monitor_mask = 0;
-	
-	hw->set_input_monitor_mask = generic_set_input_monitor_mask;
-	hw->change_sample_clock = generic_change_sample_clock;
-	hw->release = generic_release;
-
-	return hw;
-}
diff --git a/qnx/ioaudio/hardware.h b/qnx/ioaudio/hardware.h
index b77dc859..7b82ad01 100644
--- a/qnx/ioaudio/hardware.h
+++ b/qnx/ioaudio/hardware.h
@@ -1,75 +1,74 @@
 /*
-   Copyright (C) 2001 Paul Davis
+ Copyright (C) 2001 Paul Davis
 
-   This program 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 2 of the License, or
-   (at your option) any later version.
+ This program 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 2 of the License, or
+ (at your option) any later version.
 
-   This program 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.
+ This program 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 this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-   $Id: hardware.h,v 1.3 2005/11/23 11:24:29 letz Exp $
-*/
+ $Id: hardware.h,v 1.3 2005/11/23 11:24:29 letz Exp $
+ */
 
 #ifndef __jack_hardware_h__
 #define __jack_hardware_h__
 
 #include "types.h"
 
-typedef	enum {
+enum SampleClockMode
+{
     AutoSync,
     WordClock,
     ClockMaster
-} SampleClockMode;
+};
 
-typedef enum {
+enum Capabilities
+{
+    Cap_None = 0x0,
     Cap_HardwareMonitoring = 0x1,
     Cap_AutoSync = 0x2,
     Cap_WordClock = 0x4,
     Cap_ClockMaster = 0x8,
     Cap_ClockLockReporting = 0x10,
     Cap_HardwareMetering = 0x20
-} Capabilities;
-
-struct _jack_hardware;
+};
 
-typedef void (*JackHardwareReleaseFunction)(struct _jack_hardware *);
-typedef int (*JackHardwareSetInputMonitorMaskFunction)(struct _jack_hardware *, unsigned long);
-typedef int (*JackHardwareChangeSampleClockFunction)(struct _jack_hardware *, SampleClockMode);
-typedef double (*JackHardwareGetHardwarePeak)(jack_port_t *port, jack_nframes_t frames);
-typedef double (*JackHardwareGetHardwarePower)(jack_port_t *port, jack_nframes_t frames);
-
-typedef struct _jack_hardware
+struct jack_hardware_t
 {
-    unsigned long capabilities;
+    Capabilities capabilities;
     unsigned long input_monitor_mask;
-
-    JackHardwareChangeSampleClockFunction change_sample_clock;
-    JackHardwareSetInputMonitorMaskFunction set_input_monitor_mask;
-    JackHardwareReleaseFunction release;
-    JackHardwareGetHardwarePeak get_hardware_peak;
-    JackHardwareGetHardwarePower get_hardware_power;
     void *private_hw;
-}
-jack_hardware_t;
 
-#ifdef __cplusplus
-extern "C"
-{
-#endif
+    jack_hardware_t() :
+            capabilities( Cap_None ),
+            input_monitor_mask( 0 )
+    {
+    }
+
+    virtual void release() = 0;
+
+    virtual int set_input_monitor_mask(
+        unsigned long ) = 0;
+
+    virtual int change_sample_clock(
+        SampleClockMode ) = 0;
 
-    jack_hardware_t * jack_hardware_new ();
+    virtual double get_hardware_peak(
+        jack_port_t *port,
+        jack_nframes_t frames ) = 0;
 
-#ifdef __cplusplus
-}
-#endif
+    virtual double get_hardware_power(
+        jack_port_t *port,
+        jack_nframes_t frames ) = 0;
 
+};
 
 #endif /* __jack_hardware_h__ */
diff --git a/qnx/ioaudio/ioaudio_backend.c b/qnx/ioaudio/ioaudio_backend.c
deleted file mode 100644
index 7a832ab7..00000000
--- a/qnx/ioaudio/ioaudio_backend.c
+++ /dev/null
@@ -1,2369 +0,0 @@
-/* -*- mode: c; c-file-style: "linux"; -*- */
-/*
- Copyright (C) 2001 Paul Davis
-
- This program 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 2 of the License, or
- (at your option) any later version.
-
- This program 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 this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
- */
-
-#define __STDC_FORMAT_MACROS   // For inttypes.h to work in C++
-#define _GNU_SOURCE            /* for strcasestr() from string.h */
-
-#include <inttypes.h>
-#include <math.h>
-#include <stdio.h>
-#include <memory.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <stdarg.h>
-#include <signal.h>
-#include <sys/mman.h>
-#include <sys/poll.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <string.h>
-
-#include "ioaudio_backend.h"
-#include "generic.h"
-#include "memops.h"
-#include "JackError.h"
-
-//#include "ioaudio_midi_impl.h"
-
-extern void store_work_time(
-    int );
-extern void store_wait_time(
-    int );
-extern void show_wait_times();
-extern void show_work_times();
-
-#undef DEBUG_WAKEUP
-
-char* strcasestr(
-    const char* haystack,
-    const char* needle );
-
-/* Delay (in process calls) before jackd will report an xrun */
-#define XRUN_REPORT_DELAY 0
-
-void jack_driver_init(
-    jack_driver_t *driver )
-{
-    memset( driver,
-            0,
-            sizeof( *driver ) );
-}
-
-void jack_driver_nt_init(
-    jack_driver_nt_t * driver )
-{
-    memset( driver,
-            0,
-            sizeof( *driver ) );
-}
-
-static void ioaudio_driver_release_channel_dependent_memory(
-    ioaudio_driver_t *driver )
-{
-    bitset_destroy( &driver->channels_done );
-    bitset_destroy( &driver->channels_not_done );
-
-    if( driver->playback_addr )
-        {
-        free( driver->playback_addr );
-        driver->playback_addr = 0;
-        }
-
-    if( driver->capture_addr )
-        {
-        free( driver->capture_addr );
-        driver->capture_addr = 0;
-        }
-
-    if( driver->playback_interleave_skip )
-        {
-        free( driver->playback_interleave_skip );
-        driver->playback_interleave_skip = NULL;
-        }
-
-    if( driver->capture_interleave_skip )
-        {
-        free( driver->capture_interleave_skip );
-        driver->capture_interleave_skip = NULL;
-        }
-
-    if( driver->silent )
-        {
-        free( driver->silent );
-        driver->silent = 0;
-        }
-
-    if( driver->dither_state )
-        {
-        free( driver->dither_state );
-        driver->dither_state = 0;
-        }
-}
-
-static int ioaudio_driver_check_capabilities(
-    ioaudio_driver_t *driver )
-{
-    return 0;
-}
-
-char*
-get_control_device_name(
-    const char * device_name )
-{
-    char * ctl_name;
-    const char * comma;
-
-    /* the user wants a hw or plughw device, the ctl name
-     * should be hw:x where x is the card identification.
-     * We skip the subdevice suffix that starts with comma */
-
-    if( strncasecmp( device_name,
-                     "plughw:",
-                     7 ) == 0 )
-        {
-        /* skip the "plug" prefix" */
-        device_name += 4;
-        }
-
-    comma = strchr( device_name,
-                    ',' );
-    if( comma == NULL )
-        {
-        ctl_name = strdup( device_name );
-        if( ctl_name == NULL )
-            {
-            jack_error( "strdup(\"%s\") failed.",
-                        device_name );
-            }
-        }
-    else
-        {
-        ctl_name = strdup( device_name );
-        if( ctl_name == NULL )
-            {
-            jack_error( "strdup(\"%s\") failed.",
-                        device_name );
-            return NULL;
-            }
-        ctl_name[comma - device_name] = '\0';
-        }
-
-    return ctl_name;
-}
-
-static int ioaudio_driver_check_card_type(
-    ioaudio_driver_t *driver )
-{
-    int err;
-    snd_ctl_hw_info_t card_info;
-    int play_card;
-    int cap_card;
-
-    play_card = snd_card_name( driver->ioaudio_name_playback );
-    cap_card = snd_card_name( driver->ioaudio_name_capture );
-
-    // XXX: I don't know the "right" way to do this. Which to use
-    // driver->ioaudio_name_playback or driver->ioaudio_name_capture.
-    if( ( err = snd_ctl_open( &driver->ctl_handle,
-                              play_card ) ) < 0 )
-        {
-        jack_error( "control open %d:\"%s\" (%s)",
-                    play_card,
-                    driver->ioaudio_name_playback,
-                    snd_strerror( err ) );
-        }
-    else if( ( err = snd_ctl_hw_info( driver->ctl_handle,
-                                      &card_info ) ) < 0 )
-        {
-        jack_error( "control hardware info %d:\"%s\" (%s)",
-                    play_card,
-                    driver->ioaudio_name_playback,
-                    snd_strerror( err ) );
-        snd_ctl_close( driver->ctl_handle );
-        }
-
-    driver->ioaudio_driver = strdup( card_info.longname );
-
-    return ioaudio_driver_check_capabilities( driver );
-}
-
-static int ioaudio_driver_generic_hardware(
-    ioaudio_driver_t *driver )
-{
-    driver->hw = jack_ioaudio_generic_hw_new( driver );
-    return 0;
-}
-
-static int ioaudio_driver_hw_specific(
-    ioaudio_driver_t *driver,
-    int hw_monitoring,
-    int hw_metering )
-{
-    int err;
-
-    if( ( err = ioaudio_driver_generic_hardware( driver ) ) != 0 )
-        {
-        return err;
-        }
-
-    if( driver->hw->capabilities & Cap_HardwareMonitoring )
-        {
-        driver->has_hw_monitoring = TRUE;
-        /* XXX need to ensure that this is really FALSE or
-         * TRUE or whatever*/
-        driver->hw_monitoring = hw_monitoring;
-        }
-    else
-        {
-        driver->has_hw_monitoring = FALSE;
-        driver->hw_monitoring = FALSE;
-        }
-
-    if( driver->hw->capabilities & Cap_ClockLockReporting )
-        {
-        driver->has_clock_sync_reporting = TRUE;
-        }
-    else
-        {
-        driver->has_clock_sync_reporting = FALSE;
-        }
-
-    if( driver->hw->capabilities & Cap_HardwareMetering )
-        {
-        driver->has_hw_metering = TRUE;
-        driver->hw_metering = hw_metering;
-        }
-    else
-        {
-        driver->has_hw_metering = FALSE;
-        driver->hw_metering = FALSE;
-        }
-
-    return 0;
-}
-
-static void ioaudio_driver_setup_io_function_pointers(
-    ioaudio_driver_t *driver )
-{
-    if( driver->playback_handle )
-        {
-        if( SND_PCM_FMT_FLOAT_LE == driver->playback_setup.format.format )
-            {
-            driver->write_via_copy = sample_move_dS_floatLE;
-            }
-        else
-            {
-            ssize_t bytes =
-                snd_pcm_format_size(
-                                     driver->playback_setup.format.format,
-                                     1 );
-            switch( bytes )
-                {
-                case 2:
-                    switch( driver->dither )
-                        {
-                        case Rectangular:
-                            jack_info( "Rectangular dithering at 16 bits" );
-                            driver->write_via_copy =
-                                driver->quirk_bswap ?
-                                    sample_move_dither_rect_d16_sSs :
-                                    sample_move_dither_rect_d16_sS;
-                            break;
-
-                        case Triangular:
-                            jack_info( "Triangular dithering at 16 bits" );
-                            driver->write_via_copy =
-                                driver->quirk_bswap ?
-                                    sample_move_dither_tri_d16_sSs :
-                                    sample_move_dither_tri_d16_sS;
-                            break;
-
-                        case Shaped:
-                            jack_info( "Noise-shaped dithering at 16 bits" );
-                            driver->write_via_copy =
-                                driver->quirk_bswap ?
-                                    sample_move_dither_shaped_d16_sSs :
-                                    sample_move_dither_shaped_d16_sS;
-                            break;
-
-                        default:
-                            driver->write_via_copy =
-                                driver->quirk_bswap ?
-                                                      sample_move_d16_sSs :
-                                                      sample_move_d16_sS;
-                            break;
-                        }
-                    break;
-
-                case 3: /* NO DITHER */
-                    driver->write_via_copy =
-                        driver->quirk_bswap ?
-                                              sample_move_d24_sSs :
-                                              sample_move_d24_sS;
-
-                    break;
-
-                case 4: /* NO DITHER */
-                    driver->write_via_copy =
-                        driver->quirk_bswap ?
-                                              sample_move_d32u24_sSs :
-                                              sample_move_d32u24_sS;
-                    break;
-
-                default:
-                    jack_error( "impossible sample width (%d) discovered!",
-                                bytes );
-                    exit( 1 );
-                }
-            }
-        }
-
-    if( driver->capture_handle )
-        {
-        if( SND_PCM_FMT_FLOAT_LE == driver->capture_setup.format.format )
-            {
-            driver->read_via_copy = sample_move_floatLE_sSs;
-            }
-        else
-            {
-            ssize_t bytes =
-                snd_pcm_format_size(
-                                     driver->capture_setup.format.format,
-                                     1 );
-            switch( bytes )
-                {
-                case 2:
-                    driver->read_via_copy =
-                        driver->quirk_bswap ?
-                                              sample_move_dS_s16s :
-                                              sample_move_dS_s16;
-                    break;
-                case 3:
-                    driver->read_via_copy =
-                        driver->quirk_bswap ?
-                                              sample_move_dS_s24s :
-                                              sample_move_dS_s24;
-                    break;
-                case 4:
-                    driver->read_via_copy =
-                        driver->quirk_bswap ?
-                                              sample_move_dS_s32u24s :
-                                              sample_move_dS_s32u24;
-                    break;
-                }
-            }
-        }
-}
-
-static int ioaudio_driver_configure_stream(
-    ioaudio_driver_t *driver,
-    char *device_name,
-    const char *stream_name,
-    snd_pcm_t *handle,
-    snd_pcm_channel_params_t *params,
-    unsigned int *nperiodsp )
-{
-    int err, format;
-    snd_pcm_channel_info_t info;
-    int32_t formats[] =
-        {
-        SND_PCM_SFMT_FLOAT_LE,
-          SND_PCM_SFMT_S32_LE,
-          SND_PCM_SFMT_S32_BE,
-          SND_PCM_SFMT_S24_LE,
-          SND_PCM_SFMT_S24_BE,
-          SND_PCM_SFMT_S16_LE,
-          SND_PCM_SFMT_S16_BE
-        };
-#define NUMFORMATS (sizeof(formats)/sizeof(formats[0]))
-
-    info.channel = params->channel;
-
-    err = snd_pcm_channel_info( handle,
-                                &info );
-
-    if( SND_PCM_CHNINFO_NONINTERLEAVE & info.flags )
-        {
-        params->format.interleave = 0;
-        }
-    else if( SND_PCM_CHNINFO_INTERLEAVE & info.flags )
-        {
-        params->format.interleave = 1;
-        }
-
-    if( !( SND_PCM_CHNINFO_MMAP & info.flags ) )
-        {
-        jack_error( "io-audio: mmap-based access is not possible"
-                    " for the %s "
-                    "stream of this audio interface",
-                    stream_name );
-        return -1;
-        }
-
-    params->mode = SND_PCM_MODE_BLOCK;
-
-    for( format = 0; format < NUMFORMATS; ++format )
-        {
-        if( info.formats & ( 1 << formats[format] ) )
-            {
-            jack_info( "io-audio: final selected sample format for %s: %s",
-                       stream_name,
-                       snd_pcm_get_format_name( formats[format] ) );
-            params->format.format = formats[format];
-            break;
-            }
-        }
-    if( NUMFORMATS == format )
-        {
-        jack_error( "Sorry. The audio interface \"%s\""
-                    " doesn't support any of the"
-                    " hardware sample formats that"
-                    " JACK's ioaudio-driver can use.",
-                    device_name );
-        return -1;
-        }
-
-#if defined(SND_LITTLE_ENDIAN)
-    driver->quirk_bswap = snd_pcm_format_big_endian(formats[format]);
-#elif defined(SND_BIG_ENDIAN)
-    driver->quirk_bswap = snd_pcm_format_little_endian( formats[format] );
-#else
-    driver->quick_bswap = 0;
-#endif
-
-    params->format.rate = driver->frame_rate;
-
-    if( 0 == params->format.voices )
-        {
-        /*if not user-specified, try to find the maximum
-         * number of channels */
-        params->format.voices = info.max_voices;
-        }
-
-    params->start_mode = SND_PCM_START_DATA;
-
-    params->stop_mode = SND_PCM_STOP_STOP;
-
-    params->time = 1;
-
-    params->buf.block.frag_size =
-        snd_pcm_format_size( formats[format],
-                             driver->frames_per_cycle );
-
-    *nperiodsp = driver->user_nperiods;
-    params->buf.block.frags_min = driver->user_nperiods;
-    params->buf.block.frags_max = driver->user_nperiods;
-
-    jack_info( "io-audio: use %d periods for %s",
-               *nperiodsp,
-               stream_name );
-
-    int subchn_len = sizeof( params->sw_mixer_subchn_name );
-    strncpy( params->sw_mixer_subchn_name,
-             stream_name,
-             subchn_len );
-    params->sw_mixer_subchn_name[subchn_len - 1] = '\0';
-
-    if( ( err = snd_pcm_channel_params( handle,
-                                        params ) ) < 0 )
-        {
-        jack_error(
-                    "io-audio: cannot set hardware parameters for %s, why_failed=%d",
-                    stream_name,
-                    params->why_failed );
-        return -1;
-        }
-
-    return 0;
-}
-
-static int ioaudio_driver_set_parameters(
-    ioaudio_driver_t *driver,
-    jack_nframes_t frames_per_cycle,
-    jack_nframes_t user_nperiods,
-    jack_nframes_t rate )
-{
-    size_t p_period_size = 0;
-    size_t c_period_size = 0;
-    channel_t chn;
-    unsigned int pr = 0;
-    unsigned int cr = 0;
-    int err;
-
-    driver->frame_rate = rate;
-    driver->frames_per_cycle = frames_per_cycle;
-    driver->user_nperiods = user_nperiods;
-
-    jack_info( "configuring for %" PRIu32 "Hz, period = %"
-               PRIu32 " frames (%.1f ms), buffer = %" PRIu32 " periods",
-               rate,
-               frames_per_cycle,
-               ( ( (float)frames_per_cycle / (float)rate ) * 1000.0f ),
-               user_nperiods );
-
-    if( driver->capture_handle )
-        {
-        memset( &driver->capture_params,
-                0,
-                sizeof(snd_pcm_channel_params_t) );
-        driver->capture_params.channel = SND_PCM_CHANNEL_CAPTURE;
-        if( ioaudio_driver_configure_stream( driver,
-                                             driver->ioaudio_name_capture,
-                                             "capture",
-                                             driver->capture_handle,
-                                             &driver->capture_params,
-                                             &driver->capture_nperiods ) )
-            {
-            jack_error( "io-audio: cannot configure capture channel" );
-            return -1;
-            }
-        driver->capture_setup.channel = SND_PCM_CHANNEL_CAPTURE;
-        snd_pcm_channel_setup( driver->capture_handle,
-                               &driver->capture_setup );
-        cr = driver->capture_setup.format.rate;
-
-        /* check the fragment size, since thats non-negotiable */
-        c_period_size = driver->capture_setup.buf.block.frag_size;
-
-        if( c_period_size != driver->frames_per_cycle )
-            {
-            jack_error( "ioaudio_pcm: requested an interrupt every %"
-                        PRIu32
-                        " frames but got %uc frames for capture",
-                        driver->frames_per_cycle,
-                        p_period_size );
-            return -1;
-            }
-
-        /* check the sample format */
-        switch( driver->capture_setup.format.format )
-            {
-            case SND_PCM_SFMT_FLOAT_LE:
-                case SND_PCM_SFMT_S32_LE:
-                case SND_PCM_SFMT_S24_LE:
-                case SND_PCM_SFMT_S24_BE:
-                case SND_PCM_SFMT_S16_LE:
-                case SND_PCM_SFMT_S32_BE:
-                case SND_PCM_SFMT_S16_BE:
-                break;
-
-            default:
-                jack_error( "programming error: unhandled format "
-                            "type for capture" );
-                return -1;
-            }
-
-        if( driver->capture_setup.format.interleave )
-            {
-            if( ( err = snd_pcm_mmap( driver->capture_handle,
-                                      SND_PCM_CHANNEL_CAPTURE,
-                                      &driver->capture_mmap,
-                                      &driver->capture_buffer ) ) < 0 )
-                {
-                jack_error( "io-audio: %s: mmap areas info error",
-                            driver->ioaudio_name_capture );
-                return -1;
-                }
-            }
-        }
-
-    if( driver->playback_handle )
-        {
-        memset( &driver->playback_params,
-                0,
-                sizeof(snd_pcm_channel_params_t) );
-        driver->playback_params.channel = SND_PCM_CHANNEL_PLAYBACK;
-
-        if( ioaudio_driver_configure_stream( driver,
-                                             driver->ioaudio_name_playback,
-                                             "playback",
-                                             driver->playback_handle,
-                                             &driver->playback_params,
-                                             &driver->playback_nperiods ) )
-            {
-            jack_error( "io-audio: cannot configure playback channel" );
-            return -1;
-            }
-
-        driver->playback_setup.channel = SND_PCM_CHANNEL_PLAYBACK;
-        snd_pcm_channel_setup( driver->playback_handle,
-                               &driver->playback_setup );
-        pr = driver->playback_setup.format.rate;
-
-        /* check the fragment size, since thats non-negotiable */
-        p_period_size = driver->playback_setup.buf.block.frag_size;
-
-        if( p_period_size
-            != snd_pcm_format_size( driver->playback_setup.format.format,
-                                    driver->frames_per_cycle ) )
-            {
-            jack_error( "ioaudio_pcm: requested an interrupt every %"
-                        PRIu32
-                        " frames but got %u frames for playback",
-                        driver->frames_per_cycle,
-                        p_period_size );
-            return -1;
-            }
-
-        /* check the sample format */
-        switch( driver->playback_setup.format.format )
-            {
-            case SND_PCM_SFMT_FLOAT_LE:
-                case SND_PCM_SFMT_S32_LE:
-                case SND_PCM_SFMT_S24_LE:
-                case SND_PCM_SFMT_S24_BE:
-                case SND_PCM_SFMT_S16_LE:
-                case SND_PCM_SFMT_S32_BE:
-                case SND_PCM_SFMT_S16_BE:
-                break;
-
-            default:
-                jack_error( "programming error: unhandled format "
-                            "type for playback" );
-                return -1;
-            }
-
-        if( driver->playback_setup.format.interleave )
-            {
-            if( ( err = snd_pcm_mmap( driver->playback_handle,
-                                      SND_PCM_CHANNEL_PLAYBACK,
-                                      &driver->playback_mmap,
-                                      &driver->playback_buffer ) ) < 0 )
-                {
-                jack_error( "io-audio: %s: mmap areas info error",
-                            driver->ioaudio_name_playback );
-                return -1;
-                }
-            driver->interleave_unit =
-                snd_pcm_format_size(
-                                     driver->playback_setup.format.format,
-                                     1 );
-            }
-        else
-            {
-            driver->interleave_unit = 0; /* NOT USED */
-            }
-        }
-
-    /* check the rate, since thats rather important */
-    if( driver->capture_handle && driver->playback_handle )
-        {
-        if( cr != pr )
-            {
-            jack_error( "playback and capture sample rates do "
-                        "not match (%d vs. %d)",
-                        pr,
-                        cr );
-            }
-
-        /* only change if *both* capture and playback rates
-         * don't match requested certain hardware actually
-         * still works properly in full-duplex with slightly
-         * different rate values between adc and dac
-         */
-        if( cr != driver->frame_rate && pr != driver->frame_rate )
-            {
-            jack_error( "sample rate in use (%d Hz) does not "
-                        "match requested rate (%d Hz)",
-                        cr,
-                        driver->frame_rate );
-            driver->frame_rate = cr;
-            }
-
-        }
-    else if( driver->capture_handle && cr != driver->frame_rate )
-        {
-        jack_error( "capture sample rate in use (%d Hz) does not "
-                    "match requested rate (%d Hz)",
-                    cr,
-                    driver->frame_rate );
-        driver->frame_rate = cr;
-        }
-    else if( driver->playback_handle && pr != driver->frame_rate )
-        {
-        jack_error( "playback sample rate in use (%d Hz) does not "
-                    "match requested rate (%d Hz)",
-                    pr,
-                    driver->frame_rate );
-        driver->frame_rate = pr;
-        }
-
-    if( driver->playback_setup.format.voices
-        > driver->capture_setup.format.voices )
-        {
-        driver->max_nchannels = driver->playback_setup.format.voices;
-        driver->user_nchannels = driver->capture_setup.format.voices;
-        }
-    else
-        {
-        driver->max_nchannels = driver->capture_setup.format.voices;
-        driver->user_nchannels = driver->playback_setup.format.voices;
-        }
-
-    ioaudio_driver_setup_io_function_pointers( driver );
-
-    /* Allocate and initialize structures that rely on the
-     channels counts.
-
-     Set up the bit pattern that is used to record which
-     channels require action on every cycle. any bits that are
-     not set after the engine's process() call indicate channels
-     that potentially need to be silenced.
-     */
-
-    bitset_create( &driver->channels_done,
-                   driver->max_nchannels );
-    bitset_create( &driver->channels_not_done,
-                   driver->max_nchannels );
-
-    if( driver->playback_handle )
-        {
-        driver->playback_addr =
-            (char **)malloc(
-                             sizeof(char *)
-                                 * driver->playback_setup.format.voices );
-        memset( driver->playback_addr,
-                0,
-                sizeof(char *) * driver->playback_setup.format.voices );
-        driver->playback_interleave_skip =
-            (unsigned long *)malloc(
-                                     sizeof(unsigned long *)
-                                         * driver->playback_setup.format.voices );
-        memset( driver->playback_interleave_skip,
-                0,
-                sizeof(unsigned long *)
-                    * driver->playback_setup.format.voices );
-        driver->silent =
-            (unsigned long *)malloc(
-                                     sizeof(unsigned long)
-                                         * driver->playback_setup.format.voices );
-
-        for( chn = 0; chn < driver->playback_setup.format.voices; chn++ )
-            {
-            driver->silent[chn] = 0;
-            }
-
-        for( chn = 0; chn < driver->playback_setup.format.voices; chn++ )
-            {
-            bitset_add( driver->channels_done,
-                        chn );
-            }
-
-        driver->dither_state =
-            (dither_state_t *)calloc(
-                                      driver->playback_setup.format.voices,
-                                      sizeof(dither_state_t) );
-        }
-
-    if( driver->capture_handle )
-        {
-        driver->capture_addr =
-            (char **)malloc(
-                             sizeof(char *)
-                                 * driver->capture_setup.format.voices );
-        memset( driver->capture_addr,
-                0,
-                sizeof(char *) * driver->capture_setup.format.voices );
-        driver->capture_interleave_skip =
-            (unsigned long *)malloc(
-                                     sizeof(unsigned long *)
-                                         * driver->capture_setup.format.voices );
-        memset( driver->capture_interleave_skip,
-                0,
-                sizeof(unsigned long *) * driver->capture_setup.format.voices );
-        }
-
-    driver->clock_sync_data =
-        (ClockSyncStatus *)malloc(
-                                   sizeof(ClockSyncStatus)
-                                       * driver->max_nchannels );
-
-    driver->period_usecs =
-        (jack_time_t)floor(
-                            ( ( (float)driver->frames_per_cycle )
-                                / driver->frame_rate )
-                                * 1000000.0f );
-    driver->poll_timeout_msecs = (int)floor( 1.5f * driver->period_usecs / 1000.0f );
-
-    return 0;
-}
-
-int ioaudio_driver_reset_parameters(
-    ioaudio_driver_t *driver,
-    jack_nframes_t frames_per_cycle,
-    jack_nframes_t user_nperiods,
-    jack_nframes_t rate )
-{
-    /* XXX unregister old ports ? */
-    ioaudio_driver_release_channel_dependent_memory( driver );
-    return ioaudio_driver_set_parameters( driver,
-                                          frames_per_cycle,
-                                          user_nperiods,
-                                          rate );
-}
-
-static int ioaudio_driver_get_channel_addresses(
-    ioaudio_driver_t *driver,
-    size_t *capture_avail,
-    size_t *playback_avail,
-    size_t *capture_offset,
-    size_t *playback_offset )
-{
-    int err;
-    channel_t chn;
-
-    if( capture_avail )
-        {
-        if( ( err = snd_pcm_mmap( driver->capture_handle,
-                                  SND_PCM_CHANNEL_CAPTURE,
-                                  &driver->capture_mmap,
-                                  &driver->capture_buffer ) ) < 0 )
-            {
-            jack_error( "io-audio: %s: mmap areas info error",
-                        driver->ioaudio_name_capture );
-            return -1;
-            }
-
-        for( chn = 0; chn < driver->capture_setup.format.voices; chn++ )
-            {
-            driver->capture_addr[chn] = driver->capture_buffer;
-            driver->capture_interleave_skip[chn] =
-                (unsigned long)driver->capture_mmap->status.voices;
-            }
-        }
-
-    if( playback_avail )
-        {
-        if( ( err = snd_pcm_mmap( driver->playback_handle,
-                                  SND_PCM_CHANNEL_PLAYBACK,
-                                  &driver->playback_mmap,
-                                  &driver->playback_buffer ) ) < 0 )
-            {
-            jack_error( "io-audio: %s: mmap areas info error ",
-                        driver->ioaudio_name_playback );
-            return -1;
-            }
-
-        for( chn = 0; chn < driver->playback_setup.format.voices; chn++ )
-            {
-            driver->playback_addr[chn] = driver->playback_buffer;
-            driver->playback_interleave_skip[chn] =
-                (unsigned long)driver->playback_mmap->status.voices;
-            }
-        }
-
-    return 0;
-}
-
-int ioaudio_driver_start(
-    ioaudio_driver_t *driver )
-{
-    int err;
-    size_t poffset, pavail;
-    channel_t chn;
-
-    driver->poll_last = 0;
-    driver->poll_next = 0;
-
-    if( driver->playback_handle )
-        {
-        if( ( err = snd_pcm_playback_prepare( driver->playback_handle ) ) < 0 )
-            {
-            jack_error( "io-audio: prepare error for playback on "
-                        "\"%s\" (%s)",
-                        driver->ioaudio_name_playback,
-                        snd_strerror( err ) );
-            return -1;
-            }
-        }
-
-    if( ( driver->capture_handle && driver->capture_and_playback_not_synced )
-        || !driver->playback_handle )
-        {
-        if( ( err = snd_pcm_capture_prepare( driver->capture_handle ) ) < 0 )
-            {
-            jack_error( "io-audio: prepare error for capture on \"%s\""
-                        " (%s)",
-                        driver->ioaudio_name_capture,
-                        snd_strerror( err ) );
-            return -1;
-            }
-        }
-
-    if( driver->hw_monitoring )
-        {
-        if( driver->input_monitor_mask || driver->all_monitor_in )
-            {
-            if( driver->all_monitor_in )
-                {
-                driver->hw->set_input_monitor_mask( driver->hw,
-                                                    ~0U );
-                }
-            else
-                {
-                driver->hw->set_input_monitor_mask( driver->hw,
-                                                    driver->input_monitor_mask );
-                }
-            }
-        else
-            {
-            driver->hw->set_input_monitor_mask( driver->hw,
-                                                driver->input_monitor_mask );
-            }
-        }
-
-    if( driver->playback_handle )
-        {
-        /* fill playback buffer with zeroes, and mark
-         all fragments as having data.
-         */
-
-#if 0
-        pavail = snd_pcm_avail_update (driver->playback_handle);
-#else
-        pavail = driver->frames_per_cycle * driver->playback_nperiods;
-#endif
-
-        if( pavail != driver->frames_per_cycle * driver->playback_nperiods )
-            {
-            jack_error( "io-audio: full buffer not available at start" );
-            return -1;
-            }
-
-        if( ioaudio_driver_get_channel_addresses( driver,
-                                                  0,
-                                                  &pavail,
-                                                  0,
-                                                  &poffset ) )
-            {
-            return -1;
-            }
-
-        /* XXX this is cheating. io-audio offers no guarantee that
-         we can access the entire buffer at any one time. It
-         works on most hardware tested so far, however, buts
-         its a liability in the long run. I think that
-         ioaudio-lib may have a better function for doing this
-         here, where the goal is to silence the entire
-         buffer.
-         */
-
-        for( chn = 0; chn < driver->playback_setup.format.voices; chn++ )
-            {
-            ioaudio_driver_silence_on_channel( driver,
-                                               chn,
-                                               driver->user_nperiods
-                                                   * driver->frames_per_cycle );
-            }
-
-        msync( driver->playback_addr,
-               snd_pcm_format_size( driver->playback_setup.format.format,
-                                    driver->user_nperiods
-                                        * driver->frames_per_cycle ),
-               MS_SYNC );
-
-//        if( ( err = snd_pcm_playback_go( driver->playback_handle ) ) < 0 )
-//            {
-//            jack_error( "io-audio: could not start playback (%s)",
-//                        snd_strerror( err ) );
-//            return -1;
-//            }
-        }
-
-//    if( ( driver->capture_handle && driver->capture_and_playback_not_synced )
-//        || !driver->playback_handle )
-//        {
-//        if( ( err = snd_pcm_capture_go( driver->capture_handle ) ) < 0 )
-//            {
-//            jack_error( "io-audio: could not start capture (%s)",
-//                        snd_strerror( err ) );
-//            return -1;
-//            }
-//        }
-
-    return 0;
-}
-
-int ioaudio_driver_stop(
-    ioaudio_driver_t *driver )
-{
-    int err;
-//      JSList* node;
-//      int chn;
-
-    /* silence all capture port buffers, because we might
-     be entering offline mode.
-     */
-
-// JACK2
-    /*
-     for (chn = 0, node = driver->capture_ports; node;
-     node = jack_slist_next (node), chn++) {
-
-     jack_port_t* port;
-     char* buf;
-     jack_nframes_t nframes = driver->engine->control->buffer_size;
-
-     port = (jack_port_t *) node->data;
-     buf = jack_port_get_buffer (port, nframes);
-     memset (buf, 0, sizeof (jack_default_audio_sample_t) * nframes);
-     }
-     */
-
-// JACK2
-    ClearOutput();
-
-    if( driver->playback_handle )
-        {
-        if( ( err = snd_pcm_playback_flush( driver->playback_handle ) ) < 0 )
-            {
-            jack_error( "io-audio: channel flush for playback "
-                        "failed (%s)",
-                        snd_strerror( err ) );
-            return -1;
-            }
-        }
-
-    if( !driver->playback_handle || driver->capture_and_playback_not_synced )
-        {
-        if( driver->capture_handle )
-            {
-            if( ( err = snd_pcm_capture_flush( driver->capture_handle ) ) < 0 )
-                {
-                jack_error( "io-audio: channel flush for "
-                            "capture failed (%s)",
-                            snd_strerror( err ) );
-                return -1;
-                }
-            }
-        }
-
-    if( driver->hw_monitoring )
-        {
-        driver->hw->set_input_monitor_mask( driver->hw,
-                                            0 );
-        }
-
-//        if (driver->midi && !driver->xrun_recovery)
-//                (driver->midi->stop)(driver->midi);
-
-    return 0;
-}
-
-static int ioaudio_driver_restart(
-    ioaudio_driver_t *driver )
-{
-    int res;
-
-    driver->xrun_recovery = 1;
-    // JACK2
-    /*
-     if ((res = driver->nt_stop((struct _jack_driver_nt *) driver))==0)
-     res = driver->nt_start((struct _jack_driver_nt *) driver);
-     */
-    res = Restart();
-    driver->xrun_recovery = 0;
-
-//        if (res && driver->midi)
-//                (driver->midi->stop)(driver->midi);
-
-    return res;
-}
-
-static int ioaudio_driver_xrun_recovery(
-    ioaudio_driver_t *driver,
-    float *delayed_usecs )
-{
-    snd_pcm_channel_status_t status;
-    int res;
-
-    if( driver->capture_handle )
-        {
-        status.channel = SND_PCM_CHANNEL_CAPTURE;
-        if( ( res = snd_pcm_channel_status( driver->capture_handle,
-                                            &status ) ) < 0 )
-            {
-            jack_error( "status error: %s",
-                        snd_strerror( res ) );
-            }
-        }
-    else
-        {
-        status.channel = SND_PCM_CHANNEL_PLAYBACK;
-        if( ( res = snd_pcm_channel_status( driver->playback_handle,
-                                            &status ) )
-            < 0 )
-            {
-            jack_error( "status error: %s",
-                        snd_strerror( res ) );
-            }
-        }
-
-    if( status.status == SND_PCM_STATUS_READY )
-        {
-        jack_log( "**** ioaudio_pcm: pcm in suspended state, resuming it" );
-        if( driver->capture_handle )
-            {
-            if( ( res = snd_pcm_capture_prepare( driver->capture_handle ) )
-                < 0 )
-                {
-                jack_error( "error preparing after suspend: %s",
-                            snd_strerror( res ) );
-                }
-            }
-        else
-            {
-            if( ( res = snd_pcm_playback_prepare( driver->playback_handle ) )
-                < 0 )
-                {
-                jack_error( "error preparing after suspend: %s",
-                            snd_strerror( res ) );
-                }
-            }
-        }
-
-    if( status.status == SND_PCM_STATUS_OVERRUN
-        && driver->process_count > XRUN_REPORT_DELAY )
-        {
-        struct timeval now, diff, tstamp;
-        driver->xrun_count++;
-        gettimeofday( &now,
-                      NULL );
-        tstamp = status.stop_time;
-        timersub( &now,
-                  &tstamp,
-                  &diff );
-        *delayed_usecs = diff.tv_sec * 1000000.0 + diff.tv_usec;
-        jack_log( "**** ioaudio_pcm: xrun of at least %.3f msecs",
-                  *delayed_usecs / 1000.0 );
-        }
-
-    if( ioaudio_driver_restart( driver ) )
-        {
-        return -1;
-        }
-    return 0;
-}
-
-void ioaudio_driver_silence_untouched_channels(
-    ioaudio_driver_t *driver,
-    jack_nframes_t nframes )
-{
-    channel_t chn;
-    jack_nframes_t buffer_frames = driver->frames_per_cycle
-        * driver->playback_nperiods;
-
-    for( chn = 0; chn < driver->playback_setup.format.voices; chn++ )
-        {
-        if( bitset_contains( driver->channels_not_done,
-                             chn ) )
-            {
-            if( driver->silent[chn] < buffer_frames )
-                {
-                ioaudio_driver_silence_on_channel_no_mark( driver,
-                                                           chn,
-                                                           nframes );
-                driver->silent[chn] += nframes;
-                }
-            }
-        }
-}
-
-void ioaudio_driver_set_clock_sync_status(
-    ioaudio_driver_t *driver,
-    channel_t chn,
-    ClockSyncStatus status )
-{
-    driver->clock_sync_data[chn] = status;
-    ioaudio_driver_clock_sync_notify( driver,
-                                      chn,
-                                      status );
-}
-
-static int under_gdb = FALSE;
-
-jack_nframes_t ioaudio_driver_wait(
-    ioaudio_driver_t *driver,
-    int extra_fd,
-    int *status,
-    float *delayed_usecs )
-{
-    ssize_t avail = 0;
-    ssize_t capture_avail = 0;
-    ssize_t playback_avail = 0;
-    int xrun_detected = FALSE;
-    int need_capture;
-    int need_playback;
-    jack_time_t poll_enter;
-    jack_time_t poll_ret = 0;
-
-    *status = -1;
-    *delayed_usecs = 0;
-
-    need_capture = driver->capture_handle ? 1 : 0;
-
-    if( extra_fd >= 0 )
-        {
-        need_playback = 0;
-        }
-    else
-        {
-        need_playback = driver->playback_handle ? 1 : 0;
-        }
-
-    again:
-
-    while( need_playback || need_capture )
-        {
-
-        int poll_result;
-        unsigned short revents;
-
-        if( need_playback )
-            {
-            int fd = snd_pcm_file_descriptor( driver->playback_handle,
-                                              SND_PCM_CHANNEL_PLAYBACK );
-
-            driver->pfd[SND_PCM_CHANNEL_PLAYBACK].fd = fd;
-            driver->pfd[SND_PCM_CHANNEL_PLAYBACK].events = POLLOUT;
-            }
-        else
-            {
-            driver->pfd[SND_PCM_CHANNEL_PLAYBACK].fd = -1;
-            }
-
-        if( extra_fd >= 0 )
-            {
-            driver->pfd[SND_PCM_CHANNEL_PLAYBACK].fd = extra_fd;
-            driver->pfd[SND_PCM_CHANNEL_PLAYBACK].events = POLLIN;
-            }
-
-        if( need_capture )
-            {
-            int fd = snd_pcm_file_descriptor( driver->capture_handle,
-                                              SND_PCM_CHANNEL_CAPTURE );
-
-            driver->pfd[SND_PCM_CHANNEL_CAPTURE].fd = fd;
-            driver->pfd[SND_PCM_CHANNEL_PLAYBACK].events = POLLIN;
-            }
-        else
-            {
-            driver->pfd[SND_PCM_CHANNEL_CAPTURE].fd = -1;
-            }
-
-        poll_enter = jack_get_microseconds();
-
-        if( poll_enter > driver->poll_next )
-            {
-            /*
-             * This processing cycle was delayed past the
-             * next due interrupt!  Do not account this as
-             * a wakeup delay:
-             */
-            driver->poll_next = 0;
-            driver->poll_late++;
-            }
-
-        poll_result = poll( driver->pfd,
-                            SND_PCM_CHANNEL_MAX,
-                            driver->poll_timeout_msecs );
-
-        if( poll_result < 0 )
-            {
-
-            if( errno == EINTR )
-                {
-                jack_info( "poll interrupt" );
-                // this happens mostly when run
-                // under gdb, or when exiting due to a signal
-                if( under_gdb )
-                    {
-                    goto again;
-                    }
-                *status = -2;
-                return 0;
-                }
-
-            jack_error( "io-audio: poll call failed (%s)",
-                        strerror( errno ) );
-            *status = -3;
-            return 0;
-
-            }
-
-        poll_ret = jack_get_microseconds();
-
-        // JACK2
-        SetTime( poll_ret );
-
-        if( extra_fd < 0 )
-            {
-            if( driver->poll_next && poll_ret > driver->poll_next )
-                {
-                *delayed_usecs = poll_ret - driver->poll_next;
-                }
-            driver->poll_last = poll_ret;
-            driver->poll_next = poll_ret + driver->period_usecs;
-// JACK2
-            /*
-             driver->engine->transport_cycle_start (driver->engine,
-             poll_ret);
-             */
-            }
-
-#ifdef DEBUG_WAKEUP
-        fprintf (stderr, "%" PRIu64 ": checked %d fds, started at %" PRIu64 " %" PRIu64 "  usecs since poll entered\n",
-            poll_ret, nfds, poll_enter, poll_ret - poll_enter);
-#endif
-
-        /* check to see if it was the extra FD that caused us
-         * to return from poll */
-
-        if( extra_fd >= 0 )
-            {
-
-            if( driver->pfd[SND_PCM_CHANNEL_PLAYBACK].revents == 0 )
-            //            if( !FD_ISSET( extra_fd, &writefds ) )
-                {
-                /* we timed out on the extra fd */
-
-                *status = -4;
-                return -1;
-                }
-
-            /* if POLLIN was the only bit set, we're OK */
-
-            *status = 0;
-            return
-            ( driver->pfd[SND_PCM_CHANNEL_PLAYBACK].revents == POLLIN ) ?
-                                                                          0 :
-                                                                          -1;
-            }
-
-        if( need_playback )
-            {
-            snd_pcm_channel_status_t chstatus;
-            chstatus.channel = SND_PCM_CHANNEL_PLAYBACK;
-            snd_pcm_channel_status( driver->playback_handle,
-                                    &chstatus );
-
-            revents = driver->pfd[SND_PCM_CHANNEL_PLAYBACK].revents;
-
-            if( revents & POLLERR )
-                {
-                xrun_detected = TRUE;
-                }
-
-            if( revents & POLLOUT )
-                {
-                need_playback = 0;
-#ifdef DEBUG_WAKEUP
-                fprintf (stderr, "%" PRIu64
-                    " playback stream ready\n",
-                    poll_ret);
-#endif
-                }
-            }
-
-        if( need_capture )
-            {
-            snd_pcm_channel_status_t chstatus;
-            chstatus.channel = SND_PCM_CHANNEL_CAPTURE;
-            snd_pcm_channel_status( driver->playback_handle,
-                                    &chstatus );
-
-            revents = driver->pfd[SND_PCM_CHANNEL_CAPTURE].revents;
-
-            if( revents & POLLERR )
-                {
-                xrun_detected = TRUE;
-                }
-
-            if( revents & POLLIN )
-                {
-                need_capture = 0;
-#ifdef DEBUG_WAKEUP
-                fprintf (stderr, "%" PRIu64
-                    " capture stream ready\n",
-                    poll_ret);
-#endif
-                }
-            }
-
-        if( poll_result == 0 )
-            {
-            jack_error( "io-audio: poll time out, polled for %" PRIu64
-                        " usecs",
-                        poll_ret - poll_enter );
-            *status = -5;
-            return 0;
-            }
-
-        }
-
-    if( driver->capture_handle )
-        {
-        capture_avail = driver->capture_setup.buf.block.frag_size
-            / snd_pcm_format_size( driver->capture_setup.format.format,
-                                   1 );
-        }
-    else
-        {
-        capture_avail = INT_MAX;
-        }
-
-    if( driver->playback_handle )
-        {
-        playback_avail = driver->playback_setup.buf.block.frag_size
-            / snd_pcm_format_size( driver->playback_setup.format.format,
-                                   1 );
-        }
-    else
-        {
-        /* odd, but see min() computation below */
-        playback_avail = INT_MAX;
-        }
-
-    if( xrun_detected )
-        {
-        *status = ioaudio_driver_xrun_recovery( driver,
-                                                delayed_usecs );
-        return 0;
-        }
-
-    *status = 0;
-    driver->last_wait_ust = poll_ret;
-
-    avail = capture_avail < playback_avail ? capture_avail : playback_avail;
-
-#ifdef DEBUG_WAKEUP
-    fprintf (stderr, "wakeup complete, avail = %lu, pavail = %lu "
-        "cavail = %lu\n",
-        avail, playback_avail, capture_avail);
-#endif
-
-    /* mark all channels not done for now. read/write will change this */
-
-    bitset_copy( driver->channels_not_done,
-                 driver->channels_done );
-
-    /* constrain the available count to the nearest (round down) number of
-     periods.
-     */
-
-    return avail - ( avail % driver->frames_per_cycle );
-}
-
-int ioaudio_driver_read(
-    ioaudio_driver_t *driver,
-    jack_nframes_t nframes )
-{
-    ssize_t contiguous;
-    ssize_t nread;
-    size_t offset = 0;
-    jack_nframes_t orig_nframes;
-//      jack_default_audio_sample_t* buf;
-//      channel_t chn;
-//      JSList *node;
-//      jack_port_t* port;
-    int err;
-
-    if( nframes > driver->frames_per_cycle )
-        {
-        return -1;
-        }
-
-// JACK2
-    /*
-     if (driver->engine->freewheeling) {
-     return 0;
-     }
-     */
-//        if (driver->midi)
-//                (driver->midi->read)(driver->midi, nframes);
-    if( !driver->capture_handle )
-        {
-        return 0;
-        }
-
-    nread = 0;
-    contiguous = 0;
-    orig_nframes = nframes;
-
-    while( nframes )
-        {
-
-        contiguous = nframes;
-
-        if( ioaudio_driver_get_channel_addresses( driver,
-                                                  (size_t *)&contiguous,
-                                                  (size_t *)0,
-                                                  &offset,
-                                                  0 ) < 0 )
-            {
-            return -1;
-            }
-// JACK2
-        /*
-         for (chn = 0, node = driver->capture_ports; node;
-         node = jack_slist_next (node), chn++) {
-
-         port = (jack_port_t *) node->data;
-
-         if (!jack_port_connected (port)) {
-         // no-copy optimization
-         continue;
-         }
-         buf = jack_port_get_buffer (port, orig_nframes);
-         ioaudio_driver_read_from_channel (driver, chn,
-         buf + nread, contiguous);
-         }
-         */
-        ReadInput( orig_nframes,
-                   contiguous,
-                   nread );
-
-        if( ( err = msync( driver->capture_addr + offset,
-                           contiguous,
-                           MS_SYNC ) )
-            < 0 )
-            {
-            jack_error( "io-audio: could not complete read of %"
-                        PRIu32 " frames: error = %d",
-                        contiguous,
-                        err );
-            return -1;
-            }
-
-        nframes -= contiguous;
-        nread += contiguous;
-        }
-
-    return 0;
-}
-
-int ioaudio_driver_write(
-    ioaudio_driver_t* driver,
-    jack_nframes_t nframes )
-{
-//      channel_t chn;
-//      JSList *node;
-//      JSList *mon_node;
-//      jack_default_audio_sample_t* buf;
-//      jack_default_audio_sample_t* monbuf;
-    jack_nframes_t orig_nframes;
-    ssize_t nwritten;
-    ssize_t contiguous;
-    size_t offset = 0;
-//      jack_port_t *port;
-    int err;
-
-    driver->process_count++;
-
-// JACK2
-    /*
-     if (!driver->playback_handle || driver->engine->freewheeling) {
-     return 0;
-     }
-     */
-    if( !driver->playback_handle )
-        {
-        return 0;
-        }
-
-    if( nframes > driver->frames_per_cycle )
-        {
-        return -1;
-        }
-
-//        if (driver->midi)
-//                (driver->midi->write)(driver->midi, nframes);
-
-    nwritten = 0;
-    contiguous = 0;
-    orig_nframes = nframes;
-
-    /* check current input monitor request status */
-
-    driver->input_monitor_mask = 0;
-
-// JACK2
-    /*
-     for (chn = 0, node = driver->capture_ports; node;
-     node = jack_slist_next (node), chn++) {
-     if (((jack_port_t *) node->data)->shared->monitor_requests) {
-     driver->input_monitor_mask |= (1<<chn);
-     }
-     }
-     */
-    MonitorInput();
-
-    if( driver->hw_monitoring )
-        {
-        if( ( driver->hw->input_monitor_mask != driver->input_monitor_mask )
-            && !driver->all_monitor_in )
-            {
-            driver->hw->set_input_monitor_mask( driver->hw,
-                                                driver->input_monitor_mask );
-            }
-        }
-
-    while( nframes )
-        {
-
-        contiguous = nframes;
-
-        if( ioaudio_driver_get_channel_addresses( driver,
-                                                  (size_t *)0,
-                                                  (size_t *)&contiguous,
-                                                  0,
-                                                  &offset ) < 0 )
-            {
-            return -1;
-            }
-
-// JACK2
-        /*
-         for (chn = 0, node = driver->playback_ports, mon_node=driver->monitor_ports;
-         node;
-         node = jack_slist_next (node), chn++) {
-
-         port = (jack_port_t *) node->data;
-
-         if (!jack_port_connected (port)) {
-         continue;
-         }
-         buf = jack_port_get_buffer (port, orig_nframes);
-         ioaudio_driver_write_to_channel (driver, chn,
-         buf + nwritten, contiguous);
-
-         if (mon_node) {
-         port = (jack_port_t *) mon_node->data;
-         if (!jack_port_connected (port)) {
-         continue;
-         }
-         monbuf = jack_port_get_buffer (port, orig_nframes);
-         memcpy (monbuf + nwritten, buf + nwritten, contiguous * sizeof(jack_default_audio_sample_t));
-         mon_node = jack_slist_next (mon_node);
-         }
-         }
-         */
-
-        // JACK2
-        WriteOutput( orig_nframes,
-                     contiguous,
-                     nwritten );
-
-        if( !bitset_empty( driver->channels_not_done ) )
-            {
-            ioaudio_driver_silence_untouched_channels( driver,
-                                                       contiguous );
-            }
-
-        if( ( err = msync( driver->playback_buffer + offset,
-                           contiguous,
-                           MS_SYNC ) )
-            < 0 )
-            {
-            jack_error( "io-audio: could not complete playback of %"
-                        PRIu32 " frames: error = %d",
-                        contiguous,
-                        err );
-            if( err != -EPIPE && err != -ESTRPIPE )
-                return -1;
-            }
-
-        nframes -= contiguous;
-        nwritten += contiguous;
-        }
-
-    return 0;
-}
-
-#if 0
-static int /* UNUSED */
-ioaudio_driver_change_sample_clock (ioaudio_driver_t *driver, SampleClockMode mode)
-    {
-    return driver->hw->change_sample_clock (driver->hw, mode);
-    }
-
-static void /* UNUSED */
-ioaudio_driver_request_all_monitor_input (ioaudio_driver_t *driver, int yn)
-
-    {
-    if (driver->hw_monitoring)
-        {
-        if (yn)
-            {
-            driver->hw->set_input_monitor_mask (driver->hw, ~0U);
-            }
-        else
-            {
-            driver->hw->set_input_monitor_mask (
-                driver->hw, driver->input_monitor_mask);
-            }
-        }
-
-    driver->all_monitor_in = yn;
-    }
-
-static void /* UNUSED */
-ioaudio_driver_set_hw_monitoring (ioaudio_driver_t *driver, int yn)
-    {
-    if (yn)
-        {
-        driver->hw_monitoring = TRUE;
-
-        if (driver->all_monitor_in)
-            {
-            driver->hw->set_input_monitor_mask (driver->hw, ~0U);
-            }
-        else
-            {
-            driver->hw->set_input_monitor_mask (
-                driver->hw, driver->input_monitor_mask);
-            }
-        }
-    else
-        {
-        driver->hw_monitoring = FALSE;
-        driver->hw->set_input_monitor_mask (driver->hw, 0);
-        }
-    }
-
-static ClockSyncStatus /* UNUSED */
-ioaudio_driver_clock_sync_status (channel_t chn)
-    {
-    return Lock;
-    }
-#endif
-
-void ioaudio_driver_delete(
-    ioaudio_driver_t *driver )
-{
-    JSList *node;
-
-//        if (driver->midi)
-//                (driver->midi->destroy)(driver->midi);
-
-    for( node = driver->clock_sync_listeners; node;
-        node = jack_slist_next( node ) )
-        {
-        free( node->data );
-        }
-    jack_slist_free( driver->clock_sync_listeners );
-
-    if( driver->ctl_handle )
-        {
-        snd_ctl_close( driver->ctl_handle );
-        driver->ctl_handle = 0;
-        }
-
-    if( driver->capture_handle )
-        {
-        snd_pcm_close( driver->capture_handle );
-        driver->capture_handle = 0;
-        }
-
-    if( driver->playback_handle )
-        {
-        snd_pcm_close( driver->playback_handle );
-        driver->capture_handle = 0;
-        }
-
-//    if( driver->pfd )
-//        {
-//        free( driver->pfd );
-//        }
-
-    if( driver->hw )
-        {
-        driver->hw->release( driver->hw );
-        driver->hw = 0;
-        }
-    free( driver->ioaudio_name_playback );
-    free( driver->ioaudio_name_capture );
-    free( driver->ioaudio_driver );
-
-    ioaudio_driver_release_channel_dependent_memory( driver );
-    //JACK2
-    //jack_driver_nt_finish ((jack_driver_nt_t *) driver);
-    free( driver );
-}
-
-//static char*
-//discover_ioaudio_using_apps()
-//{
-//    char found[2048];
-//    char command[5192];
-//    char* path = getenv( "PATH" );
-//    char* dir;
-//    size_t flen = 0;
-//    int card;
-//    int device;
-//    size_t cmdlen = 0;
-//
-//    if( !path )
-//        {
-//        return NULL;
-//        }
-//
-//    /* look for lsof and give up if its not in PATH */
-//
-//    path = strdup( path );
-//    dir = strtok( path,
-//                  ":" );
-//    while( dir )
-//        {
-//        char maybe[PATH_MAX + 1];
-//        snprintf( maybe,
-//                  sizeof( maybe ),
-//                  "%s/lsof",
-//                  dir );
-//        if( access( maybe,
-//                    X_OK ) )
-//            {
-//            break;
-//            }
-//        dir = strtok( NULL,
-//                      ":" );
-//        }
-//    free( path );
-//
-//    if( !dir )
-//        {
-//        return NULL;
-//        }
-//
-//    snprintf( command,
-//              sizeof( command ),
-//              "lsof -Fc0 " );
-//    cmdlen = strlen( command );
-//
-//    for( card = 0; card < 8; ++card )
-//        {
-//        for( device = 0; device < 8; ++device )
-//            {
-//            char buf[32];
-//
-//            snprintf( buf,
-//                      sizeof( buf ),
-//                      "/dev/snd/pcmC%dD%dp",
-//                      card,
-//                      device );
-//            if( access( buf,
-//                        F_OK ) == 0 )
-//                {
-//                snprintf( command + cmdlen,
-//                          sizeof( command ) - cmdlen,
-//                          "%s ",
-//                          buf );
-//                }
-//            cmdlen = strlen( command );
-//
-//            snprintf( buf,
-//                      sizeof( buf ),
-//                      "/dev/snd/pcmC%dD%dc",
-//                      card,
-//                      device );
-//            if( access( buf,
-//                        F_OK ) == 0 )
-//                {
-//                snprintf( command + cmdlen,
-//                          sizeof( command ) - cmdlen,
-//                          "%s ",
-//                          buf );
-//                }
-//            cmdlen = strlen( command );
-//            }
-//        }
-//
-//    FILE* f = popen( command,
-//                     "r" );
-//
-//    if( !f )
-//        {
-//        return NULL;
-//        }
-//
-//    while( !feof( f ) )
-//        {
-//        char buf[1024]; /* lsof doesn't output much */
-//
-//        if( !fgets( buf,
-//                    sizeof( buf ),
-//                    f ) )
-//            {
-//            break;
-//            }
-//
-//        if( *buf != 'p' )
-//            {
-//            return NULL;
-//            }
-//
-//        /* buf contains NULL as a separator between the process field and the command field */
-//        char *pid = buf;
-//        ++pid; /* skip leading 'p' */
-//        char *cmd = pid;
-//
-//        /* skip to NULL */
-//        while( *cmd )
-//            {
-//            ++cmd;
-//            }
-//        ++cmd; /* skip to 'c' */
-//        ++cmd; /* skip to first character of command */
-//
-//        snprintf( found + flen,
-//                  sizeof( found ) - flen,
-//                  "%s (process ID %s)\n",
-//                  cmd,
-//                  pid );
-//        flen = strlen( found );
-//
-//        if( flen >= sizeof( found ) )
-//            {
-//            break;
-//            }
-//        }
-//
-//    pclose( f );
-//
-//    if( flen )
-//        {
-//        return strdup( found );
-//        }
-//    else
-//        {
-//        return NULL;
-//        }
-//}
-
-jack_driver_t *
-ioaudio_driver_new(
-    char *name,
-    jack_client_t *client,
-    ioaudio_driver_args_t args )
-//ioaudio_driver_new(
-//    char *name,
-//    char *playback_pcm_name,
-//    char *capture_pcm_name,
-//    jack_client_t *client,
-//    jack_nframes_t frames_per_interrupt,
-//    jack_nframes_t user_nperiods,
-//    jack_nframes_t srate,
-//    int hw_monitoring,
-//    int hw_metering,
-//    int capture,
-//    int playback,
-//    DitherAlgorithm dither,
-//    int soft_mode,
-//    int monitor,
-//    int user_capture_nchnls,
-//    int user_playback_nchnls,
-//    int shorts_first,
-//    jack_nframes_t systemic_input_latency,
-//    jack_nframes_t systemic_output_latency /*,
-//     ioaudio_midi_t *midi_driver     */
-//    )
-{
-//        int err;
-    char* current_apps;
-    ioaudio_driver_t *driver;
-
-    jack_info( "creating ioaudio driver ... %s|%s|%" PRIu32 "|%" PRIu32
-               "|%" PRIu32"|%" PRIu32"|%" PRIu32 "|%s|%s|%s|%s",
-               args.playback ? args.playback_pcm_name : "-",
-               args.capture ? args.capture_pcm_name : "-",
-               args.frames_per_interrupt,
-               args.user_nperiods,
-               args.srate,
-               args.user_capture_nchnls,
-               args.user_playback_nchnls,
-               args.hw_monitoring ? "hwmon" : "nomon",
-               args.hw_metering ? "hwmeter" : "swmeter",
-               args.soft_mode ? "soft-mode" : "-",
-               args.shorts_first ? "16bit" : "32bit" );
-
-    driver = (ioaudio_driver_t *)calloc( 1,
-                                         sizeof(ioaudio_driver_t) );
-
-    jack_driver_nt_init( (jack_driver_nt_t *)driver );
-
-    // JACK2
-    /*
-     driver->nt_attach = (JackDriverNTAttachFunction) ioaudio_driver_attach;
-     driver->nt_detach = (JackDriverNTDetachFunction) ioaudio_driver_detach;
-     driver->read = (JackDriverReadFunction) ioaudio_driver_read;
-     driver->write = (JackDriverReadFunction) ioaudio_driver_write;
-     driver->null_cycle = (JackDriverNullCycleFunction) ioaudio_driver_null_cycle;
-     driver->nt_bufsize = (JackDriverNTBufSizeFunction) ioaudio_driver_bufsize;
-     driver->nt_start = (JackDriverNTStartFunction) ioaudio_driver_start;
-     driver->nt_stop = (JackDriverNTStopFunction) ioaudio_driver_stop;
-     driver->nt_run_cycle = (JackDriverNTRunCycleFunction) ioaudio_driver_run_cycle;
-     */
-
-    driver->playback_handle = NULL;
-    driver->capture_handle = NULL;
-    driver->ctl_handle = 0;
-    driver->hw = 0;
-    driver->capture_and_playback_not_synced = FALSE;
-    driver->max_nchannels = 0;
-    driver->user_nchannels = 0;
-    driver->user_playback_nchnls = args.user_playback_nchnls;
-    driver->user_capture_nchnls = args.user_capture_nchnls;
-    driver->capture_frame_latency = args.systemic_input_latency;
-    driver->playback_frame_latency = args.systemic_output_latency;
-
-    driver->playback_addr = 0;
-    driver->capture_addr = 0;
-    driver->playback_interleave_skip = NULL;
-    driver->capture_interleave_skip = NULL;
-
-    driver->silent = 0;
-    driver->all_monitor_in = FALSE;
-    driver->with_monitor_ports = args.monitor;
-
-    driver->clock_mode = ClockMaster; /* XXX is it? */
-    driver->input_monitor_mask = 0; /* XXX is it? */
-
-    driver->capture_ports = 0;
-    driver->playback_ports = 0;
-    driver->monitor_ports = 0;
-
-    memset( driver->pfd,
-            0,
-            sizeof( driver->pfd ) );
-
-    driver->dither = args.dither;
-    driver->soft_mode = args.soft_mode;
-
-    driver->quirk_bswap = 0;
-
-    pthread_mutex_init( &driver->clock_sync_lock,
-                        0 );
-    driver->clock_sync_listeners = 0;
-
-    driver->poll_late = 0;
-    driver->xrun_count = 0;
-    driver->process_count = 0;
-
-    driver->ioaudio_name_playback = strdup( args.playback_pcm_name );
-    driver->ioaudio_name_capture = strdup( args.capture_pcm_name );
-
-//        driver->midi = midi_driver;
-    driver->xrun_recovery = 0;
-
-    if( ioaudio_driver_check_card_type( driver ) )
-        {
-        ioaudio_driver_delete( driver );
-        return NULL;
-        }
-
-    ioaudio_driver_hw_specific( driver,
-                                args.hw_monitoring,
-                                args.hw_metering );
-
-    if( args.playback )
-        {
-        if( snd_pcm_open_name( &driver->playback_handle,
-                               args.playback_pcm_name,
-                               SND_PCM_OPEN_PLAYBACK | SND_PCM_OPEN_NONBLOCK )
-            < 0 )
-            {
-            switch(
-            errno )
-                {
-                case EBUSY:
-                    //#ifdef __ANDROID__
-//                    jack_error( "\n\nATTENTION: The playback device \"%s\" is "
-//                                "already in use. Please stop the"
-//                                " application using it and "
-//                                "run JACK again",
-//                                args.playback_pcm_name );
-//#else
-//                    current_apps = discover_ioaudio_using_apps();
-//                    if( current_apps )
-//                        {
-//                        jack_error(
-//                                    "\n\nATTENTION: The playback device \"%s\" is "
-//                                    "already in use. The following applications "
-//                                    " are using your soundcard(s) so you should "
-//                                    " check them and stop them as necessary before "
-//                                    " trying to start JACK again:\n\n%s",
-//                                    playback_pcm_name,
-//                                    current_apps );
-//                        free( current_apps );
-//                        }
-//                    else
-//                        {
-//                        jack_error(
-//                                    "\n\nATTENTION: The playback device \"%s\" is "
-//                                    "already in use. Please stop the"
-//                                    " application using it and "
-//                                    "run JACK again",
-//                                    playback_pcm_name );
-//                        }
-                    jack_error( "\n\nATTENTION: The playback device \"%s\" is "
-                                "already in use. Please stop the"
-                                " application using it and "
-                                "run JACK again",
-                                args.playback_pcm_name );
-                    ioaudio_driver_delete( driver );
-                    return NULL;
-//#endif
-
-                case EPERM:
-                    jack_error( "you do not have permission to open "
-                                "the audio device \"%s\" for playback",
-                                args.playback_pcm_name );
-                    ioaudio_driver_delete( driver );
-                    return NULL;
-                    break;
-                }
-
-            driver->playback_handle = NULL;
-            }
-
-        if( driver->playback_handle )
-            {
-            snd_pcm_nonblock_mode( driver->playback_handle,
-                                   0 );
-            }
-        }
-
-    if( args.capture )
-        {
-        if( snd_pcm_open_name( &driver->capture_handle,
-                               args.capture_pcm_name,
-                               SND_PCM_OPEN_CAPTURE | SND_PCM_OPEN_NONBLOCK )
-            < 0 )
-            {
-            switch(
-            errno )
-                {
-                case EBUSY:
-                    //#ifdef __ANDROID__
-//                    jack_error ("\n\nATTENTION: The capture (recording) device \"%s\" is "
-//                        "already in use",
-//                        capture_pcm_name);
-//#else
-//                    current_apps = discover_ioaudio_using_apps();
-//                    if( current_apps )
-//                        {
-//                        jack_error(
-//                                    "\n\nATTENTION: The capture device \"%s\" is "
-//                                    "already in use. The following applications "
-//                                    " are using your soundcard(s) so you should "
-//                                    " check them and stop them as necessary before "
-//                                    " trying to start JACK again:\n\n%s",
-//                                    args.capture_pcm_name,
-//                                    current_apps );
-//                        free( current_apps );
-//                        }
-//                    else
-//                        {
-//                        jack_error(
-//                                    "\n\nATTENTION: The capture (recording) device \"%s\" is "
-//                                    "already in use. Please stop the"
-//                                    " application using it and "
-//                                    "run JACK again",
-//                                    args.capture_pcm_name );
-//                        }
-//#endif
-                    jack_error(
-                                "\n\nATTENTION: The capture (recording) device \"%s\" is "
-                                "already in use. Please stop the"
-                                " application using it and "
-                                "run JACK again",
-                                args.capture_pcm_name );
-                    ioaudio_driver_delete( driver );
-                    return NULL;
-                    break;
-
-                case EPERM:
-                    jack_error( "you do not have permission to open "
-                                "the audio device \"%s\" for capture",
-                                args.capture_pcm_name );
-                    ioaudio_driver_delete( driver );
-                    return NULL;
-                    break;
-                }
-
-            driver->capture_handle = NULL;
-            }
-
-        if( driver->capture_handle )
-            {
-            snd_pcm_nonblock_mode( driver->capture_handle,
-                                   0 );
-            }
-        }
-
-    if( driver->playback_handle == NULL )
-        {
-        if( args.playback )
-            {
-
-            /* they asked for playback, but we can't do it */
-
-            jack_error( "io-audio: Cannot open PCM device %s for "
-                        "playback. Falling back to capture-only"
-                        " mode",
-                        name );
-
-            if( driver->capture_handle == NULL )
-                {
-                /* can't do anything */
-                ioaudio_driver_delete( driver );
-                return NULL;
-                }
-
-            args.playback = FALSE;
-            }
-        }
-
-    if( driver->capture_handle == NULL )
-        {
-        if( args.capture )
-            {
-
-            /* they asked for capture, but we can't do it */
-
-            jack_error( "io-audio: Cannot open PCM device %s for "
-                        "capture. Falling back to playback-only"
-                        " mode",
-                        name );
-
-            if( driver->playback_handle == NULL )
-                {
-                /* can't do anything */
-                ioaudio_driver_delete( driver );
-                return NULL;
-                }
-
-            args.capture = FALSE;
-            }
-        }
-
-    if( ioaudio_driver_set_parameters( driver,
-                                       args.frames_per_interrupt,
-                                       args.user_nperiods,
-                                       args.srate ) )
-        {
-        ioaudio_driver_delete( driver );
-        return NULL;
-        }
-
-    driver->capture_and_playback_not_synced = FALSE;
-
-    if( driver->capture_handle && driver->playback_handle )
-        {
-        if( snd_pcm_link( driver->playback_handle,
-                          driver->capture_handle ) != 0 )
-            {
-            driver->capture_and_playback_not_synced = TRUE;
-            }
-        }
-
-    driver->client = client;
-
-    return (jack_driver_t *)driver;
-}
-
-int ioaudio_driver_listen_for_clock_sync_status(
-    ioaudio_driver_t *driver,
-    ClockSyncListenerFunction func,
-    void *arg )
-{
-    ClockSyncListener *csl;
-
-    csl = (ClockSyncListener *)malloc( sizeof(ClockSyncListener) );
-    csl->function = func;
-    csl->arg = arg;
-    csl->id = driver->next_clock_sync_listener_id++;
-
-    pthread_mutex_lock( &driver->clock_sync_lock );
-    driver->clock_sync_listeners =
-        jack_slist_prepend(
-                            driver->clock_sync_listeners,
-                            csl );
-    pthread_mutex_unlock( &driver->clock_sync_lock );
-    return csl->id;
-}
-
-int ioaudio_driver_stop_listening_to_clock_sync_status(
-    ioaudio_driver_t *driver,
-    unsigned int which )
-
-{
-    JSList *node;
-    int ret = -1;
-    pthread_mutex_lock( &driver->clock_sync_lock );
-    for( node = driver->clock_sync_listeners; node;
-        node = jack_slist_next( node ) )
-        {
-        if( ( (ClockSyncListener *)node->data )->id == which )
-            {
-            driver->clock_sync_listeners =
-                jack_slist_remove_link(
-                                        driver->clock_sync_listeners,
-                                        node );
-            free( node->data );
-            jack_slist_free_1( node );
-            ret = 0;
-            break;
-            }
-        }
-    pthread_mutex_unlock( &driver->clock_sync_lock );
-    return ret;
-}
-
-void ioaudio_driver_clock_sync_notify(
-    ioaudio_driver_t *driver,
-    channel_t chn,
-    ClockSyncStatus status )
-{
-    JSList *node;
-
-    pthread_mutex_lock( &driver->clock_sync_lock );
-    for( node = driver->clock_sync_listeners; node;
-        node = jack_slist_next( node ) )
-        {
-        ClockSyncListener *csl = (ClockSyncListener *)node->data;
-        csl->function( chn,
-                       status,
-                       csl->arg );
-        }
-    pthread_mutex_unlock( &driver->clock_sync_lock );
-
-}
-
-/* DRIVER "PLUGIN" INTERFACE */
-
-const char driver_client_name[] = "ioaudio_pcm";
-
-void driver_finish(
-    jack_driver_t *driver )
-{
-    ioaudio_driver_delete( (ioaudio_driver_t *)driver );
-}
diff --git a/qnx/ioaudio/ioaudio_backend.h b/qnx/ioaudio/ioaudio_backend.h
deleted file mode 100644
index f351d085..00000000
--- a/qnx/ioaudio/ioaudio_backend.h
+++ /dev/null
@@ -1,386 +0,0 @@
-/*
- Copyright (C) 2001 Paul Davis
-
- This program 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 2 of the License, or
- (at your option) any later version.
-
- This program 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 this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
- $Id: ioaudio_driver.h 945 2006-05-04 15:14:45Z pbd $
- */
-
-#ifndef __jack_ioaudio_driver_h__
-#define __jack_ioaudio_driver_h__
-
-#include <sys/asoundlib.h>
-#include <sys/poll.h>
-#include "bitset.h"
-
-#if __BYTE_ORDER == __LITTLE_ENDIAN
-#define IS_LE 0
-#define IS_BE 1
-#elif __BYTE_ORDER == __BIG_ENDIAN
-#define IS_LE 1
-#define IS_BE 0
-#endif
-
-#define TRUE 1
-#define FALSE 0
-
-#include "types.h"
-#include "hardware.h"
-#include "driver.h"
-#include "memops.h"
-//#include "ioaudio_midi.h"
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    typedef void (*ReadCopyFunction)(
-        jack_default_audio_sample_t *dst,
-        char *src,
-        unsigned long src_bytes,
-        unsigned long src_skip_bytes );
-    typedef void (*WriteCopyFunction)(
-        char *dst,
-        jack_default_audio_sample_t *src,
-        unsigned long src_bytes,
-        unsigned long dst_skip_bytes,
-        dither_state_t *state );
-
-    typedef struct _ioaudio_driver_args
-    {
-        char* device;
-
-        char capture;
-        const char* capture_pcm_name;
-        size_t user_capture_nchnls;
-
-        char playback;
-        const char* playback_pcm_name;
-        size_t user_playback_nchnls;
-
-        size_t srate;
-        size_t frames_per_interrupt;
-        size_t user_nperiods;
-        DitherAlgorithm dither;
-        char hw_monitoring;
-        char hw_metering;
-        char duplex;
-        char soft_mode;
-        char monitor;
-        char shorts_first;
-        size_t systemic_input_latency;
-        size_t systemic_output_latency;
-        const char* midi_driver;
-    } ioaudio_driver_args_t;
-
-    typedef struct _ioaudio_driver
-    {
-
-        JACK_DRIVER_NT_DECL
-
-        int poll_timeout_msecs;
-        jack_time_t poll_last;
-        jack_time_t poll_next;
-        char **playback_addr;
-        char **capture_addr;
-        struct pollfd pfd[SND_PCM_CHANNEL_MAX];
-        unsigned long interleave_unit;
-        unsigned long *capture_interleave_skip;
-        unsigned long *playback_interleave_skip;
-        channel_t max_nchannels;
-        channel_t user_nchannels;
-        int user_capture_nchnls;
-        int user_playback_nchnls;
-
-        jack_nframes_t frame_rate;
-        jack_nframes_t frames_per_cycle;
-        jack_nframes_t capture_frame_latency;
-        jack_nframes_t playback_frame_latency;
-
-        unsigned long *silent;
-        char *ioaudio_name_playback;
-        char *ioaudio_name_capture;
-        char *ioaudio_driver;
-        bitset_t channels_not_done;
-        bitset_t channels_done;
-        float max_sample_val;
-        unsigned long user_nperiods;
-        unsigned int playback_nperiods;
-        unsigned int capture_nperiods;
-        unsigned long last_mask;
-        snd_ctl_t *ctl_handle;
-
-        snd_pcm_t *playback_handle;
-        snd_pcm_channel_params_t playback_params;
-        snd_pcm_channel_setup_t playback_setup;
-        snd_pcm_mmap_control_t *playback_mmap;
-        void *playback_buffer;
-
-        snd_pcm_t *capture_handle;
-        snd_pcm_channel_params_t capture_params;
-        snd_pcm_channel_setup_t capture_setup;
-        snd_pcm_mmap_control_t *capture_mmap;
-        void *capture_buffer;
-
-        jack_hardware_t *hw;
-        ClockSyncStatus *clock_sync_data;
-        jack_client_t *client;
-        JSList *capture_ports;
-        JSList *playback_ports;
-        JSList *monitor_ports;
-
-        unsigned long input_monitor_mask;
-
-        char soft_mode;
-        char hw_monitoring;
-        char hw_metering;
-        char all_monitor_in;
-        char capture_and_playback_not_synced;
-        char with_monitor_ports;
-        char has_clock_sync_reporting;
-        char has_hw_monitoring;
-        char has_hw_metering;
-        char quirk_bswap;
-
-        ReadCopyFunction read_via_copy;
-        WriteCopyFunction write_via_copy;
-
-        int dither;
-        dither_state_t *dither_state;
-
-        SampleClockMode clock_mode;
-        JSList *clock_sync_listeners;
-        pthread_mutex_t clock_sync_lock;
-        unsigned long next_clock_sync_listener_id;
-
-        int running;
-        int run;
-
-        int poll_late;
-        int xrun_count;
-        int process_count;
-
-//    ioaudio_midi_t *midi;
-        char *midi;
-        int xrun_recovery;
-
-    } ioaudio_driver_t;
-
-    static inline void
-    ioaudio_driver_mark_channel_done(
-        ioaudio_driver_t *driver,
-        channel_t chn )
-    {
-        bitset_remove( driver->channels_not_done,
-                       chn );
-        driver->silent[chn] = 0;
-    }
-
-    static inline void
-    ioaudio_driver_silence_on_channel(
-        ioaudio_driver_t *driver,
-        channel_t chn,
-        jack_nframes_t nframes )
-    {
-        if( driver->playback_setup.format.interleave )
-            {
-            memset_interleave
-            ( driver->playback_addr[chn],
-              0,
-              snd_pcm_format_size(
-                                   driver->playback_setup.format.format,
-                                   nframes ),
-              driver->interleave_unit,
-              driver->playback_interleave_skip[chn] );
-            }
-        else
-            {
-            memset( driver->playback_addr[chn],
-                    0,
-                    snd_pcm_format_size(
-                                         driver->playback_setup.format.format,
-                                         nframes ) );
-            }
-        ioaudio_driver_mark_channel_done( driver,
-                                          chn );
-    }
-
-    static inline void
-    ioaudio_driver_silence_on_channel_no_mark(
-        ioaudio_driver_t *driver,
-        channel_t chn,
-        jack_nframes_t nframes )
-    {
-        if( driver->playback_setup.format.interleave )
-            {
-            memset_interleave
-            ( driver->playback_addr[chn],
-              0,
-              snd_pcm_format_size(
-                                   driver->playback_setup.format.format,
-                                   nframes ),
-              driver->interleave_unit,
-              driver->playback_interleave_skip[chn] );
-            }
-        else
-            {
-            memset( driver->playback_addr[chn],
-                    0,
-                    snd_pcm_format_size(
-                                         driver->playback_setup.format.format,
-                                         nframes ) );
-            }
-    }
-
-    static inline void
-    ioaudio_driver_read_from_channel(
-        ioaudio_driver_t *driver,
-        channel_t channel,
-        jack_default_audio_sample_t *buf,
-        jack_nframes_t nsamples )
-    {
-        driver->read_via_copy( buf,
-                               driver->capture_addr[channel],
-                               nsamples,
-                               driver->capture_interleave_skip[channel] );
-    }
-
-    static inline void
-    ioaudio_driver_write_to_channel(
-        ioaudio_driver_t *driver,
-        channel_t channel,
-        jack_default_audio_sample_t *buf,
-        jack_nframes_t nsamples )
-    {
-        driver->write_via_copy( driver->playback_addr[channel],
-                                buf,
-                                nsamples,
-                                driver->playback_interleave_skip[channel],
-                                driver->dither_state + channel );
-        ioaudio_driver_mark_channel_done( driver,
-                                          channel );
-    }
-
-    void ioaudio_driver_silence_untouched_channels(
-        ioaudio_driver_t *driver,
-        jack_nframes_t nframes );
-    void ioaudio_driver_set_clock_sync_status(
-        ioaudio_driver_t *driver,
-        channel_t chn,
-        ClockSyncStatus status );
-    int ioaudio_driver_listen_for_clock_sync_status(
-        ioaudio_driver_t *,
-        ClockSyncListenerFunction,
-        void *arg );
-    int ioaudio_driver_stop_listen_for_clock_sync_status(
-        ioaudio_driver_t *,
-        unsigned int );
-    void ioaudio_driver_clock_sync_notify(
-        ioaudio_driver_t *,
-        channel_t chn,
-        ClockSyncStatus );
-
-    int
-    ioaudio_driver_reset_parameters(
-        ioaudio_driver_t *driver,
-        jack_nframes_t frames_per_cycle,
-        jack_nframes_t user_nperiods,
-        jack_nframes_t rate );
-
-    jack_driver_t *
-    ioaudio_driver_new(
-        char *name,
-        jack_client_t *client,
-        ioaudio_driver_args_t args
-        );
-
-//    jack_driver_t *
-//    ioaudio_driver_new(
-//        char *name,
-//        char *playback_ioaudio_device,
-//        char *capture_ioaudio_device,
-//        jack_client_t *client,
-//        jack_nframes_t frames_per_cycle,
-//        jack_nframes_t user_nperiods,
-//        jack_nframes_t rate,
-//        int hw_monitoring,
-//        int hw_metering,
-//        int capturing,
-//        int playing,
-//        DitherAlgorithm dither,
-//        int soft_mode,
-//        int monitor,
-//        int user_capture_nchnls,
-//        int user_playback_nchnls,
-//        int shorts_first,
-//        jack_nframes_t capture_latency,
-//        jack_nframes_t playback_latency /*,
-//         ioaudio_midi_t *midi_driver     */
-//        );
-    void
-    ioaudio_driver_delete(
-        ioaudio_driver_t *driver );
-
-    int
-    ioaudio_driver_start(
-        ioaudio_driver_t *driver );
-
-    int
-    ioaudio_driver_stop(
-        ioaudio_driver_t *driver );
-
-    jack_nframes_t
-    ioaudio_driver_wait(
-        ioaudio_driver_t *driver,
-        int extra_fd,
-        int *status,
-        float
-        *delayed_usecs );
-
-    int
-    ioaudio_driver_read(
-        ioaudio_driver_t *driver,
-        jack_nframes_t nframes );
-
-    int
-    ioaudio_driver_write(
-        ioaudio_driver_t* driver,
-        jack_nframes_t nframes );
-
-    jack_time_t jack_get_microseconds(
-        void );
-
-// Code implemented in JackioaudioDriver.cpp
-
-    void ReadInput(
-        jack_nframes_t orig_nframes,
-        ssize_t contiguous,
-        ssize_t nread );
-    void MonitorInput();
-    void ClearOutput();
-    void WriteOutput(
-        jack_nframes_t orig_nframes,
-        ssize_t contiguous,
-        ssize_t nwritten );
-    void SetTime(
-        jack_time_t time );
-    int Restart();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __jack_ioaudio_driver_h__ */
diff --git a/qnx/wscript b/qnx/wscript
index 600dd653..9202d209 100644
--- a/qnx/wscript
+++ b/qnx/wscript
@@ -44,8 +44,8 @@ def build(bld):
 
     ioaudio_driver_src = [
                '../common/memops.c',
-               'ioaudio/generic_hw.c',
-               'ioaudio/ioaudio_backend.c',
+               #'ioaudio/generic_hw.c',
+               #'ioaudio/ioaudio_backend.c',
                'ioaudio/JackIoAudioDriver.cpp',
                ]
     create_jack_driver_obj(bld, 'ioaudio', ioaudio_driver_src, ['IOAUDIO', 'PTHREAD'])