Merge lp:~artfwo/ubuntu/precise/jackd2/jackd2-fix-911342 into lp:ubuntu/precise/jackd2

[Artem Popov]

* Merge from debian unstable (LP: #911342), remaining changes:
  - Drop libcelt build dependency
  - debian/gbp.conf: Set debian-branch to ubuntu
  - Drop dh-buildinfo build-dependency; this creates conflicting
    per-architecture buildinfo.gz files that prevent multiarch
    co-installability, and all this information is already available in the
    build logs.
  - Build for multiarch. LP: #861025.
  - Build using dh_python2

[Sebastien Bacher (seb128)]

Thank you for your work, it's a bit weird that the diff lists no change in debian directory, it should at least have a new changelog revision? I will look at the debdiff on the bug

[Sebastien Bacher (seb128)]

Hum, Debian got a new version in testing since, do you think you could rebase your work on this one?

[Sebastien Bacher (seb128)]

(settings to "Work in progress" please set it back to "Needs review" when you update so it's showing up in the queue again)

[Artem Popov (artfwo)]

Pulled in latest Debian changes. Updated the debdiff on the bug page as well. Setting to 'Needs review' again.

[Sebastien Bacher (seb128)]

Thank you for your work, for some reason I've issues with the vcs but the debdiff looks fine so I'm sponsoring that

review: Approve

=== removed file '.pc/applied-patches'
--- .pc/applied-patches	2011-08-08 14:38:08 +0000
+++ .pc/applied-patches	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-hppa-parallel.patch
-hurd.patch
-no-selfconnect.patch
-sh4.patch

=== removed directory '.pc/hppa-parallel.patch'
=== removed directory '.pc/hppa-parallel.patch/.waf-1.5.0-8e39a4c1c16303c1e8f010bf330305f6'
=== removed directory '.pc/hppa-parallel.patch/.waf-1.5.0-8e39a4c1c16303c1e8f010bf330305f6/wafadmin'
=== removed file '.pc/hppa-parallel.patch/.waf-1.5.0-8e39a4c1c16303c1e8f010bf330305f6/wafadmin/Runner.py'
--- .pc/hppa-parallel.patch/.waf-1.5.0-8e39a4c1c16303c1e8f010bf330305f6/wafadmin/Runner.py	2010-06-19 18:54:29 +0000
+++ .pc/hppa-parallel.patch/.waf-1.5.0-8e39a4c1c16303c1e8f010bf330305f6/wafadmin/Runner.py	1970-01-01 00:00:00 +0000
@@ -1,145 +0,0 @@
-#! /usr/bin/env python
-# encoding: utf-8
-import sys
-if sys.hexversion < 0x020400f0: from sets import Set as set
-import sys,random,time,threading,Queue,traceback
-import Build,Utils,Logs,Options
-import pproc
-from Logs import debug,error
-from Constants import*
-GAP=15
-run_old=threading.Thread.run
-def run(*args,**kwargs):
-	try:
-		run_old(*args,**kwargs)
-	except(KeyboardInterrupt,SystemExit):
-		raise
-	except:
-		sys.excepthook(*sys.exc_info())
-threading.Thread.run=run
-class TaskConsumer(threading.Thread):
-	def __init__(self,m):
-		threading.Thread.__init__(self)
-		self.setDaemon(1)
-		self.master=m
-		self.start()
-	def run(self):
-		try:
-			self.loop()
-		except:
-			pass
-	def loop(self):
-		m=self.master
-		while 1:
-			tsk=m.ready.get()
-			if m.stop:
-				m.out.put(tsk)
-				continue
-			try:
-				tsk.generator.bld.printout(tsk.display())
-				if tsk.__class__.stat:ret=tsk.__class__.stat(tsk)
-				else:ret=tsk.call_run()
-			except Exception,e:
-				tsk.err_msg=Utils.ex_stack()
-				tsk.hasrun=EXCEPTION
-				m.error_handler(tsk)
-				m.out.put(tsk)
-				continue
-			if ret:
-				tsk.err_code=ret
-				tsk.hasrun=CRASHED
-			else:
-				try:
-					tsk.post_run()
-				except OSError:
-					tsk.hasrun=MISSING
-				else:
-					tsk.hasrun=SUCCESS
-			if tsk.hasrun!=SUCCESS:
-				m.error_handler(tsk)
-			m.out.put(tsk)
-class Parallel(object):
-	def __init__(self,bld,j=2):
-		self.numjobs=j
-		self.manager=bld.task_manager
-		self.total=self.manager.total()
-		self.outstanding=[]
-		self.maxjobs=sys.maxint
-		self.frozen=[]
-		self.ready=Queue.Queue(0)
-		self.out=Queue.Queue(0)
-		self.count=0
-		self.stuck=0
-		self.processed=1
-		self.consumers=None
-		self.stop=False
-		self.error=False
-	def get_next(self):
-		if not self.outstanding:
-			return None
-		return self.outstanding.pop(0)
-	def postpone(self,tsk):
-		if random.randint(0,1):
-			self.frozen.insert(0,tsk)
-		else:
-			self.frozen.append(tsk)
-	def refill_task_list(self):
-		while self.count>self.numjobs+GAP or self.count>self.maxjobs:
-			self.get_out()
-		while not self.outstanding:
-			if self.count:
-				self.get_out()
-			if self.frozen:
-				self.outstanding+=self.frozen
-				self.frozen=[]
-			elif not self.count:
-				(self.maxjobs,tmp)=self.manager.get_next_set()
-				if tmp:self.outstanding+=tmp
-				break
-	def get_out(self):
-		ret=self.out.get()
-		self.manager.add_finished(ret)
-		if not self.stop and getattr(ret,'more_tasks',None):
-			self.outstanding+=ret.more_tasks
-			self.total+=len(ret.more_tasks)
-		self.count-=1
-	def error_handler(self,tsk):
-		if not Options.options.keep:
-			self.stop=True
-		self.error=True
-	def start(self):
-		while not self.stop:
-			self.refill_task_list()
-			tsk=self.get_next()
-			if not tsk:
-				if self.count:
-					continue
-				else:
-					break
-			if tsk.hasrun:
-				self.processed+=1
-				self.manager.add_finished(tsk)
-			try:
-				st=tsk.runnable_status()
-			except Exception,e:
-				tsk.err_msg=Utils.ex_stack()
-				tsk.hasrun=EXCEPTION
-				self.processed+=1
-				self.error_handler(tsk)
-				self.manager.add_finished(tsk)
-				continue
-			if st==ASK_LATER:
-				self.postpone(tsk)
-			elif st==SKIP_ME:
-				self.processed+=1
-				tsk.hasrun=SKIPPED
-				self.manager.add_finished(tsk)
-			else:
-				tsk.position=(self.processed,self.total)
-				self.count+=1
-				self.ready.put(tsk)
-				self.processed+=1
-				if not self.consumers:
-					self.consumers=[TaskConsumer(self)for i in xrange(self.numjobs)]
-		assert(self.count==0 or self.stop)
-

=== removed directory '.pc/hurd.patch'
=== removed directory '.pc/hurd.patch/dbus'
=== removed file '.pc/hurd.patch/dbus/sigsegv.c'
--- .pc/hurd.patch/dbus/sigsegv.c	2010-08-01 19:54:32 +0000
+++ .pc/hurd.patch/dbus/sigsegv.c	1970-01-01 00:00:00 +0000
@@ -1,202 +0,0 @@
-/**
- * This source file is used to print out a stack-trace when your program
- * segfaults.  It is relatively reliable and spot-on accurate.
- *
- * This code is in the public domain.  Use it as you see fit, some credit
- * would be appreciated, but is not a prerequisite for usage.  Feedback
- * on it's use would encourage further development and maintenance.
- *
- * Author:  Jaco Kroon <[e-mail]>
- *
- * Copyright (C) 2005 - 2008 Jaco Kroon
- */
-
-#if defined(HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
-//#define NO_CPP_DEMANGLE
-#define SIGSEGV_NO_AUTO_INIT
-
-#ifndef _GNU_SOURCE
-# define _GNU_SOURCE
-#endif
-
-#include <memory.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <signal.h>
-#include <dlfcn.h>
-#include <execinfo.h>
-#include <errno.h>
-#ifndef NO_CPP_DEMANGLE
-char * __cxa_demangle(const char * __mangled_name, char * __output_buffer, size_t * __length, int * __status);
-#endif
-
-#include "JackError.h"
-
-#if defined(REG_RIP)
-# define SIGSEGV_STACK_IA64
-# define REGFORMAT "%016lx"
-#elif defined(REG_EIP)
-# define SIGSEGV_STACK_X86
-# define REGFORMAT "%08x"
-#else
-# define SIGSEGV_STACK_GENERIC
-# define REGFORMAT "%x"
-#endif
-
-#ifdef __APPLE__
-
-// TODO : does not compile yet on OSX
-static void signal_segv(int signum, siginfo_t* info, void*ptr) 
-{}
-
-#else
-
-#include <ucontext.h>
-
-static void signal_segv(int signum, siginfo_t* info, void*ptr) {
-    static const char *si_codes[3] = {"", "SEGV_MAPERR", "SEGV_ACCERR"};
-
-    size_t i;
-    ucontext_t *ucontext = (ucontext_t*)ptr;
-
-#if defined(SIGSEGV_STACK_X86) || defined(SIGSEGV_STACK_IA64)
-    int f = 0;
-    Dl_info dlinfo;
-    void **bp = 0;
-    void *ip = 0;
-#else
-    void *bt[20];
-    char **strings;
-    size_t sz;
-#endif
-
-    if (signum == SIGSEGV)
-    {
-        jack_error("Segmentation Fault!");
-    }
-    else if (signum == SIGABRT)
-    {
-        jack_error("Abort!");
-    }
-    else if (signum == SIGILL)
-    {
-        jack_error("Illegal instruction!");
-    }
-    else if (signum == SIGFPE)
-    {
-        jack_error("Floating point exception!");
-    }
-    else
-    {
-        jack_error("Unknown bad signal catched!");
-    }
-
-    jack_error("info.si_signo = %d", signum);
-    jack_error("info.si_errno = %d", info->si_errno);
-    jack_error("info.si_code  = %d (%s)", info->si_code, si_codes[info->si_code]);
-    jack_error("info.si_addr  = %p", info->si_addr);
-#if !defined(__alpha__) && !defined(__ia64__) && !defined(__FreeBSD_kernel__) && !defined(__arm__) && !defined(__hppa__) && !defined(__sh__)
-    for(i = 0; i < NGREG; i++)
-        jack_error("reg[%02d]       = 0x" REGFORMAT, i, 
-#if defined(__powerpc__)
-                ucontext->uc_mcontext.uc_regs[i]
-#elif defined(__sparc__) && defined(__arch64__)
-                ucontext->uc_mcontext.mc_gregs[i]
-#else
-                ucontext->uc_mcontext.gregs[i]
-#endif
-                );
-#endif /* alpha, ia64, kFreeBSD, arm, hppa */
-
-#if defined(SIGSEGV_STACK_X86) || defined(SIGSEGV_STACK_IA64)
-# if defined(SIGSEGV_STACK_IA64)
-    ip = (void*)ucontext->uc_mcontext.gregs[REG_RIP];
-    bp = (void**)ucontext->uc_mcontext.gregs[REG_RBP];
-# elif defined(SIGSEGV_STACK_X86)
-    ip = (void*)ucontext->uc_mcontext.gregs[REG_EIP];
-    bp = (void**)ucontext->uc_mcontext.gregs[REG_EBP];
-# endif
-
-    jack_error("Stack trace:");
-    while(bp && ip) {
-        if(!dladdr(ip, &dlinfo))
-            break;
-
-        const char *symname = dlinfo.dli_sname;
-#ifndef NO_CPP_DEMANGLE
-        int status;
-        char *tmp = __cxa_demangle(symname, NULL, 0, &status);
-
-        if(status == 0 && tmp)
-            symname = tmp;
-#endif
-
-        jack_error("% 2d: %p <%s+%u> (%s)",
-                ++f,
-                ip,
-                symname,
-                (unsigned)(ip - dlinfo.dli_saddr),
-                dlinfo.dli_fname);
-
-#ifndef NO_CPP_DEMANGLE
-        if(tmp)
-            free(tmp);
-#endif
-
-        if(dlinfo.dli_sname && !strcmp(dlinfo.dli_sname, "main"))
-            break;
-
-        ip = bp[1];
-        bp = (void**)bp[0];
-    }
-#else
-    jack_error("Stack trace (non-dedicated):");
-    sz = backtrace(bt, 20);
-    strings = backtrace_symbols(bt, sz);
-
-    for(i = 0; i < sz; ++i)
-        jack_error("%s", strings[i]);
-#endif
-    jack_error("End of stack trace");
-    exit (-1);
-}
-
-#endif
-
-int setup_sigsegv() {
-    struct sigaction action;
-
-    memset(&action, 0, sizeof(action));
-    action.sa_sigaction = signal_segv;
-    action.sa_flags = SA_SIGINFO;
-    if(sigaction(SIGSEGV, &action, NULL) < 0) {
-        jack_error("sigaction failed. errno is %d (%s)", errno, strerror(errno));
-        return 0;
-    }
-
-    if(sigaction(SIGILL, &action, NULL) < 0) {
-        jack_error("sigaction failed. errno is %d (%s)", errno, strerror(errno));
-        return 0;
-    }
-
-    if(sigaction(SIGABRT, &action, NULL) < 0) {
-        jack_error("sigaction failed. errno is %d (%s)", errno, strerror(errno));
-        return 0;
-    }
-
-    if(sigaction(SIGFPE, &action, NULL) < 0) {
-        jack_error("sigaction failed. errno is %d (%s)", errno, strerror(errno));
-        return 0;
-    }
-
-    return 1;
-}
-
-#ifndef SIGSEGV_NO_AUTO_INIT
-static void __attribute((constructor)) init(void) {
-    setup_sigsegv();
-}
-#endif

=== removed directory '.pc/no-selfconnect.patch'
=== removed directory '.pc/no-selfconnect.patch/common'
=== removed file '.pc/no-selfconnect.patch/common/JackConstants.h'
--- .pc/no-selfconnect.patch/common/JackConstants.h	2011-01-29 19:00:05 +0000
+++ .pc/no-selfconnect.patch/common/JackConstants.h	1970-01-01 00:00:00 +0000
@@ -1,82 +0,0 @@
-/*
- Copyright (C) 2004-2008 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 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.
-
-*/
-
-#ifndef __JackConstants__
-#define __JackConstants__
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#define VERSION "1.9.7"
-
-#define BUFFER_SIZE_MAX 8192
-
-#define JACK_PORT_NAME_SIZE 256
-#define JACK_PORT_TYPE_SIZE 32
-
-#define JACK_CLIENT_NAME_SIZE 64
-#define JACK_MESSAGE_SIZE 256
-#define JACK_UUID_SIZE 32
-#define JACK_SESSION_COMMAND_SIZE 256
-
-#ifndef PORT_NUM
-#define PORT_NUM 2048
-#endif
-
-#define PORT_NUM_MAX 4096           // The "max" value for ports used in connection manager, although port number in graph manager is dynamic
-
-#define DRIVER_PORT_NUM 256
-
-#ifndef PORT_NUM_FOR_CLIENT
-#define PORT_NUM_FOR_CLIENT 768
-#endif
-
-#define FIRST_AVAILABLE_PORT 1
-
-#define CONNECTION_NUM_FOR_PORT PORT_NUM_FOR_CLIENT
-
-#ifndef CLIENT_NUM
-#define CLIENT_NUM 64
-#endif
-
-#define AUDIO_DRIVER_REFNUM   0                 // Audio driver is initialized first, it will get the refnum 0
-#define FREEWHEEL_DRIVER_REFNUM   1             // Freewheel driver is initialized second, it will get the refnum 1
-
-#define JACK_DEFAULT_SERVER_NAME "default"
-
-#define jack_server_entry "jackdmp_entry"
-#define jack_client_entry "jack_client"
-
-#define ALL_CLIENTS -1 // for notification
-
-#define JACK_PROTOCOL_VERSION 8
-
-#define SOCKET_TIME_OUT 5               // in sec
-#define DRIVER_OPEN_TIMEOUT 5           // in sec
-#define FREEWHEEL_DRIVER_TIMEOUT 10     // in sec
-#define DRIVER_TIMEOUT_FACTOR    10     
-
-
-#define NO_PORT   0xFFFE
-
-#define EMPTY   0xFFFD
-#define FREE	0xFFFC
-
-#endif

=== removed file '.pc/no-selfconnect.patch/common/JackControlAPI.cpp'
--- .pc/no-selfconnect.patch/common/JackControlAPI.cpp	2011-03-31 13:54:50 +0000
+++ .pc/no-selfconnect.patch/common/JackControlAPI.cpp	1970-01-01 00:00:00 +0000
@@ -1,1249 +0,0 @@
-// u/* -*- Mode: C++ ; c-basic-offset: 4 -*- */
-/*
-  JACK control API implementation
-
-  Copyright (C) 2008 Nedko Arnaudov
-  Copyright (C) 2008 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; version 2 of the License.
-
-  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.
-
-*/
-
-#ifndef WIN32
-#include <stdint.h>
-#include <dirent.h>
-#include <pthread.h>
-#endif
-
-#include "types.h"
-#include <string.h>
-#include <errno.h>
-#include <stdio.h>
-#include <assert.h>
-#include <signal.h>
-
-#include "jslist.h"
-#include "driver_interface.h"
-#include "JackError.h"
-#include "JackServer.h"
-#include "shm.h"
-#include "JackTools.h"
-#include "JackControlAPI.h"
-#include "JackLockedEngine.h"
-#include "JackConstants.h"
-#include "JackDriverLoader.h"
-#include "JackServerGlobals.h"
-
-using namespace Jack;
-
-struct jackctl_server
-{
-    JSList * drivers;
-    JSList * internals;
-    JSList * parameters;
-
-    class JackServer * engine;
-
-    /* string, server name */
-    union jackctl_parameter_value name;
-    union jackctl_parameter_value default_name;
-
-    /* bool, whether to be "realtime" */
-    union jackctl_parameter_value realtime;
-    union jackctl_parameter_value default_realtime;
-
-    /* int32_t */
-    union jackctl_parameter_value realtime_priority;
-    union jackctl_parameter_value default_realtime_priority;
-
-    /* bool, whether to exit once all clients have closed their connections */
-    union jackctl_parameter_value temporary;
-    union jackctl_parameter_value default_temporary;
-
-    /* bool, whether to be verbose */
-    union jackctl_parameter_value verbose;
-    union jackctl_parameter_value default_verbose;
-
-    /* int32_t, msecs; if zero, use period size. */
-    union jackctl_parameter_value client_timeout;
-    union jackctl_parameter_value default_client_timeout;
-
-    /* uint32_t, clock source type */
-    union jackctl_parameter_value clock_source;
-    union jackctl_parameter_value default_clock_source;
-
-    /* uint32_t, max port number */
-    union jackctl_parameter_value port_max;
-    union jackctl_parameter_value default_port_max;
-
-    /* bool */
-    union jackctl_parameter_value replace_registry;
-    union jackctl_parameter_value default_replace_registry;
-
-    /* bool, synchronous or asynchronous engine mode */
-    union jackctl_parameter_value sync;
-    union jackctl_parameter_value default_sync;
-};
-
-struct jackctl_driver
-{
-    jack_driver_desc_t * desc_ptr;
-    JSList * parameters;
-    JSList * set_parameters;
-    JackDriverInfo* info;
-};
-
-struct jackctl_internal
-{
-    jack_driver_desc_t * desc_ptr;
-    JSList * parameters;
-    JSList * set_parameters;
-    int refnum;
-};
-
-struct jackctl_parameter
-{
-    const char * name;
-    const char * short_description;
-    const char * long_description;
-    jackctl_param_type_t type;
-    bool is_set;
-    union jackctl_parameter_value * value_ptr;
-    union jackctl_parameter_value * default_value_ptr;
-
-    union jackctl_parameter_value value;
-    union jackctl_parameter_value default_value;
-    struct jackctl_driver * driver_ptr;
-    char id;
-    jack_driver_param_t * driver_parameter_ptr;
-    jack_driver_param_constraint_desc_t * constraint_ptr;
-};
-
-static
-struct jackctl_parameter *
-jackctl_add_parameter(
-    JSList ** parameters_list_ptr_ptr,
-    const char * name,
-    const char * short_description,
-    const char * long_description,
-    jackctl_param_type_t type,
-    union jackctl_parameter_value * value_ptr,
-    union jackctl_parameter_value * default_value_ptr,
-    union jackctl_parameter_value value,
-    jack_driver_param_constraint_desc_t * constraint_ptr = NULL)
-{
-    struct jackctl_parameter * parameter_ptr;
-
-    parameter_ptr = (struct jackctl_parameter *)malloc(sizeof(struct jackctl_parameter));
-    if (parameter_ptr == NULL)
-    {
-        jack_error("Cannot allocate memory for jackctl_parameter structure.");
-        goto fail;
-    }
-
-    parameter_ptr->name = name;
-    parameter_ptr->short_description = short_description;
-    parameter_ptr->long_description = long_description;
-    parameter_ptr->type = type;
-    parameter_ptr->is_set = false;
-
-    if (value_ptr == NULL)
-    {
-        value_ptr = &parameter_ptr->value;
-    }
-
-    if (default_value_ptr == NULL)
-    {
-        default_value_ptr = &parameter_ptr->default_value;
-    }
-
-    parameter_ptr->value_ptr = value_ptr;
-    parameter_ptr->default_value_ptr = default_value_ptr;
-
-    *value_ptr = *default_value_ptr = value;
-
-    parameter_ptr->driver_ptr = NULL;
-    parameter_ptr->driver_parameter_ptr = NULL;
-    parameter_ptr->id = 0;
-    parameter_ptr->constraint_ptr = constraint_ptr;
-
-    *parameters_list_ptr_ptr = jack_slist_append(*parameters_list_ptr_ptr, parameter_ptr);
-
-    return parameter_ptr;
-
-fail:
-    return NULL;
-}
-
-static
-void
-jackctl_free_driver_parameters(
-    struct jackctl_driver * driver_ptr)
-{
-    JSList * next_node_ptr;
-
-    while (driver_ptr->parameters)
-    {
-        next_node_ptr = driver_ptr->parameters->next;
-        free(driver_ptr->parameters->data);
-        free(driver_ptr->parameters);
-        driver_ptr->parameters = next_node_ptr;
-    }
-
-    while (driver_ptr->set_parameters)
-    {
-        next_node_ptr = driver_ptr->set_parameters->next;
-        free(driver_ptr->set_parameters->data);
-        free(driver_ptr->set_parameters);
-        driver_ptr->set_parameters = next_node_ptr;
-    }
-}
-
-static
-bool
-jackctl_add_driver_parameters(
-    struct jackctl_driver * driver_ptr)
-{
-    uint32_t i;
-    union jackctl_parameter_value jackctl_value;
-    jackctl_param_type_t jackctl_type;
-    struct jackctl_parameter * parameter_ptr;
-    jack_driver_param_desc_t * descriptor_ptr;
-
-    for (i = 0 ; i < driver_ptr->desc_ptr->nparams ; i++)
-    {
-        descriptor_ptr = driver_ptr->desc_ptr->params + i;
-
-        switch (descriptor_ptr->type)
-        {
-        case JackDriverParamInt:
-            jackctl_type = JackParamInt;
-            jackctl_value.i = descriptor_ptr->value.i;
-            break;
-        case JackDriverParamUInt:
-            jackctl_type = JackParamUInt;
-            jackctl_value.ui = descriptor_ptr->value.ui;
-            break;
-        case JackDriverParamChar:
-            jackctl_type = JackParamChar;
-            jackctl_value.c = descriptor_ptr->value.c;
-            break;
-        case JackDriverParamString:
-            jackctl_type = JackParamString;
-            strcpy(jackctl_value.str, descriptor_ptr->value.str);
-            break;
-        case JackDriverParamBool:
-            jackctl_type = JackParamBool;
-            jackctl_value.b = descriptor_ptr->value.i;
-            break;
-        default:
-            jack_error("unknown driver parameter type %i", (int)descriptor_ptr->type);
-            assert(0);
-            goto fail;
-        }
-
-        parameter_ptr = jackctl_add_parameter(
-            &driver_ptr->parameters,
-            descriptor_ptr->name,
-            descriptor_ptr->short_desc,
-            descriptor_ptr->long_desc,
-            jackctl_type,
-            NULL,
-            NULL,
-            jackctl_value,
-            descriptor_ptr->constraint);
-
-        if (parameter_ptr == NULL)
-        {
-            goto fail;
-        }
-
-        parameter_ptr->driver_ptr = driver_ptr;
-        parameter_ptr->id = descriptor_ptr->character;
-    }
-
-    return true;
-
-fail:
-    jackctl_free_driver_parameters(driver_ptr);
-
-    return false;
-}
-
-static int
-jackctl_drivers_load(
-    struct jackctl_server * server_ptr)
-{
-    struct jackctl_driver * driver_ptr;
-    JSList *node_ptr;
-    JSList *descriptor_node_ptr;
-
-    descriptor_node_ptr = jack_drivers_load(NULL);
-    if (descriptor_node_ptr == NULL)
-    {
-        jack_error("could not find any drivers in driver directory!");
-        return false;
-    }
-
-    while (descriptor_node_ptr != NULL)
-    {
-        driver_ptr = (struct jackctl_driver *)malloc(sizeof(struct jackctl_driver));
-        if (driver_ptr == NULL)
-        {
-            jack_error("memory allocation of jackctl_driver structure failed.");
-            goto next;
-        }
-
-        driver_ptr->desc_ptr = (jack_driver_desc_t *)descriptor_node_ptr->data;
-        driver_ptr->parameters = NULL;
-        driver_ptr->set_parameters = NULL;
-
-        if (!jackctl_add_driver_parameters(driver_ptr))
-        {
-            assert(driver_ptr->parameters == NULL);
-            free(driver_ptr);
-            goto next;
-        }
-
-        server_ptr->drivers = jack_slist_append(server_ptr->drivers, driver_ptr);
-
-    next:
-        node_ptr = descriptor_node_ptr;
-        descriptor_node_ptr = descriptor_node_ptr->next;
-        free(node_ptr);
-    }
-
-    return true;
-}
-
-static
-void
-jackctl_server_free_drivers(
-    struct jackctl_server * server_ptr)
-{
-    JSList * next_node_ptr;
-    struct jackctl_driver * driver_ptr;
-
-    while (server_ptr->drivers)
-    {
-        next_node_ptr = server_ptr->drivers->next;
-        driver_ptr = (struct jackctl_driver *)server_ptr->drivers->data;
-
-        jackctl_free_driver_parameters(driver_ptr);
-        free(driver_ptr->desc_ptr->params);
-        free(driver_ptr->desc_ptr);
-        free(driver_ptr);
-
-        free(server_ptr->drivers);
-        server_ptr->drivers = next_node_ptr;
-    }
-}
-
-static int
-jackctl_internals_load(
-    struct jackctl_server * server_ptr)
-{
-    struct jackctl_internal * internal_ptr;
-    JSList *node_ptr;
-    JSList *descriptor_node_ptr;
-
-    descriptor_node_ptr = jack_internals_load(NULL);
-    if (descriptor_node_ptr == NULL)
-    {
-        jack_error("could not find any internals in driver directory!");
-        return false;
-    }
-
-    while (descriptor_node_ptr != NULL)
-    {
-        internal_ptr = (struct jackctl_internal *)malloc(sizeof(struct jackctl_internal));
-        if (internal_ptr == NULL)
-        {
-            jack_error("memory allocation of jackctl_driver structure failed.");
-            goto next;
-        }
-
-        internal_ptr->desc_ptr = (jack_driver_desc_t *)descriptor_node_ptr->data;
-        internal_ptr->parameters = NULL;
-        internal_ptr->set_parameters = NULL;
-
-        if (!jackctl_add_driver_parameters((struct jackctl_driver *)internal_ptr))
-        {
-            assert(internal_ptr->parameters == NULL);
-            free(internal_ptr);
-            goto next;
-        }
-
-        server_ptr->internals = jack_slist_append(server_ptr->internals, internal_ptr);
-
-    next:
-        node_ptr = descriptor_node_ptr;
-        descriptor_node_ptr = descriptor_node_ptr->next;
-        free(node_ptr);
-    }
-
-    return true;
-}
-
-static
-void
-jackctl_server_free_internals(
-    struct jackctl_server * server_ptr)
-{
-    JSList * next_node_ptr;
-    struct jackctl_internal * internal_ptr;
-
-    while (server_ptr->internals)
-    {
-        next_node_ptr = server_ptr->internals->next;
-        internal_ptr = (struct jackctl_internal *)server_ptr->internals->data;
-
-        jackctl_free_driver_parameters((struct jackctl_driver *)internal_ptr);
-        free(internal_ptr->desc_ptr->params);
-        free(internal_ptr->desc_ptr);
-        free(internal_ptr);
-
-        free(server_ptr->internals);
-        server_ptr->internals = next_node_ptr;
-    }
-}
-
-static
-void
-jackctl_server_free_parameters(
-    struct jackctl_server * server_ptr)
-{
-    JSList * next_node_ptr;
-
-    while (server_ptr->parameters)
-    {
-        next_node_ptr = server_ptr->parameters->next;
-        free(server_ptr->parameters->data);
-        free(server_ptr->parameters);
-        server_ptr->parameters = next_node_ptr;
-    }
-}
-
-#ifdef WIN32
-
-static HANDLE waitEvent;
-
-static void do_nothing_handler(int signum)
-{
-    printf("jack main caught signal %d\n", signum);
-    (void) signal(SIGINT, SIG_DFL);
-    SetEvent(waitEvent);
-}
-
-sigset_t
-jackctl_setup_signals(
-    unsigned int flags)
-{
-    if ((waitEvent = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL) {
-        jack_error("CreateEvent fails err = %ld", GetLastError());
-        return 0;
-    }
-
-    (void) signal(SIGINT, do_nothing_handler);
-    (void) signal(SIGABRT, do_nothing_handler);
-    (void) signal(SIGTERM, do_nothing_handler);
-
-    return (sigset_t)waitEvent;
-}
-
-void jackctl_wait_signals(sigset_t signals)
-{
-    if (WaitForSingleObject(waitEvent, INFINITE) != WAIT_OBJECT_0) {
-        jack_error("WaitForSingleObject fails err = %ld", GetLastError());
-    }
-}
-
-#else
-
-static
-void
-do_nothing_handler(int sig)
-{
-    /* this is used by the child (active) process, but it never
-       gets called unless we are already shutting down after
-       another signal.
-    */
-    char buf[64];
-    snprintf (buf, sizeof(buf), "received signal %d during shutdown (ignored)\n", sig);
-}
-
-EXPORT sigset_t
-jackctl_setup_signals(
-    unsigned int flags)
-{
-    sigset_t signals;
-    sigset_t allsignals;
-    struct sigaction action;
-    int i;
-
-    /* ensure that we are in our own process group so that
-       kill (SIG, -pgrp) does the right thing.
-    */
-
-    setsid();
-
-    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
-
-    /* what's this for?
-
-       POSIX says that signals are delivered like this:
-
-       * if a thread has blocked that signal, it is not
-           a candidate to receive the signal.
-           * of all threads not blocking the signal, pick
-           one at random, and deliver the signal.
-
-           this means that a simple-minded multi-threaded program can
-           expect to get POSIX signals delivered randomly to any one
-           of its threads,
-
-       here, we block all signals that we think we might receive
-       and want to catch. all "child" threads will inherit this
-       setting. if we create a thread that calls sigwait() on the
-       same set of signals, implicitly unblocking all those
-       signals. any of those signals that are delivered to the
-       process will be delivered to that thread, and that thread
-       alone. this makes cleanup for a signal-driven exit much
-       easier, since we know which thread is doing it and more
-       importantly, we are free to call async-unsafe functions,
-       because the code is executing in normal thread context
-       after a return from sigwait().
-    */
-
-    sigemptyset(&signals);
-    sigaddset(&signals, SIGHUP);
-    sigaddset(&signals, SIGINT);
-    sigaddset(&signals, SIGQUIT);
-    sigaddset(&signals, SIGPIPE);
-    sigaddset(&signals, SIGTERM);
-    sigaddset(&signals, SIGUSR1);
-    sigaddset(&signals, SIGUSR2);
-
-    /* all child threads will inherit this mask unless they
-     * explicitly reset it
-     */
-
-    pthread_sigmask(SIG_BLOCK, &signals, 0);
-
-    /* install a do-nothing handler because otherwise pthreads
-       behaviour is undefined when we enter sigwait.
-    */
-
-    sigfillset(&allsignals);
-    action.sa_handler = do_nothing_handler;
-    action.sa_mask = allsignals;
-    action.sa_flags = SA_RESTART|SA_RESETHAND;
-
-    for (i = 1; i < NSIG; i++)
-    {
-        if (sigismember (&signals, i))
-        {
-            sigaction(i, &action, 0);
-        }
-    }
-
-    return signals;
-}
-
-EXPORT void
-jackctl_wait_signals(sigset_t signals)
-{
-    int sig;
-    bool waiting = true;
-
-    while (waiting) {
-    #if defined(sun) && !defined(__sun__) // SUN compiler only, to check
-        sigwait(&signals);
-    #else
-        sigwait(&signals, &sig);
-    #endif
-        fprintf(stderr, "jack main caught signal %d\n", sig);
-
-        switch (sig) {
-            case SIGUSR1:
-                //jack_dump_configuration(engine, 1);
-                break;
-            case SIGUSR2:
-                // driver exit
-                waiting = false;
-                break;
-            case SIGTTOU:
-                break;
-            default:
-                waiting = false;
-                break;
-        }
-    }
-
-    if (sig != SIGSEGV) {
-        // unblock signals so we can see them during shutdown.
-        // this will help prod developers not to lose sight of
-        // bugs that cause segfaults etc. during shutdown.
-        sigprocmask(SIG_UNBLOCK, &signals, 0);
-    }
-}
-#endif
-
-static
-jack_driver_param_constraint_desc_t *
-get_realtime_priority_constraint()
-{
-    jack_driver_param_constraint_desc_t * constraint_ptr;
-    int min, max;
-
-    if (!jack_get_thread_realtime_priority_range(&min, &max))
-    {
-        return NULL;
-    }
-
-    //jack_info("realtime priority range is (%d,%d)", min, max);
-
-    constraint_ptr = (jack_driver_param_constraint_desc_t *)calloc(1, sizeof(jack_driver_param_value_enum_t));
-    if (constraint_ptr == NULL)
-    {
-        jack_error("Cannot allocate memory for jack_driver_param_constraint_desc_t structure.");
-        return NULL;
-    }
-    constraint_ptr->flags = JACK_CONSTRAINT_FLAG_RANGE;
-
-    constraint_ptr->constraint.range.min.i = min;
-    constraint_ptr->constraint.range.max.i = max;
-
-    return constraint_ptr;
-}
-
-EXPORT jackctl_server_t * jackctl_server_create(
-    bool (* on_device_acquire)(const char * device_name),
-    void (* on_device_release)(const char * device_name))
-{
-    struct jackctl_server * server_ptr;
-    union jackctl_parameter_value value;
-
-    server_ptr = (struct jackctl_server *)malloc(sizeof(struct jackctl_server));
-    if (server_ptr == NULL)
-    {
-        jack_error("Cannot allocate memory for jackctl_server structure.");
-        goto fail;
-    }
-
-    server_ptr->drivers = NULL;
-    server_ptr->internals = NULL;
-    server_ptr->parameters = NULL;
-    server_ptr->engine = NULL;
-
-    strcpy(value.str, JACK_DEFAULT_SERVER_NAME);
-    if (jackctl_add_parameter(
-            &server_ptr->parameters,
-            "name",
-            "Server name to use.",
-            "",
-            JackParamString,
-            &server_ptr->name,
-            &server_ptr->default_name,
-            value) == NULL)
-    {
-        goto fail_free_parameters;
-    }
-
-    value.b = false;
-    if (jackctl_add_parameter(
-            &server_ptr->parameters,
-            "realtime",
-            "Whether to use realtime mode.",
-            "Use realtime scheduling. This is needed for reliable low-latency performance. On most systems, it requires JACK to run with special scheduler and memory allocation privileges, which may be obtained in several ways. On Linux you should use PAM.",
-            JackParamBool,
-            &server_ptr->realtime,
-            &server_ptr->default_realtime,
-            value) == NULL)
-    {
-        goto fail_free_parameters;
-    }
-
-    value.i = 10;
-    if (jackctl_add_parameter(
-            &server_ptr->parameters,
-            "realtime-priority",
-            "Scheduler priority when running in realtime mode.",
-            "",
-            JackParamInt,
-            &server_ptr->realtime_priority,
-            &server_ptr->default_realtime_priority,
-            value,
-            get_realtime_priority_constraint()) == NULL)
-    {
-        goto fail_free_parameters;
-    }
-
-    value.b = false;
-    if (jackctl_add_parameter(
-            &server_ptr->parameters,
-            "temporary",
-            "Exit once all clients have closed their connections.",
-            "",
-            JackParamBool,
-            &server_ptr->temporary,
-            &server_ptr->default_temporary,
-            value) == NULL)
-    {
-        goto fail_free_parameters;
-    }
-
-    value.b = false;
-    if (jackctl_add_parameter(
-            &server_ptr->parameters,
-            "verbose",
-            "Verbose mode.",
-            "",
-            JackParamBool,
-            &server_ptr->verbose,
-            &server_ptr->default_verbose,
-            value) == NULL)
-    {
-        goto fail_free_parameters;
-    }
-
-    value.i = 0;
-    if (jackctl_add_parameter(
-            &server_ptr->parameters,
-            "client-timeout",
-            "Client timeout limit in milliseconds.",
-            "",
-            JackParamInt,
-            &server_ptr->client_timeout,
-            &server_ptr->default_client_timeout,
-            value) == NULL)
-    {
-        goto fail_free_parameters;
-    }
-
-    value.ui = 0;
-    if (jackctl_add_parameter(
-            &server_ptr->parameters,
-            "clock-source",
-            "Clocksource type : c(ycle) | h(pet) | s(ystem).",
-            "",
-            JackParamUInt,
-            &server_ptr->clock_source,
-            &server_ptr->default_clock_source,
-            value) == NULL)
-    {
-        goto fail_free_parameters;
-    }
-
-    value.ui = PORT_NUM;
-    if (jackctl_add_parameter(
-          &server_ptr->parameters,
-          "port-max",
-          "Maximum number of ports.",
-          "",
-          JackParamUInt,
-          &server_ptr->port_max,
-          &server_ptr->default_port_max,
-          value) == NULL)
-    {
-        goto fail_free_parameters;
-    }
-
-    value.b = false;
-    if (jackctl_add_parameter(
-            &server_ptr->parameters,
-            "replace-registry",
-            "Replace shared memory registry.",
-            "",
-            JackParamBool,
-            &server_ptr->replace_registry,
-            &server_ptr->default_replace_registry,
-            value) == NULL)
-    {
-        goto fail_free_parameters;
-    }
-
-    value.b = false;
-    if (jackctl_add_parameter(
-            &server_ptr->parameters,
-            "sync",
-            "Use server synchronous mode.",
-            "",
-            JackParamBool,
-            &server_ptr->sync,
-            &server_ptr->default_sync,
-            value) == NULL)
-    {
-        goto fail_free_parameters;
-    }
-
-    JackServerGlobals::on_device_acquire = on_device_acquire;
-    JackServerGlobals::on_device_release = on_device_release;
-
-    if (!jackctl_drivers_load(server_ptr))
-    {
-        goto fail_free_parameters;
-    }
-
-    /* Allowed to fail */
-    jackctl_internals_load(server_ptr);
-
-    return server_ptr;
-
-fail_free_parameters:
-    jackctl_server_free_parameters(server_ptr);
-
-    free(server_ptr);
-
-fail:
-    return NULL;
-}
-
-EXPORT void jackctl_server_destroy(jackctl_server *server_ptr)
-{
-    jackctl_server_free_drivers(server_ptr);
-    jackctl_server_free_internals(server_ptr);
-    jackctl_server_free_parameters(server_ptr);
-    free(server_ptr);
-}
-
-EXPORT const JSList * jackctl_server_get_drivers_list(jackctl_server *server_ptr)
-{
-    return server_ptr->drivers;
-}
-
-EXPORT bool jackctl_server_stop(jackctl_server *server_ptr)
-{
-    server_ptr->engine->Stop();
-    return true;
-}
-
-EXPORT bool jackctl_server_close(jackctl_server *server_ptr)
-{
-    server_ptr->engine->Close();
-    delete server_ptr->engine;
-
-    /* clean up shared memory and files from this server instance */
-    jack_log("cleaning up shared memory");
-
-    jack_cleanup_shm();
-
-    jack_log("cleaning up files");
-
-    JackTools::CleanupFiles(server_ptr->name.str);
-
-    jack_log("unregistering server `%s'", server_ptr->name.str);
-
-    jack_unregister_server(server_ptr->name.str);
-
-    server_ptr->engine = NULL;
-
-    return true;
-}
-
-EXPORT const JSList * jackctl_server_get_parameters(jackctl_server *server_ptr)
-{
-    return server_ptr->parameters;
-}
-
-EXPORT bool
-jackctl_server_open(
-    jackctl_server *server_ptr,
-    jackctl_driver *driver_ptr)
-{
-    int rc;
-
-    rc = jack_register_server(server_ptr->name.str, server_ptr->replace_registry.b);
-    switch (rc)
-    {
-    case EEXIST:
-        jack_error("`%s' server already active", server_ptr->name.str);
-        goto fail;
-    case ENOSPC:
-        jack_error("too many servers already active");
-        goto fail;
-    case ENOMEM:
-        jack_error("no access to shm registry");
-        goto fail;
-    }
-
-    jack_log("server `%s' registered", server_ptr->name.str);
-
-    /* clean up shared memory and files from any previous
-     * instance of this server name */
-    jack_cleanup_shm();
-    JackTools::CleanupFiles(server_ptr->name.str);
-
-    if (!server_ptr->realtime.b && server_ptr->client_timeout.i == 0)
-        server_ptr->client_timeout.i = 500; /* 0.5 sec; usable when non realtime. */
-
-    /* check port max value before allocating server */
-    if (server_ptr->port_max.ui > PORT_NUM_MAX) {
-        jack_error("JACK server started with too much ports %d (when port max can be %d)", server_ptr->port_max.ui, PORT_NUM_MAX);
-        goto fail;
-    }
-
-    /* get the engine/driver started */
-    server_ptr->engine = new JackServer(
-        server_ptr->sync.b,
-        server_ptr->temporary.b,
-        server_ptr->client_timeout.i,
-        server_ptr->realtime.b,
-        server_ptr->realtime_priority.i,
-        server_ptr->port_max.ui,
-        server_ptr->verbose.b,
-        (jack_timer_type_t)server_ptr->clock_source.ui,
-        server_ptr->name.str);
-    if (server_ptr->engine == NULL)
-    {
-        jack_error("Failed to create new JackServer object");
-        goto fail_unregister;
-    }
-
-    rc = server_ptr->engine->Open(driver_ptr->desc_ptr, driver_ptr->set_parameters);
-    if (rc < 0)
-    {
-        jack_error("JackServer::Open() failed with %d", rc);
-        goto fail_delete;
-    }
-
-    return true;
-
-fail_delete:
-    delete server_ptr->engine;
-    server_ptr->engine = NULL;
-
-fail_unregister:
-    jack_log("cleaning up shared memory");
-
-    jack_cleanup_shm();
-
-    jack_log("cleaning up files");
-
-    JackTools::CleanupFiles(server_ptr->name.str);
-
-    jack_log("unregistering server `%s'", server_ptr->name.str);
-
-    jack_unregister_server(server_ptr->name.str);
-
-fail:
-    return false;
-}
-
-EXPORT bool
-jackctl_server_start(
-    jackctl_server *server_ptr)
-{
-    int rc = server_ptr->engine->Start();
-    bool result = rc >= 0;
-    if (! result)
-    {
-        jack_error("JackServer::Start() failed with %d", rc);
-    }
-    return result;
-}
-
-EXPORT const char * jackctl_driver_get_name(jackctl_driver *driver_ptr)
-{
-    return driver_ptr->desc_ptr->name;
-}
-
-EXPORT const JSList * jackctl_driver_get_parameters(jackctl_driver *driver_ptr)
-{
-    return driver_ptr->parameters;
-}
-
-EXPORT jack_driver_desc_t * jackctl_driver_get_desc(jackctl_driver *driver_ptr)
-{
-    return driver_ptr->desc_ptr;
-}
-
-EXPORT const char * jackctl_parameter_get_name(jackctl_parameter *parameter_ptr)
-{
-    return parameter_ptr->name;
-}
-
-EXPORT const char * jackctl_parameter_get_short_description(jackctl_parameter *parameter_ptr)
-{
-    return parameter_ptr->short_description;
-}
-
-EXPORT const char * jackctl_parameter_get_long_description(jackctl_parameter *parameter_ptr)
-{
-    return parameter_ptr->long_description;
-}
-
-EXPORT bool jackctl_parameter_has_range_constraint(jackctl_parameter *parameter_ptr)
-{
-    return parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->flags & JACK_CONSTRAINT_FLAG_RANGE) != 0;
-}
-
-EXPORT bool jackctl_parameter_has_enum_constraint(jackctl_parameter *parameter_ptr)
-{
-    return parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->flags & JACK_CONSTRAINT_FLAG_RANGE) == 0;
-}
-
-EXPORT uint32_t jackctl_parameter_get_enum_constraints_count(jackctl_parameter *parameter_ptr)
-{
-    if (!jackctl_parameter_has_enum_constraint(parameter_ptr))
-    {
-        return 0;
-    }
-
-    return parameter_ptr->constraint_ptr->constraint.enumeration.count;
-}
-
-EXPORT union jackctl_parameter_value jackctl_parameter_get_enum_constraint_value(jackctl_parameter *parameter_ptr, uint32_t index)
-{
-    jack_driver_param_value_t * value_ptr;
-    union jackctl_parameter_value jackctl_value;
-
-    value_ptr = &parameter_ptr->constraint_ptr->constraint.enumeration.possible_values_array[index].value;
-
-    switch (parameter_ptr->type)
-    {
-    case JackParamInt:
-        jackctl_value.i = value_ptr->i;
-        break;
-    case JackParamUInt:
-        jackctl_value.ui = value_ptr->ui;
-        break;
-    case JackParamChar:
-        jackctl_value.c = value_ptr->c;
-        break;
-    case JackParamString:
-        strcpy(jackctl_value.str, value_ptr->str);
-        break;
-    default:
-        jack_error("bad driver parameter type %i (enum constraint)", (int)parameter_ptr->type);
-        assert(0);
-    }
-
-    return jackctl_value;
-}
-
-EXPORT const char * jackctl_parameter_get_enum_constraint_description(jackctl_parameter *parameter_ptr, uint32_t index)
-{
-    return parameter_ptr->constraint_ptr->constraint.enumeration.possible_values_array[index].short_desc;
-}
-
-EXPORT void jackctl_parameter_get_range_constraint(jackctl_parameter *parameter_ptr, union jackctl_parameter_value * min_ptr, union jackctl_parameter_value * max_ptr)
-{
-    switch (parameter_ptr->type)
-    {
-    case JackParamInt:
-        min_ptr->i = parameter_ptr->constraint_ptr->constraint.range.min.i;
-        max_ptr->i = parameter_ptr->constraint_ptr->constraint.range.max.i;
-        return;
-    case JackParamUInt:
-        min_ptr->ui = parameter_ptr->constraint_ptr->constraint.range.min.ui;
-        max_ptr->ui = parameter_ptr->constraint_ptr->constraint.range.max.ui;
-        return;
-    default:
-        jack_error("bad driver parameter type %i (range constraint)", (int)parameter_ptr->type);
-        assert(0);
-    }
-}
-
-EXPORT bool jackctl_parameter_constraint_is_strict(jackctl_parameter_t * parameter_ptr)
-{
-    return parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->flags & JACK_CONSTRAINT_FLAG_STRICT) != 0;
-}
-
-EXPORT bool jackctl_parameter_constraint_is_fake_value(jackctl_parameter_t * parameter_ptr)
-{
-    return parameter_ptr->constraint_ptr != NULL && (parameter_ptr->constraint_ptr->flags & JACK_CONSTRAINT_FLAG_FAKE_VALUE) != 0;
-}
-
-EXPORT jackctl_param_type_t jackctl_parameter_get_type(jackctl_parameter *parameter_ptr)
-{
-    return parameter_ptr->type;
-}
-
-EXPORT char jackctl_parameter_get_id(jackctl_parameter_t * parameter_ptr)
-{
-    return parameter_ptr->id;
-}
-
-EXPORT bool jackctl_parameter_is_set(jackctl_parameter *parameter_ptr)
-{
-    return parameter_ptr->is_set;
-}
-
-EXPORT union jackctl_parameter_value jackctl_parameter_get_value(jackctl_parameter *parameter_ptr)
-{
-    return *parameter_ptr->value_ptr;
-}
-
-EXPORT bool jackctl_parameter_reset(jackctl_parameter *parameter_ptr)
-{
-    if (!parameter_ptr->is_set)
-    {
-        return true;
-    }
-
-    parameter_ptr->is_set = false;
-
-    *parameter_ptr->value_ptr = *parameter_ptr->default_value_ptr;
-
-    return true;
-}
-
-EXPORT bool jackctl_parameter_set_value(jackctl_parameter *parameter_ptr, const union jackctl_parameter_value * value_ptr)
-{
-    bool new_driver_parameter;
-
-    /* for driver parameters, set the parameter by adding jack_driver_param_t in the set_parameters list */
-    if (parameter_ptr->driver_ptr != NULL)
-    {
-/*      jack_info("setting driver parameter %p ...", parameter_ptr); */
-        new_driver_parameter = parameter_ptr->driver_parameter_ptr == NULL;
-        if (new_driver_parameter)
-        {
-/*          jack_info("new driver parameter..."); */
-            parameter_ptr->driver_parameter_ptr = (jack_driver_param_t *)malloc(sizeof(jack_driver_param_t));
-            if (parameter_ptr->driver_parameter_ptr == NULL)
-            {
-                jack_error ("Allocation of jack_driver_param_t structure failed");
-                return false;
-            }
-
-           parameter_ptr->driver_parameter_ptr->character = parameter_ptr->id;
-           parameter_ptr->driver_ptr->set_parameters = jack_slist_append(parameter_ptr->driver_ptr->set_parameters, parameter_ptr->driver_parameter_ptr);
-        }
-
-        switch (parameter_ptr->type)
-        {
-        case JackParamInt:
-            parameter_ptr->driver_parameter_ptr->value.i = value_ptr->i;
-            break;
-        case JackParamUInt:
-            parameter_ptr->driver_parameter_ptr->value.ui = value_ptr->ui;
-            break;
-        case JackParamChar:
-            parameter_ptr->driver_parameter_ptr->value.c = value_ptr->c;
-            break;
-        case JackParamString:
-            strcpy(parameter_ptr->driver_parameter_ptr->value.str, value_ptr->str);
-            break;
-        case JackParamBool:
-            parameter_ptr->driver_parameter_ptr->value.i = value_ptr->b;
-            break;
-        default:
-            jack_error("unknown parameter type %i", (int)parameter_ptr->type);
-            assert(0);
-
-            if (new_driver_parameter)
-            {
-                parameter_ptr->driver_ptr->set_parameters = jack_slist_remove(parameter_ptr->driver_ptr->set_parameters, parameter_ptr->driver_parameter_ptr);
-            }
-
-            return false;
-        }
-    }
-
-    parameter_ptr->is_set = true;
-    *parameter_ptr->value_ptr = *value_ptr;
-
-    return true;
-}
-
-EXPORT union jackctl_parameter_value jackctl_parameter_get_default_value(jackctl_parameter *parameter_ptr)
-{
-    return *parameter_ptr->default_value_ptr;
-}
-
-// Internals clients
-
-EXPORT const JSList * jackctl_server_get_internals_list(jackctl_server *server_ptr)
-{
-    return server_ptr->internals;
-}
-
-EXPORT const char * jackctl_internal_get_name(jackctl_internal *internal_ptr)
-{
-    return internal_ptr->desc_ptr->name;
-}
-
-EXPORT const JSList * jackctl_internal_get_parameters(jackctl_internal *internal_ptr)
-{
-    return internal_ptr->parameters;
-}
-
-EXPORT bool jackctl_server_load_internal(
-    jackctl_server * server_ptr,
-    jackctl_internal * internal)
-{
-    int status;
-    if (server_ptr->engine != NULL) {
-        server_ptr->engine->InternalClientLoad2(internal->desc_ptr->name, internal->desc_ptr->name, internal->set_parameters, JackNullOption, &internal->refnum, -1, &status);
-        return (internal->refnum > 0);
-    } else {
-        return false;
-    }
-}
-
-EXPORT bool jackctl_server_unload_internal(
-    jackctl_server * server_ptr,
-    jackctl_internal * internal)
-{
-    int status;
-    if (server_ptr->engine != NULL && internal->refnum > 0) {
-        // Client object is internally kept in JackEngine, and will be desallocated in InternalClientUnload
-        return ((server_ptr->engine->GetEngine()->InternalClientUnload(internal->refnum, &status)) == 0);
-    } else {
-        return false;
-    }
-}
-
-EXPORT bool jackctl_server_add_slave(jackctl_server * server_ptr, jackctl_driver * driver_ptr)
-{
-    if (server_ptr->engine != NULL) {
-        if (server_ptr->engine->IsRunning()) {
-            jack_error("cannot add a slave in a running server");
-            return false;
-        } else {
-            driver_ptr->info = server_ptr->engine->AddSlave(driver_ptr->desc_ptr, driver_ptr->set_parameters);
-            return (driver_ptr->info != 0);
-        }
-    } else {
-        return false;
-    }
-}
-
-EXPORT bool jackctl_server_remove_slave(jackctl_server * server_ptr, jackctl_driver * driver_ptr)
-{
-    if (server_ptr->engine != NULL) {
-        if (server_ptr->engine->IsRunning()) {
-            jack_error("cannot remove a slave from a running server");
-            return false;
-        } else {
-            server_ptr->engine->RemoveSlave(driver_ptr->info);
-            delete driver_ptr->info;
-            return true;
-        }
-    } else {
-        return false;
-    }
-}
-
-EXPORT bool jackctl_server_switch_master(jackctl_server * server_ptr, jackctl_driver * driver_ptr)
-{
-    if (server_ptr->engine != NULL) {
-        return (server_ptr->engine->SwitchMaster(driver_ptr->desc_ptr, driver_ptr->set_parameters) == 0);
-    } else {
-        return false;
-    }
-}
-

=== removed file '.pc/no-selfconnect.patch/common/JackEngine.cpp'
--- .pc/no-selfconnect.patch/common/JackEngine.cpp	2011-03-31 13:54:50 +0000
+++ .pc/no-selfconnect.patch/common/JackEngine.cpp	1970-01-01 00:00:00 +0000
@@ -1,1084 +0,0 @@
-/*
-Copyright (C) 2004-2008 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 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.
-
-*/
-
-#include <iostream>
-#include <fstream>
-#include <set>
-#include <assert.h>
-
-#include "JackSystemDeps.h"
-#include "JackLockedEngine.h"
-#include "JackExternalClient.h"
-#include "JackInternalClient.h"
-#include "JackEngineControl.h"
-#include "JackClientControl.h"
-#include "JackServerGlobals.h"
-#include "JackGlobals.h"
-#include "JackChannel.h"
-#include "JackError.h"
-
-namespace Jack
-{
-
-JackEngine::JackEngine(JackGraphManager* manager,
-                       JackSynchro* table,
-                       JackEngineControl* control)
-{
-    fGraphManager = manager;
-    fSynchroTable = table;
-    fEngineControl = control;
-    for (int i = 0; i < CLIENT_NUM; i++)
-        fClientTable[i] = NULL;
-    fLastSwitchUsecs = 0;
-    fMaxUUID = 0;
-    fSessionPendingReplies = 0;
-    fSessionTransaction = NULL;
-    fSessionResult = NULL;
-}
-
-JackEngine::~JackEngine()
-{}
-
-int JackEngine::Open()
-{
-    jack_log("JackEngine::Open");
-
-    // Open audio thread => request thread communication channel
-    if (fChannel.Open(fEngineControl->fServerName) < 0) {
-        jack_error("Cannot connect to server");
-        return -1;
-    } else {
-        return 0;
-    }
-}
-
-int JackEngine::Close()
-{
-    jack_log("JackEngine::Close");
-    fChannel.Close();
-
-    // Close remaining clients (RT is stopped)
-    for (int i = fEngineControl->fDriverNum; i < CLIENT_NUM; i++) {
-        if (JackLoadableInternalClient* loadable_client = dynamic_cast<JackLoadableInternalClient*>(fClientTable[i])) {
-            jack_log("JackEngine::Close loadable client = %s", loadable_client->GetClientControl()->fName);
-            loadable_client->Close();
-            // Close does not delete the pointer for internal clients
-            fClientTable[i] = NULL;
-            delete loadable_client;
-        } else if (JackExternalClient* external_client = dynamic_cast<JackExternalClient*>(fClientTable[i])) {
-            jack_log("JackEngine::Close external client = %s", external_client->GetClientControl()->fName);
-            external_client->Close();
-            // Close deletes the pointer for external clients
-            fClientTable[i] = NULL;
-        }
-    }
-
-    return 0;
-}
-
-void JackEngine::NotifyQuit()
-{
-    fChannel.NotifyQuit();
-}
-
-//-----------------------------
-// Client ressource management
-//-----------------------------
-
-int JackEngine::AllocateRefnum()
-{
-    for (int i = 0; i < CLIENT_NUM; i++) {
-        if (!fClientTable[i]) {
-            jack_log("JackEngine::AllocateRefNum ref = %ld", i);
-            return i;
-        }
-    }
-    return -1;
-}
-
-void JackEngine::ReleaseRefnum(int ref)
-{
-    fClientTable[ref] = NULL;
-
-    if (fEngineControl->fTemporary) {
-        int i;
-        for (i = fEngineControl->fDriverNum; i < CLIENT_NUM; i++) {
-            if (fClientTable[i])
-                break;
-        }
-        if (i == CLIENT_NUM) {
-            // last client and temporay case: quit the server
-            jack_log("JackEngine::ReleaseRefnum server quit");
-            fEngineControl->fTemporary = false;
-            throw JackTemporaryException();
-        }
-    }
-}
-
-//------------------
-// Graph management
-//------------------
-
-void JackEngine::ProcessNext(jack_time_t cur_cycle_begin)
-{
-    fLastSwitchUsecs = cur_cycle_begin;
-    if (fGraphManager->RunNextGraph())  { // True if the graph actually switched to a new state
-        fChannel.Notify(ALL_CLIENTS, kGraphOrderCallback, 0);
-        //NotifyGraphReorder();
-    }
-    fSignal.Signal();                   // Signal for threads waiting for next cycle
-}
-
-void JackEngine::ProcessCurrent(jack_time_t cur_cycle_begin)
-{
-    if (cur_cycle_begin < fLastSwitchUsecs + 2 * fEngineControl->fPeriodUsecs) // Signal XRun only for the first failing cycle
-        CheckXRun(cur_cycle_begin);
-    fGraphManager->RunCurrentGraph();
-}
-
-bool JackEngine::Process(jack_time_t cur_cycle_begin, jack_time_t prev_cycle_end)
-{
-    bool res = true;
-
-    // Cycle  begin
-    fEngineControl->CycleBegin(fClientTable, fGraphManager, cur_cycle_begin, prev_cycle_end);
-
-    // Graph
-    if (fGraphManager->IsFinishedGraph()) {
-        ProcessNext(cur_cycle_begin);
-        res = true;
-    } else {
-        jack_log("Process: graph not finished!");
-        if (cur_cycle_begin > fLastSwitchUsecs + fEngineControl->fTimeOutUsecs) {
-            jack_log("Process: switch to next state delta = %ld", long(cur_cycle_begin - fLastSwitchUsecs));
-            ProcessNext(cur_cycle_begin);
-            res = true;
-        } else {
-            jack_log("Process: waiting to switch delta = %ld", long(cur_cycle_begin - fLastSwitchUsecs));
-            ProcessCurrent(cur_cycle_begin);
-            res = false;
-        }
-    }
-
-    // Cycle end
-    fEngineControl->CycleEnd(fClientTable);
-    return res;
-}
-
-/*
-Client that finish *after* the callback date are considered late even if their output buffers may have been
-correctly mixed in the time window: callbackUsecs <==> Read <==> Write.
-*/
-
-void JackEngine::CheckXRun(jack_time_t callback_usecs)  // REVOIR les conditions de fin
-{
-    for (int i = fEngineControl->fDriverNum; i < CLIENT_NUM; i++) {
-        JackClientInterface* client = fClientTable[i];
-        if (client && client->GetClientControl()->fActive) {
-            JackClientTiming* timing = fGraphManager->GetClientTiming(i);
-            jack_client_state_t status = timing->fStatus;
-            jack_time_t finished_date = timing->fFinishedAt;
-
-            if (status != NotTriggered && status != Finished) {
-                jack_error("JackEngine::XRun: client = %s was not run: state = %ld", client->GetClientControl()->fName, status);
-                fChannel.Notify(ALL_CLIENTS, kXRunCallback, 0);  // Notify all clients
-                //NotifyXRun(ALL_CLIENTS);
-            }
-
-            if (status == Finished && (long)(finished_date - callback_usecs) > 0) {
-                jack_error("JackEngine::XRun: client %s finished after current callback", client->GetClientControl()->fName);
-                fChannel.Notify(ALL_CLIENTS, kXRunCallback, 0);  // Notify all clients
-                //NotifyXRun(ALL_CLIENTS);
-            }
-        }
-    }
-}
-
-int JackEngine::ComputeTotalLatencies()
-{
-    std::vector<jack_int_t> sorted;
-    std::vector<jack_int_t>::iterator it;
-    std::vector<jack_int_t>::reverse_iterator rit;
-
-    fGraphManager->TopologicalSort(sorted);
-
-    /* iterate over all clients in graph order, and emit
-	 * capture latency callback.
-	 */
-
-    for (it = sorted.begin(); it != sorted.end(); it++) {
-        NotifyClient(*it, kLatencyCallback, true, "", 0, 0);
-    }
-
-    /* now issue playback latency callbacks in reverse graph order.
-	 */
-    for (rit = sorted.rbegin(); rit != sorted.rend(); rit++) {
-        NotifyClient(*rit, kLatencyCallback, true, "", 1, 0);
-    }
-
-    return 0;
-}
-
-//---------------
-// Notifications
-//---------------
-
-void JackEngine::NotifyClient(int refnum, int event, int sync, const char* message, int value1, int value2)
-{
-    JackClientInterface* client = fClientTable[refnum];
-
-    // The client may be notified by the RT thread while closing
-    if (client) {
-
-        if (client->GetClientControl()->fCallback[event]) {
-            /*
-                Important for internal clients : unlock before calling the notification callbacks.
-            */
-            bool res = fMutex.Unlock();
-            if (client->ClientNotify(refnum, client->GetClientControl()->fName, event, sync, message, value1, value2) < 0)
-                jack_error("NotifyClient fails name = %s event = %ld val1 = %ld val2 = %ld", client->GetClientControl()->fName, event, value1, value2);
-            if (res)
-                fMutex.Lock();
-
-        } else {
-            jack_log("JackEngine::NotifyClient: no callback for event = %ld", event);
-        }
-    }
-}
-
-void JackEngine::NotifyClients(int event, int sync, const char* message, int value1, int value2)
-{
-    for (int i = 0; i < CLIENT_NUM; i++) {
-        NotifyClient(i, event, sync, message, value1, value2);
-    }
-}
-
-int JackEngine::NotifyAddClient(JackClientInterface* new_client, const char* name, int refnum)
-{
-    jack_log("JackEngine::NotifyAddClient: name = %s", name);
-    // Notify existing clients of the new client and new client of existing clients.
-    for (int i = 0; i < CLIENT_NUM; i++) {
-        JackClientInterface* old_client = fClientTable[i];
-        if (old_client) {
-            if (old_client->ClientNotify(refnum, name, kAddClient, true, "", 0, 0) < 0) {
-                jack_error("NotifyAddClient old_client fails name = %s", old_client->GetClientControl()->fName);
-                return -1;
-            }
-            if (new_client->ClientNotify(i, old_client->GetClientControl()->fName, kAddClient, true, "", 0, 0) < 0) {
-                jack_error("NotifyAddClient new_client fails name = %s", name);
-                return -1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-void JackEngine::NotifyRemoveClient(const char* name, int refnum)
-{
-    // Notify existing clients (including the one beeing suppressed) of the removed client
-    for (int i = 0; i < CLIENT_NUM; i++) {
-        JackClientInterface* client = fClientTable[i];
-        if (client) {
-            client->ClientNotify(refnum, name, kRemoveClient, true, "",0, 0);
-        }
-    }
-}
-
-// Coming from the driver
-void JackEngine::NotifyXRun(jack_time_t callback_usecs, float delayed_usecs)
-{
-    // Use the audio thread => request thread communication channel
-    fEngineControl->NotifyXRun(callback_usecs, delayed_usecs);
-    fChannel.Notify(ALL_CLIENTS, kXRunCallback, 0);
-    //NotifyXRun(ALL_CLIENTS);
-}
-
-void JackEngine::NotifyXRun(int refnum)
-{
-    if (refnum == ALL_CLIENTS) {
-        NotifyClients(kXRunCallback, false, "", 0, 0);
-    } else {
-        NotifyClient(refnum, kXRunCallback, false, "", 0, 0);
-    }
-}
-
-void JackEngine::NotifyGraphReorder()
-{
-    NotifyClients(kGraphOrderCallback, false, "", 0, 0);
-    ComputeTotalLatencies();
-}
-
-void JackEngine::NotifyBufferSize(jack_nframes_t buffer_size)
-{
-    NotifyClients(kBufferSizeCallback, true, "", buffer_size, 0);
-}
-
-void JackEngine::NotifySampleRate(jack_nframes_t sample_rate)
-{
-    NotifyClients(kSampleRateCallback, true, "", sample_rate, 0);
-}
-
-void JackEngine::NotifyFailure(int code, const char* reason)
-{
-    NotifyClients(kShutDownCallback, false, reason, code, 0);
-}
-
-void JackEngine::NotifyFreewheel(bool onoff)
-{
-    if (onoff) {
-        // Save RT state
-        fEngineControl->fSavedRealTime = fEngineControl->fRealTime;
-        fEngineControl->fRealTime = false;
-    } else {
-        // Restore RT state
-        fEngineControl->fRealTime = fEngineControl->fSavedRealTime;
-        fEngineControl->fSavedRealTime = false;
-    }
-    NotifyClients((onoff ? kStartFreewheelCallback : kStopFreewheelCallback), true, "", 0, 0);
-}
-
-void JackEngine::NotifyPortRegistation(jack_port_id_t port_index, bool onoff)
-{
-    NotifyClients((onoff ? kPortRegistrationOnCallback : kPortRegistrationOffCallback), false, "", port_index, 0);
-}
-
-void JackEngine::NotifyPortRename(jack_port_id_t port, const char* old_name)
-{
-    NotifyClients(kPortRenameCallback, false, old_name, port, 0);
-}
-
-void JackEngine::NotifyPortConnect(jack_port_id_t src, jack_port_id_t dst, bool onoff)
-{
-    NotifyClients((onoff ? kPortConnectCallback : kPortDisconnectCallback), false, "", src, dst);
-}
-
-void JackEngine::NotifyActivate(int refnum)
-{
-    NotifyClient(refnum, kActivateClient, true, "", 0, 0);
-}
-
-//----------------------------
-// Loadable client management
-//----------------------------
-
-int JackEngine::GetInternalClientName(int refnum, char* name_res)
-{
-    JackClientInterface* client = fClientTable[refnum];
-    strncpy(name_res, client->GetClientControl()->fName, JACK_CLIENT_NAME_SIZE);
-    return 0;
-}
-
-int JackEngine::InternalClientHandle(const char* client_name, int* status, int* int_ref)
-{
-    // Clear status
-    *status = 0;
-
-    for (int i = 0; i < CLIENT_NUM; i++) {
-        JackClientInterface* client = fClientTable[i];
-        if (client && dynamic_cast<JackLoadableInternalClient*>(client) && (strcmp(client->GetClientControl()->fName, client_name) == 0)) {
-            jack_log("InternalClientHandle found client name = %s ref = %ld",  client_name, i);
-            *int_ref = i;
-            return 0;
-        }
-    }
-
-    *status |= (JackNoSuchClient | JackFailure);
-    return -1;
-}
-
-int JackEngine::InternalClientUnload(int refnum, int* status)
-{
-    JackClientInterface* client = fClientTable[refnum];
-    if (client) {
-        int res = client->Close();
-        delete client;
-        *status = 0;
-        return res;
-    } else {
-        *status = (JackNoSuchClient | JackFailure);
-        return -1;
-    }
-}
-
-//-------------------
-// Client management
-//-------------------
-
-int JackEngine::ClientCheck(const char* name, int uuid, char* name_res, int protocol, int options, int* status)
-{
-    // Clear status
-    *status = 0;
-    strcpy(name_res, name);
-
-    jack_log("Check protocol client %ld server = %ld", protocol, JACK_PROTOCOL_VERSION);
-
-    if (protocol != JACK_PROTOCOL_VERSION) {
-        *status |= (JackFailure | JackVersionError);
-        jack_error("JACK protocol mismatch (%d vs %d)", protocol, JACK_PROTOCOL_VERSION);
-        return -1;
-    }
-
-    std::map<int,std::string>::iterator res = fReservationMap.find(uuid);
-
-    if (res != fReservationMap.end()) {
-        strncpy(name_res, res->second.c_str(), JACK_CLIENT_NAME_SIZE);
-    } else if (ClientCheckName(name)) {
-
-        *status |= JackNameNotUnique;
-
-        if (options & JackUseExactName) {
-            jack_error("cannot create new client; %s already exists", name);
-            *status |= JackFailure;
-            return -1;
-        }
-
-        if (GenerateUniqueName(name_res)) {
-            *status |= JackFailure;
-            return -1;
-        }
-    }
-
-    return 0;
-}
-
-bool JackEngine::GenerateUniqueName(char* name)
-{
-    int tens, ones;
-    int length = strlen(name);
-
-    if (length > JACK_CLIENT_NAME_SIZE - 4) {
-        jack_error("%s exists and is too long to make unique", name);
-        return true;            /* failure */
-    }
-
-    /*  generate a unique name by appending "-01".."-99" */
-    name[length++] = '-';
-    tens = length++;
-    ones = length++;
-    name[tens] = '0';
-    name[ones] = '1';
-    name[length] = '\0';
-
-    while (ClientCheckName(name)) {
-        if (name[ones] == '9') {
-            if (name[tens] == '9') {
-                jack_error("client %s has 99 extra instances already", name);
-                return true; /* give up */
-            }
-            name[tens]++;
-            name[ones] = '0';
-        } else {
-            name[ones]++;
-        }
-    }
-    return false;
-}
-
-bool JackEngine::ClientCheckName(const char* name)
-{
-    for (int i = 0; i < CLIENT_NUM; i++) {
-        JackClientInterface* client = fClientTable[i];
-        if (client && (strcmp(client->GetClientControl()->fName, name) == 0))
-            return true;
-    }
-
-    for (std::map<int,std::string>::iterator i = fReservationMap.begin(); i != fReservationMap.end(); i++) {
-        if (i->second == name)
-            return true;
-    }
-
-    return false;
-}
-
-int JackEngine::GetNewUUID()
-{
-    return fMaxUUID++;
-}
-
-void JackEngine::EnsureUUID(int uuid)
-{
-    if (uuid > fMaxUUID)
-        fMaxUUID = uuid+1;
-
-    for (int i = 0; i < CLIENT_NUM; i++) {
-        JackClientInterface* client = fClientTable[i];
-        if (client && (client->GetClientControl()->fSessionID == uuid)) {
-            client->GetClientControl()->fSessionID = GetNewUUID();
-        }
-    }
-}
-
-int JackEngine::GetClientPID(const char* name)
-{
-    for (int i = 0; i < CLIENT_NUM; i++) {
-        JackClientInterface* client = fClientTable[i];
-        if (client && (strcmp(client->GetClientControl()->fName, name) == 0))
-            return client->GetClientControl()->fPID;
-    }
-
-    return 0;
-}
-
-int JackEngine::GetClientRefNum(const char* name)
-{
-    for (int i = 0; i < CLIENT_NUM; i++) {
-        JackClientInterface* client = fClientTable[i];
-        if (client && (strcmp(client->GetClientControl()->fName, name) == 0))
-            return client->GetClientControl()->fRefNum;
-    }
-
-    return -1;
-}
-
-// Used for external clients
-int JackEngine::ClientExternalOpen(const char* name, int pid, int uuid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager)
-{
-    char real_name[JACK_CLIENT_NAME_SIZE + 1];
-
-    if (uuid < 0) {
-        uuid = GetNewUUID();
-        strncpy(real_name, name, JACK_CLIENT_NAME_SIZE);
-    } else {
-        std::map<int, std::string>::iterator res = fReservationMap.find(uuid);
-        if (res != fReservationMap.end()) {
-            strncpy(real_name, res->second.c_str(), JACK_CLIENT_NAME_SIZE);
-            fReservationMap.erase(uuid);
-        } else {
-            strncpy(real_name, name, JACK_CLIENT_NAME_SIZE);
-        }
-
-        EnsureUUID(uuid);
-    }
-
-    jack_log("JackEngine::ClientExternalOpen: uuid = %d, name = %s ", uuid, real_name);
-
-    int refnum = AllocateRefnum();
-    if (refnum < 0) {
-        jack_error("No more refnum available");
-        return -1;
-    }
-
-    JackExternalClient* client = new JackExternalClient();
-
-    if (!fSynchroTable[refnum].Allocate(real_name, fEngineControl->fServerName, 0)) {
-        jack_error("Cannot allocate synchro");
-        goto error;
-    }
-
-    if (client->Open(real_name, pid, refnum, uuid, shared_client) < 0) {
-        jack_error("Cannot open client");
-        goto error;
-    }
-
-    if (!fSignal.LockedTimedWait(DRIVER_OPEN_TIMEOUT * 1000000)) {
-        // Failure if RT thread is not running (problem with the driver...)
-        jack_error("Driver is not running");
-        goto error;
-    }
-
-    fClientTable[refnum] = client;
-
-    if (NotifyAddClient(client, real_name, refnum) < 0) {
-        jack_error("Cannot notify add client");
-        goto error;
-    }
-
-    fGraphManager->InitRefNum(refnum);
-    fEngineControl->ResetRollingUsecs();
-    *shared_engine = fEngineControl->GetShmIndex();
-    *shared_graph_manager = fGraphManager->GetShmIndex();
-    *ref = refnum;
-    return 0;
-
-error:
-    // Cleanup...
-    fSynchroTable[refnum].Destroy();
-    fClientTable[refnum] = 0;
-    client->Close();
-    delete client;
-    return -1;
-}
-
-// Used for server driver clients
-int JackEngine::ClientInternalOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, bool wait)
-{
-    jack_log("JackEngine::ClientInternalOpen: name = %s", name);
-
-    int refnum = AllocateRefnum();
-    if (refnum < 0) {
-        jack_error("No more refnum available");
-        goto error;
-    }
-
-    if (!fSynchroTable[refnum].Allocate(name, fEngineControl->fServerName, 0)) {
-        jack_error("Cannot allocate synchro");
-        goto error;
-    }
-
-    if (wait && !fSignal.LockedTimedWait(DRIVER_OPEN_TIMEOUT * 1000000)) {
-        // Failure if RT thread is not running (problem with the driver...)
-        jack_error("Driver is not running");
-        goto error;
-    }
-
-    fClientTable[refnum] = client;
-
-    if (NotifyAddClient(client, name, refnum) < 0) {
-        jack_error("Cannot notify add client");
-        goto error;
-    }
-
-    fGraphManager->InitRefNum(refnum);
-    fEngineControl->ResetRollingUsecs();
-    *shared_engine = fEngineControl;
-    *shared_manager = fGraphManager;
-    *ref = refnum;
-    return 0;
-
-error:
-    // Cleanup...
-    fSynchroTable[refnum].Destroy();
-    fClientTable[refnum] = 0;
-    return -1;
-}
-
-// Used for external clients
-int JackEngine::ClientExternalClose(int refnum)
-{
-    JackClientInterface* client = fClientTable[refnum];
-    fEngineControl->fTransport.ResetTimebase(refnum);
-    int res = ClientCloseAux(refnum, client, true);
-    client->Close();
-    delete client;
-    return res;
-}
-
-// Used for server internal clients or drivers when the RT thread is stopped
-int JackEngine::ClientInternalClose(int refnum, bool wait)
-{
-    JackClientInterface* client = fClientTable[refnum];
-    return ClientCloseAux(refnum, client, wait);
-}
-
-int JackEngine::ClientCloseAux(int refnum, JackClientInterface* client, bool wait)
-{
-    jack_log("JackEngine::ClientCloseAux ref = %ld", refnum);
-
-    // Unregister all ports ==> notifications are sent
-    jack_int_t ports[PORT_NUM_FOR_CLIENT];
-    int i;
-
-    fGraphManager->GetInputPorts(refnum, ports);
-    for (i = 0; (i < PORT_NUM_FOR_CLIENT) && (ports[i] != EMPTY) ; i++) {
-        PortUnRegister(refnum, ports[i]);
-    }
-
-    fGraphManager->GetOutputPorts(refnum, ports);
-    for (i = 0; (i < PORT_NUM_FOR_CLIENT) && (ports[i] != EMPTY) ; i++) {
-        PortUnRegister(refnum, ports[i]);
-    }
-
-    // Remove the client from the table
-    ReleaseRefnum(refnum);
-
-    // Remove all ports
-    fGraphManager->RemoveAllPorts(refnum);
-
-    // Wait until next cycle to be sure client is not used anymore
-    if (wait) {
-        if (!fSignal.LockedTimedWait(fEngineControl->fTimeOutUsecs * 2)) { // Must wait at least until a switch occurs in Process, even in case of graph end failure
-            jack_error("JackEngine::ClientCloseAux wait error ref = %ld", refnum);
-        }
-    }
-
-    // Notify running clients
-    NotifyRemoveClient(client->GetClientControl()->fName, client->GetClientControl()->fRefNum);
-
-    // Cleanup...
-    fSynchroTable[refnum].Destroy();
-    fEngineControl->ResetRollingUsecs();
-    return 0;
-}
-
-int JackEngine::ClientActivate(int refnum, bool is_real_time)
-{
-    JackClientInterface* client = fClientTable[refnum];
-    jack_log("JackEngine::ClientActivate ref = %ld name = %s", refnum, client->GetClientControl()->fName);
-
-    if (is_real_time)
-        fGraphManager->Activate(refnum);
-
-    // Wait for graph state change to be effective
-    if (!fSignal.LockedTimedWait(fEngineControl->fTimeOutUsecs * 10)) {
-        jack_error("JackEngine::ClientActivate wait error ref = %ld name = %s", refnum, client->GetClientControl()->fName);
-        return -1;
-    } else {
-        jack_int_t input_ports[PORT_NUM_FOR_CLIENT];
-        jack_int_t output_ports[PORT_NUM_FOR_CLIENT];
-        fGraphManager->GetInputPorts(refnum, input_ports);
-        fGraphManager->GetOutputPorts(refnum, output_ports);
-
-        // Notify client
-        NotifyActivate(refnum);
-
-        // Then issue port registration notification
-        for (int i = 0; (i < PORT_NUM_FOR_CLIENT) && (input_ports[i] != EMPTY); i++) {
-            NotifyPortRegistation(input_ports[i], true);
-        }
-        for (int i = 0; (i < PORT_NUM_FOR_CLIENT) && (output_ports[i] != EMPTY); i++) {
-            NotifyPortRegistation(output_ports[i], true);
-        }
-
-        return 0;
-    }
-}
-
-// May be called without client
-int JackEngine::ClientDeactivate(int refnum)
-{
-    JackClientInterface* client = fClientTable[refnum];
-    jack_log("JackEngine::ClientDeactivate ref = %ld name = %s", refnum, client->GetClientControl()->fName);
-
-    jack_int_t input_ports[PORT_NUM_FOR_CLIENT];
-    jack_int_t output_ports[PORT_NUM_FOR_CLIENT];
-    fGraphManager->GetInputPorts(refnum, input_ports);
-    fGraphManager->GetOutputPorts(refnum, output_ports);
-
-    // First disconnect all ports
-    for (int i = 0; (i < PORT_NUM_FOR_CLIENT) && (input_ports[i] != EMPTY); i++) {
-        PortDisconnect(refnum, input_ports[i], ALL_PORTS);
-    }
-    for (int i = 0; (i < PORT_NUM_FOR_CLIENT) && (output_ports[i] != EMPTY); i++) {
-        PortDisconnect(refnum, output_ports[i], ALL_PORTS);
-    }
-
-    // Then issue port registration notification
-    for (int i = 0; (i < PORT_NUM_FOR_CLIENT) && (input_ports[i] != EMPTY); i++) {
-        NotifyPortRegistation(input_ports[i], false);
-    }
-    for (int i = 0; (i < PORT_NUM_FOR_CLIENT) && (output_ports[i] != EMPTY); i++) {
-        NotifyPortRegistation(output_ports[i], false);
-    }
-
-    fGraphManager->Deactivate(refnum);
-    fLastSwitchUsecs = 0; // Force switch to occur next cycle, even when called with "dead" clients
-
-    // Wait for graph state change to be effective
-    if (!fSignal.LockedTimedWait(fEngineControl->fTimeOutUsecs * 10)) {
-        jack_error("JackEngine::ClientDeactivate wait error ref = %ld name = %s", refnum, client->GetClientControl()->fName);
-        return -1;
-    } else {
-        return 0;
-    }
-}
-
-//-----------------
-// Port management
-//-----------------
-
-int JackEngine::PortRegister(int refnum, const char* name, const char *type, unsigned int flags, unsigned int buffer_size, jack_port_id_t* port_index)
-{
-    jack_log("JackEngine::PortRegister ref = %ld name = %s type = %s flags = %d buffer_size = %d", refnum, name, type, flags, buffer_size);
-    JackClientInterface* client = fClientTable[refnum];
-
-    // Check if port name already exists
-    if (fGraphManager->GetPort(name) != NO_PORT) {
-        jack_error("port_name \"%s\" already exists", name);
-        return -1;
-    }
-
-    *port_index = fGraphManager->AllocatePort(refnum, name, type, (JackPortFlags)flags, fEngineControl->fBufferSize);
-    if (*port_index != NO_PORT) {
-        if (client->GetClientControl()->fActive)
-            NotifyPortRegistation(*port_index, true);
-        return 0;
-    } else {
-        return -1;
-    }
-}
-
-int JackEngine::PortUnRegister(int refnum, jack_port_id_t port_index)
-{
-    jack_log("JackEngine::PortUnRegister ref = %ld port_index = %ld", refnum, port_index);
-    JackClientInterface* client = fClientTable[refnum];
-
-    // Disconnect port ==> notification is sent
-    PortDisconnect(refnum, port_index, ALL_PORTS);
-
-    if (fGraphManager->ReleasePort(refnum, port_index) == 0) {
-        if (client->GetClientControl()->fActive)
-            NotifyPortRegistation(port_index, false);
-        return 0;
-    } else {
-        return -1;
-    }
-}
-
-int JackEngine::PortConnect(int refnum, const char* src, const char* dst)
-{
-    jack_log("JackEngine::PortConnect src = %s dst = %s", src, dst);
-    jack_port_id_t port_src, port_dst;
-
-    return (fGraphManager->GetTwoPorts(src, dst, &port_src, &port_dst) < 0)
-           ? -1
-           : PortConnect(refnum, port_src, port_dst);
-}
-
-int JackEngine::PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst)
-{
-    jack_log("JackEngine::PortConnect src = %d dst = %d", src, dst);
-    JackClientInterface* client;
-    int ref;
-
-    if (fGraphManager->CheckPorts(src, dst) < 0)
-        return -1;
-
-    ref = fGraphManager->GetOutputRefNum(src);
-    assert(ref >= 0);
-    client = fClientTable[ref];
-    assert(client);
-    if (!client->GetClientControl()->fActive) {
-        jack_error("Cannot connect ports owned by inactive clients:"
-                   " \"%s\" is not active", client->GetClientControl()->fName);
-        return -1;
-    }
-
-    ref = fGraphManager->GetInputRefNum(dst);
-    assert(ref >= 0);
-    client = fClientTable[ref];
-    assert(client);
-    if (!client->GetClientControl()->fActive) {
-        jack_error("Cannot connect ports owned by inactive clients:"
-                   " \"%s\" is not active", client->GetClientControl()->fName);
-        return -1;
-    }
-
-    int res = fGraphManager->Connect(src, dst);
-    if (res == 0)
-        NotifyPortConnect(src, dst, true);
-    return res;
-}
-
-int JackEngine::PortDisconnect(int refnum, const char* src, const char* dst)
-{
-    jack_log("JackEngine::PortDisconnect src = %s dst = %s", src, dst);
-    jack_port_id_t port_src, port_dst;
-
-    return (fGraphManager->GetTwoPorts(src, dst, &port_src, &port_dst) < 0)
-           ? -1
-           : PortDisconnect(refnum, port_src, port_dst);
-}
-
-int JackEngine::PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst)
-{
-    jack_log("JackEngine::PortDisconnect src = %d dst = %d", src, dst);
-
-    if (dst == ALL_PORTS) {
-
-        jack_int_t connections[CONNECTION_NUM_FOR_PORT];
-        fGraphManager->GetConnections(src, connections);
-
-        JackPort* port = fGraphManager->GetPort(src);
-        int ret = 0;
-        if (port->GetFlags() & JackPortIsOutput) {
-            for (int i = 0; (i < CONNECTION_NUM_FOR_PORT) && (connections[i] != EMPTY); i++) {
-                if (PortDisconnect(refnum, src, connections[i]) != 0) {
-                    ret = -1;
-                }
-            }
-        } else {
-            for (int i = 0; (i < CONNECTION_NUM_FOR_PORT) && (connections[i] != EMPTY); i++) {
-                if (PortDisconnect(refnum, connections[i], src) != 0) {
-                    ret = -1;
-                }
-            }
-        }
-
-        return ret;
-    } else if (fGraphManager->CheckPorts(src, dst) < 0) {
-        return -1;
-    } else if (fGraphManager->Disconnect(src, dst) == 0) {
-        // Notifications
-        NotifyPortConnect(src, dst, false);
-        return 0;
-    } else {
-        return -1;
-    }
-}
-
-int JackEngine::PortRename(int refnum, jack_port_id_t port, const char* name)
-{
-    char old_name[JACK_CLIENT_NAME_SIZE + JACK_PORT_NAME_SIZE];
-    strcpy(old_name, fGraphManager->GetPort(port)->GetName());
-    fGraphManager->GetPort(port)->SetName(name);
-    NotifyPortRename(port, old_name);
-    return 0;
-}
-
-//--------------------
-// Session management
-//--------------------
-
-void JackEngine::SessionNotify(int refnum, const char *target, jack_session_event_type_t type, const char *path, JackChannelTransaction *socket)
-{
-    if (fSessionPendingReplies != 0) {
-        JackSessionNotifyResult res(-1);
-        res.Write(socket);
-        jack_log("JackEngine::SessionNotify ... busy");
-        return;
-    }
-
-    for (int i = 0; i < CLIENT_NUM; i++) {
-        JackClientInterface* client = fClientTable[i];
-        if (client && (client->GetClientControl()->fSessionID < 0)) {
-            client->GetClientControl()->fSessionID = GetNewUUID();
-        }
-    }
-    fSessionResult = new JackSessionNotifyResult();
-
-    for (int i = 0; i < CLIENT_NUM; i++) {
-        JackClientInterface* client = fClientTable[i];
-        if (client && client->GetClientControl()->fCallback[kSessionCallback]) {
-
-            // check if this is a notification to a specific client.
-            if (target != NULL && strlen(target) != 0) {
-                if (strcmp(target, client->GetClientControl()->fName)) {
-                    continue;
-                }
-            }
-
-            char path_buf[JACK_PORT_NAME_SIZE];
-            snprintf( path_buf, sizeof(path_buf), "%s%s%c", path, client->GetClientControl()->fName, DIR_SEPARATOR );
-
-            int res = JackTools::MkDir(path_buf);
-            if (res)
-                jack_error( "JackEngine::SessionNotify: can not create session directory '%s'", path_buf );
-
-            int result = client->ClientNotify(i, client->GetClientControl()->fName, kSessionCallback, true, path_buf, (int) type, 0);
-
-            if (result == 2) {
-                fSessionPendingReplies += 1;
-            } else if (result == 1) {
-                char uuid_buf[JACK_UUID_SIZE];
-                snprintf( uuid_buf, sizeof(uuid_buf), "%d", client->GetClientControl()->fSessionID );
-                fSessionResult->fCommandList.push_back( JackSessionCommand( uuid_buf,
-                                                                            client->GetClientControl()->fName,
-                                                                            client->GetClientControl()->fSessionCommand,
-                                                                            client->GetClientControl()->fSessionFlags ));
-            }
-        }
-    }
-
-    if (fSessionPendingReplies == 0) {
-        fSessionResult->Write(socket);
-        delete fSessionResult;
-        fSessionResult = NULL;
-    } else {
-        fSessionTransaction = socket;
-    }
-}
-
-void JackEngine::SessionReply(int refnum)
-{
-    JackClientInterface* client = fClientTable[refnum];
-    char uuid_buf[JACK_UUID_SIZE];
-    snprintf( uuid_buf, sizeof(uuid_buf), "%d", client->GetClientControl()->fSessionID);
-    fSessionResult->fCommandList.push_back(JackSessionCommand(uuid_buf,
-                                                            client->GetClientControl()->fName,
-                                                            client->GetClientControl()->fSessionCommand,
-                                                            client->GetClientControl()->fSessionFlags));
-    fSessionPendingReplies -= 1;
-
-    if (fSessionPendingReplies == 0) {
-        fSessionResult->Write(fSessionTransaction);
-        delete fSessionResult;
-        fSessionResult = NULL;
-    }
-}
-
-void JackEngine::GetUUIDForClientName(const char *client_name, char *uuid_res, int *result)
-{
-    for (int i = 0; i < CLIENT_NUM; i++) {
-        JackClientInterface* client = fClientTable[i];
-
-        if (client && (strcmp(client_name, client->GetClientControl()->fName) == 0)) {
-            snprintf(uuid_res, JACK_UUID_SIZE, "%d", client->GetClientControl()->fSessionID);
-            *result = 0;
-            return;
-        }
-    }
-    // Did not find name.
-    *result = -1;
-}
-
-void JackEngine::GetClientNameForUUID(const char *uuid, char *name_res, int *result)
-{
-    for (int i = 0; i < CLIENT_NUM; i++) {
-        JackClientInterface* client = fClientTable[i];
-
-        if (!client)
-            continue;
-
-        char uuid_buf[JACK_UUID_SIZE];
-        snprintf(uuid_buf, JACK_UUID_SIZE, "%d", client->GetClientControl()->fSessionID);
-
-        if (strcmp(uuid,uuid_buf) == 0) {
-            strncpy(name_res, client->GetClientControl()->fName, JACK_CLIENT_NAME_SIZE);
-            *result = 0;
-            return;
-        }
-    }
-    // Did not find uuid.
-    *result = -1;
-}
-
-void JackEngine::ReserveClientName(const char *name, const char *uuid, int *result)
-{
-    jack_log("JackEngine::ReserveClientName ( name = %s, uuid = %s )", name, uuid);
-
-    if (ClientCheckName(name)) {
-        *result = -1;
-        jack_log("name already taken");
-        return;
-    }
-
-    EnsureUUID(atoi(uuid));
-    fReservationMap[atoi(uuid)] = name;
-    *result = 0;
-}
-
-void JackEngine::ClientHasSessionCallbackRequest(const char *name, int *result)
-{
-    JackClientInterface* client = NULL;
-    for (int i = 0; i < CLIENT_NUM; i++) {
-        JackClientInterface* client = fClientTable[i];
-        if (client && (strcmp(client->GetClientControl()->fName, name) == 0))
-            break;
-    }
-
-    if (client) {
-        *result = client->GetClientControl()->fCallback[kSessionCallback];
-     } else {
-        *result = -1;
-    }
-}
-
-} // end of namespace
-

=== removed file '.pc/no-selfconnect.patch/common/JackEngine.h'
--- .pc/no-selfconnect.patch/common/JackEngine.h	2011-03-31 13:54:50 +0000
+++ .pc/no-selfconnect.patch/common/JackEngine.h	1970-01-01 00:00:00 +0000
@@ -1,161 +0,0 @@
-/*
-Copyright (C) 2004-2008 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 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.
-
-*/
-
-#ifndef __JackEngine__
-#define __JackEngine__
-
-#include "JackConstants.h"
-#include "JackGraphManager.h"
-#include "JackSynchro.h"
-#include "JackMutex.h"
-#include "JackTransportEngine.h"
-#include "JackPlatformPlug.h"
-#include <map>
-
-namespace Jack
-{
-
-class JackClientInterface;
-struct JackEngineControl;
-class JackExternalClient;
-
-/*!
-\brief Engine description.
-*/
-
-class SERVER_EXPORT JackEngine : public JackLockAble
-{
-    friend class JackLockedEngine;
-
-    private:
-
-        JackGraphManager* fGraphManager;
-        JackEngineControl* fEngineControl;
-        JackClientInterface* fClientTable[CLIENT_NUM];
-        JackSynchro* fSynchroTable;
-        JackServerNotifyChannel fChannel;              /*! To communicate between the RT thread and server */
-        JackProcessSync fSignal;
-        jack_time_t fLastSwitchUsecs;
-
-        int fSessionPendingReplies;
-        JackChannelTransaction *fSessionTransaction;
-        JackSessionNotifyResult *fSessionResult;
-        std::map<int,std::string> fReservationMap;
-        int fMaxUUID;
-
-        int ClientCloseAux(int refnum, JackClientInterface* client, bool wait);
-        void CheckXRun(jack_time_t callback_usecs);
-
-        int NotifyAddClient(JackClientInterface* new_client, const char* name, int refnum);
-        void NotifyRemoveClient(const char* name, int refnum);
-
-        void ProcessNext(jack_time_t callback_usecs);
-        void ProcessCurrent(jack_time_t callback_usecs);
-
-        bool ClientCheckName(const char* name);
-        bool GenerateUniqueName(char* name);
-
-        int AllocateRefnum();
-        void ReleaseRefnum(int ref);
-
-        void NotifyClient(int refnum, int event, int sync, const char*  message, int value1, int value2);
-        void NotifyClients(int event, int sync, const char*  message,  int value1, int value2);
-
-        void NotifyPortRegistation(jack_port_id_t port_index, bool onoff);
-        void NotifyPortConnect(jack_port_id_t src, jack_port_id_t dst, bool onoff);
-        void NotifyPortRename(jack_port_id_t src, const char* old_name);
-        void NotifyActivate(int refnum);
-
-        int GetNewUUID();
-        void EnsureUUID(int uuid);
-
-        bool CheckClient(int refnum)
-        {
-            return (refnum >= 0 && refnum < CLIENT_NUM && fClientTable[refnum] != NULL);
-        }
-
-    public:
-
-        JackEngine(JackGraphManager* manager, JackSynchro* table, JackEngineControl* controler);
-        ~JackEngine();
-
-        int Open();
-        int Close();
-
-        // Client management
-        int ClientCheck(const char* name, int uuid, char* name_res, int protocol, int options, int* status);
-        int ClientExternalOpen(const char* name, int pid, int uuid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager);
-        int ClientInternalOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, bool wait);
-
-        int ClientExternalClose(int refnum);
-        int ClientInternalClose(int refnum, bool wait);
-
-        int ClientActivate(int refnum, bool is_real_time);
-        int ClientDeactivate(int refnum);
-
-        int GetClientPID(const char* name);
-        int GetClientRefNum(const char* name);
-
-        // Internal client management
-        int GetInternalClientName(int int_ref, char* name_res);
-        int InternalClientHandle(const char* client_name, int* status, int* int_ref);
-        int InternalClientUnload(int refnum, int* status);
-
-        // Port management
-        int PortRegister(int refnum, const char* name, const char *type, unsigned int flags, unsigned int buffer_size, jack_port_id_t* port);
-        int PortUnRegister(int refnum, jack_port_id_t port);
-
-        int PortConnect(int refnum, const char* src, const char* dst);
-        int PortDisconnect(int refnum, const char* src, const char* dst);
-
-        int PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst);
-        int PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst);
-
-        int PortRename(int refnum, jack_port_id_t port, const char* name);
-
-        int ComputeTotalLatencies();
-
-        // Graph
-        bool Process(jack_time_t cur_cycle_begin, jack_time_t prev_cycle_end);
-
-        // Notifications
-        void NotifyXRun(jack_time_t callback_usecs, float delayed_usecs);
-        void NotifyFailure(int code, const char* reason);
-        void NotifyXRun(int refnum);
-        void NotifyGraphReorder();
-        void NotifyBufferSize(jack_nframes_t buffer_size);
-        void NotifySampleRate(jack_nframes_t sample_rate);
-        void NotifyFreewheel(bool onoff);
-        void NotifyQuit();
-
-        // Session management
-        void SessionNotify(int refnum, const char *target, jack_session_event_type_t type, const char *path, JackChannelTransaction *socket);
-        void SessionReply(int refnum);
-
-        void GetUUIDForClientName(const char *client_name, char *uuid_res, int *result);
-        void GetClientNameForUUID(const char *uuid, char *name_res, int *result);
-        void ReserveClientName(const char *name, const char *uuid, int *result);
-        void ClientHasSessionCallbackRequest(const char *name, int *result);
-};
-
-
-} // end of namespace
-
-#endif
-

=== removed file '.pc/no-selfconnect.patch/common/JackLockedEngine.h'
--- .pc/no-selfconnect.patch/common/JackLockedEngine.h	2011-03-31 13:54:50 +0000
+++ .pc/no-selfconnect.patch/common/JackLockedEngine.h	1970-01-01 00:00:00 +0000
@@ -1,368 +0,0 @@
-/*
-Copyright (C) 2008 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 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.
-
-*/
-
-#ifndef __JackLockedEngine__
-#define __JackLockedEngine__
-
-#include "JackEngine.h"
-#include "JackMutex.h"
-#include "JackTools.h"
-#include "JackException.h"
-
-namespace Jack
-{
-
-#define TRY_CALL    \
-    try {           \
-
-/*
-See : http://groups.google.com/group/comp.programming.threads/browse_thread/thread/652bcf186fbbf697/f63757846514e5e5
-
-catch (...) {
-    // Assuming thread cancellation, must rethrow
-    throw;
-}
-*/
-
-#define CATCH_EXCEPTION_RETURN                      \
-    } catch(std::bad_alloc& e) {                    \
-        jack_error("Memory allocation error...");   \
-        return -1;                                  \
-    } catch(JackTemporaryException& e) {                       \
-        jack_error("JackTemporaryException : now quits...");   \
-        JackTools::KillServer();                     \
-        return -1;                                  \
-    } catch (...) {                                 \
-        jack_error("Unknown error...");             \
-        throw;                                      \
-    }                                               \
-
-#define CATCH_EXCEPTION                      \
-    } catch(std::bad_alloc& e) {                    \
-        jack_error("Memory allocation error...");   \
-    } catch (...) {                                 \
-        jack_error("Unknown error...");             \
-        throw;                                      \
-    }                                               \
-
-
-/*!
-\brief Locked Engine, access to methods is serialized using a mutex.
-*/
-
-class SERVER_EXPORT JackLockedEngine
-{
-    private:
-
-        JackEngine fEngine;
-
-    public:
-
-        JackLockedEngine(JackGraphManager* manager, JackSynchro* table, JackEngineControl* controler):
-            fEngine(manager, table, controler)
-        {}
-        ~JackLockedEngine()
-        {}
-
-        int Open()
-        {
-            // No lock needed
-            TRY_CALL
-            return fEngine.Open();
-            CATCH_EXCEPTION_RETURN
-        }
-        int Close()
-        {
-            // No lock needed
-            TRY_CALL
-            return fEngine.Close();
-            CATCH_EXCEPTION_RETURN
-        }
-
-        // Client management
-        int ClientCheck(const char* name, int uuid, char* name_res, int protocol, int options, int* status)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return fEngine.ClientCheck(name, uuid, name_res, protocol, options, status);
-            CATCH_EXCEPTION_RETURN
-        }
-        int ClientExternalOpen(const char* name, int pid, int uuid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return fEngine.ClientExternalOpen(name, pid, uuid, ref, shared_engine, shared_client, shared_graph_manager);
-            CATCH_EXCEPTION_RETURN
-        }
-        int ClientInternalOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, bool wait)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return fEngine.ClientInternalOpen(name, ref, shared_engine, shared_manager, client, wait);
-            CATCH_EXCEPTION_RETURN
-        }
-
-        int ClientExternalClose(int refnum)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return (fEngine.CheckClient(refnum)) ? fEngine.ClientExternalClose(refnum) : - 1;
-            CATCH_EXCEPTION_RETURN
-        }
-        int ClientInternalClose(int refnum, bool wait)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return (fEngine.CheckClient(refnum)) ? fEngine.ClientInternalClose(refnum, wait) : -1;
-            CATCH_EXCEPTION_RETURN
-        }
-
-        int ClientActivate(int refnum, bool is_real_time)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return (fEngine.CheckClient(refnum)) ? fEngine.ClientActivate(refnum, is_real_time) : -1;
-            CATCH_EXCEPTION_RETURN
-        }
-        int ClientDeactivate(int refnum)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return (fEngine.CheckClient(refnum)) ? fEngine.ClientDeactivate(refnum) : -1;
-            CATCH_EXCEPTION_RETURN
-        }
-
-        // Internal client management
-        int GetInternalClientName(int int_ref, char* name_res)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return fEngine.GetInternalClientName(int_ref, name_res);
-            CATCH_EXCEPTION_RETURN
-        }
-        int InternalClientHandle(const char* client_name, int* status, int* int_ref)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return fEngine.InternalClientHandle(client_name, status, int_ref);
-            CATCH_EXCEPTION_RETURN
-        }
-        int InternalClientUnload(int refnum, int* status)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            // Client is tested in fEngine.InternalClientUnload
-            return fEngine.InternalClientUnload(refnum, status);
-            CATCH_EXCEPTION_RETURN
-        }
-
-        // Port management
-        int PortRegister(int refnum, const char* name, const char *type, unsigned int flags, unsigned int buffer_size, jack_port_id_t* port)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return (fEngine.CheckClient(refnum)) ? fEngine.PortRegister(refnum, name, type, flags, buffer_size, port) : -1;
-            CATCH_EXCEPTION_RETURN
-        }
-        int PortUnRegister(int refnum, jack_port_id_t port)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return (fEngine.CheckClient(refnum)) ? fEngine.PortUnRegister(refnum, port) : -1;
-            CATCH_EXCEPTION_RETURN
-        }
-
-        int PortConnect(int refnum, const char* src, const char* dst)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return (fEngine.CheckClient(refnum)) ? fEngine.PortConnect(refnum, src, dst) : -1;
-            CATCH_EXCEPTION_RETURN
-        }
-        int PortDisconnect(int refnum, const char* src, const char* dst)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return (fEngine.CheckClient(refnum)) ? fEngine.PortDisconnect(refnum, src, dst) : -1;
-            CATCH_EXCEPTION_RETURN
-        }
-
-        int PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return (fEngine.CheckClient(refnum)) ? fEngine.PortConnect(refnum, src, dst) : -1;
-            CATCH_EXCEPTION_RETURN
-        }
-        int PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return (fEngine.CheckClient(refnum)) ? fEngine.PortDisconnect(refnum, src, dst) : -1;
-            CATCH_EXCEPTION_RETURN
-        }
-
-        int PortRename(int refnum, jack_port_id_t port, const char* name)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return (fEngine.CheckClient(refnum)) ? fEngine.PortRename(refnum, port, name) : -1;
-            CATCH_EXCEPTION_RETURN
-        }
-
-        int ComputeTotalLatencies()
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return fEngine.ComputeTotalLatencies();
-            CATCH_EXCEPTION_RETURN
-        }
-
-        // Graph
-        bool Process(jack_time_t cur_cycle_begin, jack_time_t prev_cycle_end)
-        {
-            // RT : no lock
-            return fEngine.Process(cur_cycle_begin, prev_cycle_end);
-        }
-
-        // Notifications
-        void NotifyXRun(jack_time_t cur_cycle_begin, float delayed_usecs)
-        {
-            // RT : no lock
-            fEngine.NotifyXRun(cur_cycle_begin, delayed_usecs);
-        }
-
-        void NotifyXRun(int refnum)
-        {
-            // RT : no lock
-            fEngine.NotifyXRun(refnum);
-        }
-
-        void NotifyGraphReorder()
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            fEngine.NotifyGraphReorder();
-            CATCH_EXCEPTION
-        }
-        void NotifyBufferSize(jack_nframes_t buffer_size)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            fEngine.NotifyBufferSize(buffer_size);
-            CATCH_EXCEPTION
-        }
-        void NotifySampleRate(jack_nframes_t sample_rate)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            fEngine.NotifySampleRate(sample_rate);
-            CATCH_EXCEPTION
-        }
-        void NotifyFreewheel(bool onoff)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            fEngine.NotifyFreewheel(onoff);
-            CATCH_EXCEPTION
-        }
-
-        void NotifyFailure(int code, const char* reason)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            fEngine.NotifyFailure(code, reason);
-            CATCH_EXCEPTION
-        }
-
-        int GetClientPID(const char* name)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return fEngine.GetClientPID(name);
-            CATCH_EXCEPTION_RETURN
-        }
-
-        int GetClientRefNum(const char* name)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return fEngine.GetClientRefNum(name);
-            CATCH_EXCEPTION_RETURN
-        }
-
-        void NotifyQuit()
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            return fEngine.NotifyQuit();
-            CATCH_EXCEPTION
-        }
-
-        void SessionNotify(int refnum, const char* target, jack_session_event_type_t type, const char *path, JackChannelTransaction *socket)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            fEngine.SessionNotify(refnum, target, type, path, socket);
-            CATCH_EXCEPTION
-        }
-
-        void SessionReply(int refnum)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            fEngine.SessionReply(refnum);
-            CATCH_EXCEPTION
-        }
-
-        void GetUUIDForClientName(const char *client_name, char *uuid_res, int *result)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            fEngine.GetUUIDForClientName(client_name, uuid_res, result);
-            CATCH_EXCEPTION
-        }
-        void GetClientNameForUUID(const char *uuid, char *name_res, int *result)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            fEngine.GetClientNameForUUID(uuid, name_res, result);
-            CATCH_EXCEPTION
-        }
-        void ReserveClientName(const char *name, const char *uuid, int *result)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            fEngine.ReserveClientName(name, uuid, result);
-            CATCH_EXCEPTION
-        }
-
-        void ClientHasSessionCallbackRequest(const char *name, int *result)
-        {
-            TRY_CALL
-            JackLock lock(&fEngine);
-            fEngine.ClientHasSessionCallbackRequest(name, result);
-            CATCH_EXCEPTION
-        }
-};
-
-} // end of namespace
-
-#endif
-

=== removed file '.pc/no-selfconnect.patch/common/JackServer.cpp'
--- .pc/no-selfconnect.patch/common/JackServer.cpp	2011-03-31 13:54:50 +0000
+++ .pc/no-selfconnect.patch/common/JackServer.cpp	1970-01-01 00:00:00 +0000
@@ -1,408 +0,0 @@
-/*
-Copyright (C) 2001 Paul Davis
-Copyright (C) 2004-2008 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 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.
-
-*/
-
-#include "JackSystemDeps.h"
-#include "JackServerGlobals.h"
-#include "JackTime.h"
-#include "JackFreewheelDriver.h"
-#include "JackDummyDriver.h"
-#include "JackThreadedDriver.h"
-#include "JackGlobals.h"
-#include "JackLockedEngine.h"
-#include "JackAudioDriver.h"
-#include "JackChannel.h"
-#include "JackClientControl.h"
-#include "JackEngineControl.h"
-#include "JackGraphManager.h"
-#include "JackInternalClient.h"
-#include "JackError.h"
-#include "JackMessageBuffer.h"
-
-namespace Jack
-{
-
-JackServer::JackServer(bool sync, bool temporary, int timeout, bool rt, int priority, int port_max, bool verbose, jack_timer_type_t clock, const char* server_name)
-{
-    if (rt) {
-        jack_info("JACK server starting in realtime mode with priority %ld", priority);
-    } else {
-        jack_info("JACK server starting in non-realtime mode");
-    }
-
-    fGraphManager = JackGraphManager::Allocate(port_max);
-    fEngineControl = new JackEngineControl(sync, temporary, timeout, rt, priority, verbose, clock, server_name);
-    fEngine = new JackLockedEngine(fGraphManager, GetSynchroTable(), fEngineControl);
-
-    // A distinction is made between the threaded freewheel driver and the
-    // regular freewheel driver because the freewheel driver needs to run in
-    // threaded mode when freewheel mode is active and needs to run as a slave
-    // when freewheel mode isn't active.
-    JackFreewheelDriver *freewheelDriver =
-        new JackFreewheelDriver(fEngine, GetSynchroTable());
-    fThreadedFreewheelDriver = new JackThreadedDriver(freewheelDriver);
-
-   fFreewheelDriver = freewheelDriver;
-    fDriverInfo = new JackDriverInfo();
-    fAudioDriver = NULL;
-    fFreewheel = false;
-    JackServerGlobals::fInstance = this;   // Unique instance
-    JackServerGlobals::fUserCount = 1;     // One user
-    JackGlobals::fVerbose = verbose;
-}
-
-JackServer::~JackServer()
-{
-    JackGraphManager::Destroy(fGraphManager);
-    delete fDriverInfo;
-    delete fThreadedFreewheelDriver;
-    delete fEngine;
-    delete fEngineControl;
-}
-
-int JackServer::Open(jack_driver_desc_t* driver_desc, JSList* driver_params)
-{
-    // TODO: move that in reworked JackServerGlobals::Init()
-    JackMessageBuffer::Create();
-
-     if ((fAudioDriver = fDriverInfo->Open(driver_desc, fEngine, GetSynchroTable(), driver_params)) == NULL) {
-        jack_error("Cannot initialize driver");
-        goto fail_close1;
-    }
-
-    if (fChannel.Open(fEngineControl->fServerName, this) < 0) {
-        jack_error("Server channel open error");
-        goto fail_close2;
-    }
-
-    if (fEngine->Open() < 0) {
-        jack_error("Cannot open engine");
-        goto fail_close3;
-    }
-
-    if (fFreewheelDriver->Open() < 0) {
-        jack_error("Cannot open freewheel driver");
-        goto fail_close4;
-    }
-
-    if (fAudioDriver->Attach() < 0) {
-        jack_error("Cannot attach audio driver");
-        goto fail_close5;
-    }
-
-    fFreewheelDriver->SetMaster(false);
-    fAudioDriver->SetMaster(true);
-    fAudioDriver->AddSlave(fFreewheelDriver);
-    InitTime();
-    SetClockSource(fEngineControl->fClockSource);
-    return 0;
-
-fail_close5:
-    fFreewheelDriver->Close();
-
-fail_close4:
-    fEngine->Close();
-
-fail_close3:
-    fChannel.Close();
-
-fail_close2:
-    fAudioDriver->Close();
-
-fail_close1:
-    JackMessageBuffer::Destroy();
-    return -1;
-}
-
-int JackServer::Close()
-{
-    jack_log("JackServer::Close");
-    fEngine->NotifyQuit();
-    fChannel.Close();
-    fAudioDriver->Detach();
-    fAudioDriver->Close();
-    fFreewheelDriver->Close();
-    fEngine->Close();
-    // TODO: move that in reworked JackServerGlobals::Destroy()
-    JackMessageBuffer::Destroy();
-    return 0;
-}
-
-int JackServer::InternalClientLoad1(const char* client_name, const char* so_name, const char* objet_data, int options, int* int_ref, int uuid, int* status)
-{
-    JackLoadableInternalClient* client = new JackLoadableInternalClient1(JackServerGlobals::fInstance, GetSynchroTable(), objet_data);
-    assert(client);
-    return InternalClientLoadAux(client, so_name, client_name, options, int_ref, uuid, status);
- }
-
-int JackServer::InternalClientLoad2(const char* client_name, const char* so_name, const JSList * parameters, int options, int* int_ref, int uuid, int* status)
-{
-    JackLoadableInternalClient* client = new JackLoadableInternalClient2(JackServerGlobals::fInstance, GetSynchroTable(), parameters);
-    assert(client);
-    return InternalClientLoadAux(client, so_name, client_name, options, int_ref, uuid, status);
-}
-
-int JackServer::InternalClientLoadAux(JackLoadableInternalClient* client, const char* so_name, const char* client_name, int options, int* int_ref, int uuid, int* status)
-{
-    // Clear status
-    *status = 0;
-
-    // Client object is internally kept in JackEngine
-    if ((client->Init(so_name) < 0) || (client->Open(JACK_DEFAULT_SERVER_NAME, client_name,  uuid, (jack_options_t)options, (jack_status_t*)status) < 0)) {
-        delete client;
-        int my_status1 = *status | JackFailure;
-        *status = (jack_status_t)my_status1;
-        *int_ref = 0;
-        return -1;
-    } else {
-        *int_ref = client->GetClientControl()->fRefNum;
-        return 0;
-    }
- }
-
-int JackServer::Start()
-{
-    jack_log("JackServer::Start");
-    if (fAudioDriver->Start() < 0) {
-        return -1;
-    }
-    return fChannel.Start();
-}
-
-int JackServer::Stop()
-{
-    jack_log("JackServer::Stop");
-    if (fFreewheel) {
-        return fThreadedFreewheelDriver->Stop();
-    } else {
-        return fAudioDriver->Stop();
-    }
-}
-
-bool JackServer::IsRunning()
-{
-    jack_log("JackServer::IsRunning");
-    assert(fAudioDriver);
-    return fAudioDriver->IsRunning();
-}
-
-int JackServer::SetBufferSize(jack_nframes_t buffer_size)
-{
-    jack_log("JackServer::SetBufferSize nframes = %ld", buffer_size);
-    jack_nframes_t current_buffer_size = fEngineControl->fBufferSize;
-
-    if (current_buffer_size == buffer_size) {
-        jack_log("SetBufferSize: requirement for new buffer size equals current value");
-        return 0;
-    }
-
-    if (fAudioDriver->IsFixedBufferSize()) {
-        jack_log("SetBufferSize: driver only supports a fixed buffer size");
-        return -1;
-    }
-
-    if (fAudioDriver->Stop() != 0) {
-        jack_error("Cannot stop audio driver");
-        return -1;
-    }
-
-    if (fAudioDriver->SetBufferSize(buffer_size) == 0) {
-        fFreewheelDriver->SetBufferSize(buffer_size);
-        fEngine->NotifyBufferSize(buffer_size);
-        return fAudioDriver->Start();
-    } else { // Failure: try to restore current value
-        jack_error("Cannot SetBufferSize for audio driver, restore current value %ld", current_buffer_size);
-        fAudioDriver->SetBufferSize(current_buffer_size);
-        fFreewheelDriver->SetBufferSize(current_buffer_size);
-        fAudioDriver->Start();
-        // SetBufferSize actually failed, so return an error...
-        return -1;
-    }
-}
-
-/*
-Freewheel mode is implemented by switching from the (audio + freewheel) driver to the freewheel driver only:
-
-    - "global" connection state is saved
-    - all audio driver ports are deconnected, thus there is no more dependancies with the audio driver
-    - the freewheel driver will be synchronized with the end of graph execution : all clients are connected to the freewheel driver
-    - the freewheel driver becomes the "master"
-
-Normal mode is restored with the connections state valid before freewheel mode was done. Thus one consider that
-no graph state change can be done during freewheel mode.
-*/
-
-int JackServer::SetFreewheel(bool onoff)
-{
-    jack_log("JackServer::SetFreewheel is = %ld want = %ld", fFreewheel, onoff);
-
-    if (fFreewheel) {
-        if (onoff) {
-            return -1;
-        } else {
-            fFreewheel = false;
-            fThreadedFreewheelDriver->Stop();
-            fGraphManager->Restore(&fConnectionState);   // Restore previous connection state
-            fEngine->NotifyFreewheel(onoff);
-            fFreewheelDriver->SetMaster(false);
-            fAudioDriver->SetMaster(true);
-            return fAudioDriver->Start();
-        }
-    } else {
-        if (onoff) {
-            fFreewheel = true;
-            fAudioDriver->Stop();
-            fGraphManager->Save(&fConnectionState);     // Save connection state
-            fGraphManager->DisconnectAllPorts(fAudioDriver->GetClientControl()->fRefNum);
-            fEngine->NotifyFreewheel(onoff);
-            fAudioDriver->SetMaster(false);
-            fFreewheelDriver->SetMaster(true);
-            return fThreadedFreewheelDriver->Start();
-        } else {
-            return -1;
-        }
-    }
-}
-
-// Coming from the RT thread
-void JackServer::Notify(int refnum, int notify, int value)
-{
-    switch (notify) {
-
-        case kGraphOrderCallback:
-            fEngine->NotifyGraphReorder();
-            break;
-
-        case kXRunCallback:
-            fEngine->NotifyXRun(refnum);
-            break;
-    }
-}
-
-void JackServer::ClientKill(int refnum)
-{
-    jack_log("JackServer::ClientKill ref = %ld", refnum);
-    if (fEngine->ClientDeactivate(refnum) < 0) {
-        jack_error("JackServer::ClientKill ref = %ld cannot be removed from the graph !!", refnum);
-    }
-    if (fEngine->ClientExternalClose(refnum) < 0) {
-        jack_error("JackServer::ClientKill ref = %ld cannot be closed", refnum);
-    }
-}
-
-//----------------------
-// Backend management
-//----------------------
-
-JackDriverInfo* JackServer::AddSlave(jack_driver_desc_t* driver_desc, JSList* driver_params)
-{
-    JackDriverInfo* info = new JackDriverInfo();
-    JackDriverClientInterface* slave = info->Open(driver_desc, fEngine, GetSynchroTable(), driver_params);
-    if (slave == NULL) {
-        delete info;
-        return NULL;
-    }
-    slave->Attach();
-    slave->SetMaster(false);
-    fAudioDriver->AddSlave(slave);
-    return info;
-}
-
-void JackServer::RemoveSlave(JackDriverInfo* info)
-{
-    JackDriverClientInterface* slave = info->GetBackend();
-    fAudioDriver->RemoveSlave(slave);
-    slave->Detach();
-    slave->Close();
-}
-
-int JackServer::SwitchMaster(jack_driver_desc_t* driver_desc, JSList* driver_params)
-{
-    /// Remove current master
-    fAudioDriver->Stop();
-    fAudioDriver->Detach();
-    fAudioDriver->Close();
-
-    // Open new master
-    JackDriverInfo* info = new JackDriverInfo();
-    JackDriverClientInterface* master = info->Open(driver_desc, fEngine, GetSynchroTable(), driver_params);
-
-    if (master == NULL) {
-        delete info;
-        return -1;
-    }
-
-    // Get slaves list
-    std::list<JackDriverInterface*> slave_list = fAudioDriver->GetSlaves();
-    std::list<JackDriverInterface*>::const_iterator it;
-
-    // Move slaves in new master
-    for (it = slave_list.begin(); it != slave_list.end(); it++) {
-        JackDriverInterface* slave = *it;
-        master->AddSlave(slave);
-    }
-
-    // Delete old master
-    delete fDriverInfo;
-
-    // Activate master
-    fAudioDriver = master;
-    fDriverInfo = info;
-    fAudioDriver->Attach();
-    fAudioDriver->SetMaster(true);
-    return fAudioDriver->Start();
-}
-
-//----------------------
-// Transport management
-//----------------------
-
-int JackServer::ReleaseTimebase(int refnum)
-{
-    return fEngineControl->fTransport.ResetTimebase(refnum);
-}
-
-int JackServer::SetTimebaseCallback(int refnum, int conditional)
-{
-    return fEngineControl->fTransport.SetTimebaseMaster(refnum, conditional);
-}
-
-JackLockedEngine* JackServer::GetEngine()
-{
-    return fEngine;
-}
-
-JackSynchro* JackServer::GetSynchroTable()
-{
-    return fSynchroTable;
-}
-
-JackEngineControl* JackServer::GetEngineControl()
-{
-    return fEngineControl;
-}
-
-JackGraphManager* JackServer::GetGraphManager()
-{
-    return fGraphManager;
-}
-
-
-} // end of namespace
-

=== removed file '.pc/no-selfconnect.patch/common/JackServer.h'
--- .pc/no-selfconnect.patch/common/JackServer.h	2011-03-31 13:54:50 +0000
+++ .pc/no-selfconnect.patch/common/JackServer.h	1970-01-01 00:00:00 +0000
@@ -1,106 +0,0 @@
-/*
-Copyright (C) 2001 Paul Davis
-Copyright (C) 2004-2008 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 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.
-
-*/
-
-#ifndef __JackServer__
-#define __JackServer__
-
-#include "JackCompilerDeps.h"
-#include "driver_interface.h"
-#include "JackDriverLoader.h"
-#include "JackConnectionManager.h"
-#include "JackGlobals.h"
-#include "JackPlatformPlug.h"
-#include "jslist.h"
-
-namespace Jack
-{
-
-class JackGraphManager;
-class JackDriverClientInterface;
-struct JackEngineControl;
-class JackLockedEngine;
-class JackLoadableInternalClient;
-
-/*!
-\brief The Jack server.
-*/
-
-class SERVER_EXPORT JackServer
-{
-
-    private:
-
-        JackDriverInfo* fDriverInfo;
-        JackDriverClientInterface* fAudioDriver;
-        JackDriverClientInterface* fFreewheelDriver;
-        JackDriverClientInterface* fThreadedFreewheelDriver;
-        JackLockedEngine* fEngine;
-        JackEngineControl* fEngineControl;
-        JackGraphManager* fGraphManager;
-        JackServerChannel fChannel;
-        JackConnectionManager fConnectionState;
-        JackSynchro fSynchroTable[CLIENT_NUM];
-        bool fFreewheel;
-
-        int InternalClientLoadAux(JackLoadableInternalClient* client, const char* so_name, const char* client_name, int options, int* int_ref, int uuid, int* status);
-
-    public:
-
-        JackServer(bool sync, bool temporary, int timeout, bool rt, int priority, int port_max, bool verbose, jack_timer_type_t clock, const char* server_name);
-        ~JackServer();
-
-        int Open(jack_driver_desc_t* driver_desc, JSList* driver_params);
-        int Close();
-
-        int Start();
-        int Stop();
-        bool IsRunning();
-
-        // RT thread
-        void Notify(int refnum, int notify, int value);
-
-        // Command thread : API
-        int SetBufferSize(jack_nframes_t buffer_size);
-        int SetFreewheel(bool onoff);
-        int InternalClientLoad1(const char* client_name, const char* so_name, const char* objet_data, int options, int* int_ref, int uuid, int* status);
-        int InternalClientLoad2(const char* client_name, const char* so_name, const JSList * parameters, int options, int* int_ref, int uuid, int* status);
-        void ClientKill(int refnum);
-
-        // Transport management
-        int ReleaseTimebase(int refnum);
-        int SetTimebaseCallback(int refnum, int conditional);
-
-        // Backend management
-        JackDriverInfo* AddSlave(jack_driver_desc_t* driver_desc, JSList* driver_params);
-        void RemoveSlave(JackDriverInfo* info);
-        int SwitchMaster(jack_driver_desc_t* driver_desc, JSList* driver_params);
-
-        // Object access
-        JackLockedEngine* GetEngine();
-        JackEngineControl* GetEngineControl();
-        JackSynchro* GetSynchroTable();
-        JackGraphManager* GetGraphManager();
-
-};
-
-} // end of namespace
-
-
-#endif

=== removed file '.pc/no-selfconnect.patch/common/JackServerGlobals.cpp'
--- .pc/no-selfconnect.patch/common/JackServerGlobals.cpp	2011-03-31 13:54:50 +0000
+++ .pc/no-selfconnect.patch/common/JackServerGlobals.cpp	1970-01-01 00:00:00 +0000
@@ -1,416 +0,0 @@
-/*
-Copyright (C) 2005 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 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.
-
-*/
-
-#include "JackServerGlobals.h"
-#include "JackLockedEngine.h"
-#include "JackTools.h"
-#include "shm.h"
-#include <getopt.h>
-#include <errno.h>
-
-static char* server_name = NULL;
-
-namespace Jack
-{
-
-JackServer* JackServerGlobals::fInstance;
-unsigned int JackServerGlobals::fUserCount;
-int JackServerGlobals::fRTNotificationSocket;
-std::map<std::string, JackDriverInfo*> JackServerGlobals::fSlavesList;
-std::map<std::string, int> JackServerGlobals::fInternalsList;
-
-bool (* JackServerGlobals::on_device_acquire)(const char * device_name) = NULL;
-void (* JackServerGlobals::on_device_release)(const char * device_name) = NULL;
-
-int JackServerGlobals::Start(const char* server_name,
-                             jack_driver_desc_t* driver_desc,
-                             JSList* driver_params,
-                             int sync,
-                             int temporary,
-                             int time_out_ms,
-                             int rt,
-                             int priority,
-                             int port_max,
-                             int verbose,
-                            jack_timer_type_t clock)
-{
-    jack_log("Jackdmp: sync = %ld timeout = %ld rt = %ld priority = %ld verbose = %ld ", sync, time_out_ms, rt, priority, verbose);
-    new JackServer(sync, temporary, time_out_ms, rt, priority, port_max, verbose, clock, server_name);  // Will setup fInstance and fUserCount globals
-    int res = fInstance->Open(driver_desc, driver_params);
-    return (res < 0) ? res : fInstance->Start();
-}
-
-void JackServerGlobals::Stop()
-{
-    jack_log("Jackdmp: server close");
-    fInstance->Stop();
-    fInstance->Close();
-}
-
-void JackServerGlobals::Delete()
-{
-    jack_log("Jackdmp: delete server");
-
-    // Slave drivers
-    std::map<std::string, JackDriverInfo*>::iterator it1;
-    for (it1 = fSlavesList.begin(); it1 != fSlavesList.end(); it1++) {
-        JackDriverInfo* info = (*it1).second;
-        if (info) {
-            fInstance->RemoveSlave((info));
-            delete (info);
-        }
-    }
-    fSlavesList.clear();
-
-    // Internal clients
-    std::map<std::string, int> ::iterator it2;
-    for (it2 = fInternalsList.begin(); it2 != fInternalsList.end(); it2++) {
-        int status;
-        int refnum = (*it2).second;
-        if (refnum > 0) {
-            // Client object is internally kept in JackEngine, and will be desallocated in InternalClientUnload
-            fInstance->GetEngine()->InternalClientUnload(refnum, &status);
-        }
-    }
-    fInternalsList.clear();
-
-    delete fInstance;
-    fInstance = NULL;
-}
-
-bool JackServerGlobals::Init()
-{
-    int realtime = 0;
-    int client_timeout = 0; /* msecs; if zero, use period size. */
-    int realtime_priority = 10;
-    int verbose_aux = 0;
-    int do_mlock = 1;
-    unsigned int port_max = 128;
-    int do_unlock = 0;
-    int temporary = 0;
-
-    int opt = 0;
-    int option_index = 0;
-    char *master_driver_name = NULL;
-    char **master_driver_args = NULL;
-    JSList* master_driver_params = NULL;
-    jack_driver_desc_t* driver_desc;
-    jack_timer_type_t clock_source = JACK_TIMER_SYSTEM_CLOCK;
-    int driver_nargs = 1;
-    JSList* drivers = NULL;
-    int loopback = 0;
-    int sync = 0;
-    int rc, i;
-    int ret;
-    int replace_registry = 0;
-
-    FILE* fp = 0;
-    char filename[255];
-    char buffer[255];
-    int argc = 0;
-    char* argv[32];
-
-    // First user starts the server
-    if (fUserCount++ == 0) {
-
-        jack_log("JackServerGlobals Init");
-
-        const char *options = "-d:X:I:P:uvshVrRL:STFl:t:mn:p:"
-    #ifdef __linux__
-            "c:"
-    #endif
-        ;
-
-    struct option long_options[] = {
-    #ifdef __linux__
-                                       { "clock-source", 1, 0, 'c' },
-    #endif
-                                       { "loopback-driver", 1, 0, 'L' },
-                                       { "audio-driver", 1, 0, 'd' },
-                                       { "midi-driver", 1, 0, 'X' },
-                                       { "internal-client", 1, 0, 'I' },
-                                       { "verbose", 0, 0, 'v' },
-                                       { "help", 0, 0, 'h' },
-                                       { "port-max", 1, 0, 'p' },
-                                       { "no-mlock", 0, 0, 'm' },
-                                       { "name", 1, 0, 'n' },
-                                       { "unlock", 0, 0, 'u' },
-                                       { "realtime", 0, 0, 'R' },
-                                       { "no-realtime", 0, 0, 'r' },
-                                       { "replace-registry", 0, &replace_registry, 0 },
-                                       { "loopback", 0, 0, 'L' },
-                                       { "realtime-priority", 1, 0, 'P' },
-                                       { "timeout", 1, 0, 't' },
-                                       { "temporary", 0, 0, 'T' },
-                                       { "version", 0, 0, 'V' },
-                                       { "silent", 0, 0, 's' },
-                                       { "sync", 0, 0, 'S' },
-                                       { 0, 0, 0, 0 }
-                                   };
-
-        snprintf(filename, 255, "%s/.jackdrc", getenv("HOME"));
-        fp = fopen(filename, "r");
-
-        if (!fp) {
-            fp = fopen("/etc/jackdrc", "r");
-        }
-        // if still not found, check old config name for backwards compatability
-        if (!fp) {
-            fp = fopen("/etc/jackd.conf", "r");
-        }
-
-        argc = 0;
-        if (fp) {
-            ret = fscanf(fp, "%s", buffer);
-            while (ret != 0 && ret != EOF) {
-                argv[argc] = (char*)malloc(64);
-                strcpy(argv[argc], buffer);
-                ret = fscanf(fp, "%s", buffer);
-                argc++;
-            }
-            fclose(fp);
-        }
-
-        /*
-        For testing
-        int argc = 15;
-        char* argv[] = {"jackdmp", "-R", "-v", "-d", "coreaudio", "-p", "512", "-d", "~:Aggregate:0", "-r", "48000", "-i", "2", "-o", "2" };
-        */
-
-        opterr = 0;
-        optind = 1; // Important : to reset argv parsing
-
-        while (!master_driver_name &&
-                (opt = getopt_long(argc, argv, options, long_options, &option_index)) != EOF) {
-
-            switch (opt) {
-
-                case 'c':
-                    if (tolower (optarg[0]) == 'h') {
-                        clock_source = JACK_TIMER_HPET;
-                    } else if (tolower (optarg[0]) == 'c') {
-                        clock_source = JACK_TIMER_CYCLE_COUNTER;
-                    } else if (tolower (optarg[0]) == 's') {
-                        clock_source = JACK_TIMER_SYSTEM_CLOCK;
-                    } else {
-                        jack_error("unknown option character %c", optopt);
-                    }
-                    break;
-
-                case 'd':
-                    master_driver_name = optarg;
-                    break;
-
-                case 'L':
-                    loopback = atoi(optarg);
-                    break;
-
-                 case 'X':
-                    fSlavesList[optarg] = NULL;
-                    break;
-
-                case 'I':
-                    fInternalsList[optarg] = -1;
-                    break;
-
-                case 'p':
-                    port_max = (unsigned int)atol(optarg);
-                    break;
-
-                case 'm':
-                    do_mlock = 0;
-                    break;
-
-                case 'u':
-                    do_unlock = 1;
-                    break;
-
-                case 'v':
-                    verbose_aux = 1;
-                    break;
-
-                case 'S':
-                    sync = 1;
-                    break;
-
-                case 'n':
-                    server_name = optarg;
-                    break;
-
-                case 'P':
-                    realtime_priority = atoi(optarg);
-                    break;
-
-                case 'r':
-                    realtime = 0;
-                    break;
-
-                case 'R':
-                    realtime = 1;
-                    break;
-
-                case 'T':
-                    temporary = 1;
-                    break;
-
-                case 't':
-                    client_timeout = atoi(optarg);
-                    break;
-
-                default:
-                    jack_error("unknown option character %c", optopt);
-                    break;
-            }
-        }
-
-        drivers = jack_drivers_load(drivers);
-        if (!drivers) {
-            jack_error("jackdmp: no drivers found; exiting");
-            goto error;
-        }
-
-        driver_desc = jack_find_driver_descriptor(drivers, master_driver_name);
-        if (!driver_desc) {
-            jack_error("jackdmp: unknown master driver '%s'", master_driver_name);
-            goto error;
-        }
-
-        if (optind < argc) {
-            driver_nargs = 1 + argc - optind;
-        } else {
-            driver_nargs = 1;
-        }
-
-        if (driver_nargs == 0) {
-            jack_error("No driver specified ... hmm. JACK won't do"
-                       " anything when run like this.");
-            goto error;
-        }
-
-        master_driver_args = (char**)malloc(sizeof(char*) * driver_nargs);
-        master_driver_args[0] = master_driver_name;
-
-        for (i = 1; i < driver_nargs; i++) {
-            master_driver_args[i] = argv[optind++];
-        }
-
-        if (jack_parse_driver_params(driver_desc, driver_nargs, master_driver_args, &master_driver_params)) {
-            goto error;
-        }
-
-#ifndef WIN32
-        if (server_name == NULL)
-            server_name = (char*)JackTools::DefaultServerName();
-#endif
-
-        rc = jack_register_server(server_name, false);
-        switch (rc) {
-            case EEXIST:
-                jack_error("`%s' server already active", server_name);
-                goto error;
-            case ENOSPC:
-                jack_error("too many servers already active");
-                goto error;
-            case ENOMEM:
-                jack_error("no access to shm registry");
-                goto error;
-            default:
-                jack_info("server `%s' registered", server_name);
-        }
-
-        /* clean up shared memory and files from any previous instance of this server name */
-        jack_cleanup_shm();
-        JackTools::CleanupFiles(server_name);
-
-        if (!realtime && client_timeout == 0)
-            client_timeout = 500; /* 0.5 sec; usable when non realtime. */
-
-        for (i = 0; i < argc; i++) {
-            free(argv[i]);
-        }
-
-        int res = Start(server_name, driver_desc, master_driver_params, sync, temporary, client_timeout, realtime, realtime_priority, port_max, verbose_aux, clock_source);
-        if (res < 0) {
-            jack_error("Cannot start server... exit");
-            Delete();
-            jack_cleanup_shm();
-            JackTools::CleanupFiles(server_name);
-            jack_unregister_server(server_name);
-            goto error;
-        }
-
-        // Slave drivers
-        std::map<std::string, JackDriverInfo*>::iterator it1;
-        for (it1 = fSlavesList.begin(); it1 != fSlavesList.end(); it1++) {
-            const char* name = ((*it1).first).c_str();
-            driver_desc = jack_find_driver_descriptor(drivers, name);
-            if (!driver_desc) {
-                jack_error("jackdmp: unknown slave driver '%s'", name);
-            } else {
-                (*it1).second = fInstance->AddSlave(driver_desc, NULL);
-            }
-        }
-
-        // Loopback driver
-        if (loopback > 0) {
-            driver_desc = jack_find_driver_descriptor(drivers, "loopback");
-            if (!driver_desc) {
-                jack_error("jackdmp: unknown driver '%s'", "loopback");
-            } else {
-                fSlavesList["loopback"] = fInstance->AddSlave(driver_desc, NULL);
-            }
-        }
-
-        // Internal clients
-        std::map<std::string, int>::iterator it2;
-        for (it2 = fInternalsList.begin(); it2 != fInternalsList.end(); it2++) {
-            int status, refnum;
-            const char* name = ((*it2).first).c_str();
-            fInstance->InternalClientLoad2(name, name, NULL, JackNullOption, &refnum, -1, &status);
-            (*it2).second = refnum;
-        }
-    }
-
-    if (master_driver_params)
-        jack_free_driver_params(master_driver_params);
-    return true;
-
-error:
-    jack_log("JackServerGlobals Init error");
-    if (master_driver_params)
-        jack_free_driver_params(master_driver_params);
-    Destroy();
-    return false;
-}
-
-void JackServerGlobals::Destroy()
-{
-    if (--fUserCount == 0) {
-        jack_log("JackServerGlobals Destroy");
-        Stop();
-        Delete();
-        jack_cleanup_shm();
-        JackTools::CleanupFiles(server_name);
-        jack_unregister_server(server_name);
-    }
-}
-
-} // end of namespace
-
-

=== removed file '.pc/no-selfconnect.patch/common/JackServerGlobals.h'
--- .pc/no-selfconnect.patch/common/JackServerGlobals.h	2011-03-31 13:54:50 +0000
+++ .pc/no-selfconnect.patch/common/JackServerGlobals.h	1970-01-01 00:00:00 +0000
@@ -1,72 +0,0 @@
-/*
-Copyright (C) 2005 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 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.
-
-*/
-
-#ifndef __JackServerGlobals__
-#define __JackServerGlobals__
-
-#include "driver_interface.h"
-#include "JackDriverLoader.h"
-#include "JackCompilerDeps.h"
-#include "JackServer.h"
-#include <map>
-
-namespace Jack
-{
-
-class JackClient;
-
-/*!
-\brief Global server static structure: singleton kind of pattern.
-*/
-
-struct SERVER_EXPORT JackServerGlobals
-{
-    static JackServer* fInstance;
-    static unsigned int fUserCount;
-    static int fRTNotificationSocket;  // For debugging purpose
-    static std::map<std::string, JackDriverInfo*> fSlavesList;
-    static std::map<std::string, int> fInternalsList;
-
-    static bool (* on_device_acquire)(const char* device_name);
-    static void (* on_device_release)(const char* device_name);
-
-    JackServerGlobals();
-    ~JackServerGlobals();
-
-    static bool Init();
-    static void Destroy();
-    static int Start(const char* server_name,
-                     jack_driver_desc_t* driver_desc,
-                     JSList* driver_params,
-                     int sync,
-                     int temporary,
-                     int time_out_ms,
-                     int rt,
-                     int priority,
-                     int port_max,
-                     int verbose,
-                    jack_timer_type_t clock);
-    static void Stop();
-    static void Delete();
-};
-
-} // end of namespace
-
-#endif
-

=== removed file '.pc/no-selfconnect.patch/common/JackTypes.h'
--- .pc/no-selfconnect.patch/common/JackTypes.h	2011-03-31 13:54:50 +0000
+++ .pc/no-selfconnect.patch/common/JackTypes.h	1970-01-01 00:00:00 +0000
@@ -1,58 +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 Lesser General Public License as published by
-  the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-  $Id: JackTypes.h,v 1.2.2.1 2006/06/20 14:44:00 letz Exp $
-*/
-
-#ifndef __JackTypes__
-#define __JackTypes__
-
-#include "JackCompilerDeps.h"
-
-typedef unsigned short UInt16;
-#if __LP64__
-typedef unsigned int UInt32;
-typedef signed int   SInt32;
-#else
-typedef unsigned long UInt32;
-typedef signed long   SInt32;
-#endif
-
-#include "JackTypes_os.h"
-
-/**
- * Type used to represent the value of free running
- * monotonic clock with units of microseconds.
- */
-typedef uint64_t jack_time_t;
-
-typedef uint16_t jack_int_t;  // Internal type for ports and refnum
-
-typedef enum {
-	JACK_TIMER_SYSTEM_CLOCK,
-	JACK_TIMER_CYCLE_COUNTER,
-	JACK_TIMER_HPET,
-} jack_timer_type_t;
-
-typedef enum {
-    NotTriggered,
-    Triggered,
-    Running,
-    Finished,
-} jack_client_state_t;
-
-#endif

=== removed file '.pc/no-selfconnect.patch/common/Jackdmp.cpp'
--- .pc/no-selfconnect.patch/common/Jackdmp.cpp	2011-03-31 13:54:50 +0000
+++ .pc/no-selfconnect.patch/common/Jackdmp.cpp	1970-01-01 00:00:00 +0000
@@ -1,534 +0,0 @@
-/*
-Copyright (C) 2001 Paul Davis
-Copyright (C) 2004-2008 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 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.
-
-*/
-
-#include <iostream>
-#include <assert.h>
-#include <cassert>
-#include <csignal>
-#include <sys/types.h>
-#include <getopt.h>
-#include <cstring>
-#include <cstdio>
-#include <list>
-
-#include "types.h"
-#include "jack.h"
-#include "JackConstants.h"
-#include "JackDriverLoader.h"
-
-#if defined(JACK_DBUS) && defined(__linux__)
-#include <dbus/dbus.h>
-#include "audio_reserve.h"
-#endif
-
-/*
-This is a simple port of the old jackdmp.cpp file to use the new Jack 2.0 control API. Available options for the server
-are "hard-coded" in the source. A much better approach would be to use the control API to:
-- dynamically retrieve available server parameters and then prepare to parse them
-- get available drivers and their possible parameters, then prepare to parse them.
-*/
-
-#ifdef __APPLE__
-#include <CoreFoundation/CFNotificationCenter.h>
-#include <CoreFoundation/CoreFoundation.h>
-
-static void notify_server_start(const char* server_name)
-{
-    // Send notification to be used in the JackRouter plugin
-    CFStringRef ref = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
-    CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
-            CFSTR("com.grame.jackserver.start"),
-            ref,
-            NULL,
-            kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
-    CFRelease(ref);
-}
-
-static void notify_server_stop(const char* server_name)
-{
-    // Send notification to be used in the JackRouter plugin
-    CFStringRef ref1 = CFStringCreateWithCString(NULL, server_name, kCFStringEncodingMacRoman);
-    CFNotificationCenterPostNotificationWithOptions(CFNotificationCenterGetDistributedCenter(),
-            CFSTR("com.grame.jackserver.stop"),
-            ref1,
-            NULL,
-            kCFNotificationDeliverImmediately | kCFNotificationPostToAllSessions);
-    CFRelease(ref1);
-}
-
-#else
-
-static void notify_server_start(const char* server_name)
-{}
-static void notify_server_stop(const char* server_name)
-{}
-
-#endif
-
-static void copyright(FILE* file)
-{
-    fprintf(file, "jackdmp " VERSION "\n"
-            "Copyright 2001-2005 Paul Davis and others.\n"
-            "Copyright 2004-2011 Grame.\n"
-            "jackdmp comes with ABSOLUTELY NO WARRANTY\n"
-            "This is free software, and you are welcome to redistribute it\n"
-            "under certain conditions; see the file COPYING for details\n");
-}
-
-static void usage(FILE* file)
-{
-    fprintf(file, "\n"
-            "usage: jackdmp [ --no-realtime OR -r ]\n"
-            "               [ --realtime OR -R [ --realtime-priority OR -P priority ] ]\n"
-            "      (the two previous arguments are mutually exclusive. The default is --realtime)\n"
-            "               [ --name OR -n server-name ]\n"
-            "               [ --timeout OR -t client-timeout-in-msecs ]\n"
-            "               [ --loopback OR -L loopback-port-number ]\n"
-            "               [ --port-max OR -p maximum-number-of-ports]\n"
-            "               [ --slave-backend OR -X slave-backend-name ]\n"
-            "               [ --internal-client OR -I internal-client-name ]\n"
-            "               [ --verbose OR -v ]\n"
-#ifdef __linux__
-            "               [ --clocksource OR -c [ c(ycle) | h(pet) | s(ystem) ]\n"
-#endif
-            "               [ --replace-registry ]\n"
-            "               [ --silent OR -s ]\n"
-            "               [ --sync OR -S ]\n"
-            "               [ --temporary OR -T ]\n"
-            "               [ --version OR -V ]\n"
-            "         -d master-backend-name [ ... master-backend args ... ]\n"
-#ifdef __APPLE__
-            "               Available master backends may include: coreaudio, dummy or net.\n\n"
-#endif
-#ifdef WIN32
-            "               Available master backends may include: portaudio, dummy or net.\n\n"
-#endif
-#ifdef __linux__
-            "               Available master backends may include: alsa, dummy, freebob, firewire or net\n\n"
-#endif
-#if defined(__sun__) || defined(sun)
-            "               Available master backends may include: boomer, oss, dummy or net.\n\n"
-#endif
-            "       jackdmp -d master-backend-name --help\n"
-            "             to display options for each master backend\n\n");
-}
-
-// To put in the control.h interface??
-static jackctl_driver_t *
-jackctl_server_get_driver(
-    jackctl_server_t *server,
-    const char *driver_name)
-{
-    const JSList * node_ptr;
-
-    node_ptr = jackctl_server_get_drivers_list(server);
-
-    while (node_ptr)
-    {
-        if (strcmp(jackctl_driver_get_name((jackctl_driver_t *)node_ptr->data), driver_name) == 0)
-        {
-            return (jackctl_driver_t *)node_ptr->data;
-        }
-
-        node_ptr = jack_slist_next(node_ptr);
-    }
-
-    return NULL;
-}
-
-static jackctl_internal_t * jackctl_server_get_internal(jackctl_server_t *server, const char *internal_name)
-{
-    const JSList * node_ptr = jackctl_server_get_internals_list(server);
-
-    while (node_ptr) {
-        if (strcmp(jackctl_internal_get_name((jackctl_internal_t *)node_ptr->data), internal_name) == 0) {
-            return (jackctl_internal_t *)node_ptr->data;
-        }
-        node_ptr = jack_slist_next(node_ptr);
-    }
-
-    return NULL;
-}
-
-static jackctl_parameter_t *
-jackctl_get_parameter(
-    const JSList * parameters_list,
-    const char * parameter_name)
-{
-    while (parameters_list)
-    {
-        if (strcmp(jackctl_parameter_get_name((jackctl_parameter_t *)parameters_list->data), parameter_name) == 0)
-        {
-            return (jackctl_parameter_t *)parameters_list->data;
-        }
-
-        parameters_list = jack_slist_next(parameters_list);
-    }
-
-    return NULL;
-}
-
-int main(int argc, char* argv[])
-{
-    jackctl_server_t * server_ctl;
-    const JSList * server_parameters;
-    const char* server_name = "default";
-    jackctl_driver_t * master_driver_ctl;
-    jackctl_driver_t * loopback_driver_ctl;
-    int replace_registry = 0;
-
-    const char *options = "-d:X:I:P:uvshVrRL:STFl:t:mn:p:"
-#ifdef __linux__
-        "c:"
-#endif
-        ;
-
-    struct option long_options[] = {
-#ifdef __linux__
-                                       { "clock-source", 1, 0, 'c' },
-#endif
-                                       { "loopback-driver", 1, 0, 'L' },
-                                       { "audio-driver", 1, 0, 'd' },
-                                       { "midi-driver", 1, 0, 'X' },
-                                       { "internal-client", 1, 0, 'I' },
-                                       { "verbose", 0, 0, 'v' },
-                                       { "help", 0, 0, 'h' },
-                                       { "port-max", 1, 0, 'p' },
-                                       { "no-mlock", 0, 0, 'm' },
-                                       { "name", 1, 0, 'n' },
-                                       { "unlock", 0, 0, 'u' },
-                                       { "realtime", 0, 0, 'R' },
-                                       { "no-realtime", 0, 0, 'r' },
-                                       { "replace-registry", 0, &replace_registry, 0 },
-                                       { "loopback", 0, 0, 'L' },
-                                       { "realtime-priority", 1, 0, 'P' },
-                                       { "timeout", 1, 0, 't' },
-                                       { "temporary", 0, 0, 'T' },
-                                       { "version", 0, 0, 'V' },
-                                       { "silent", 0, 0, 's' },
-                                       { "sync", 0, 0, 'S' },
-                                       { 0, 0, 0, 0 }
-                                   };
-
-    int i,opt = 0;
-    int option_index = 0;
-    char* master_driver_name = NULL;
-    char** master_driver_args = NULL;
-    int master_driver_nargs = 1;
-    int do_mlock = 1;
-    int do_unlock = 0;
-    int loopback = 0;
-    bool show_version = false;
-    sigset_t signals;
-    jackctl_parameter_t* param;
-    union jackctl_parameter_value value;
-
-    std::list<char*> internals_list;
-    std::list<char*> slaves_list;
-    std::list<char*>::iterator it;
-
-    // Assume that we fail.
-    int return_value = -1;
-    bool notify_sent = false;
-
-    copyright(stdout);
-#if defined(JACK_DBUS) && defined(__linux__)
-    server_ctl = jackctl_server_create(audio_acquire, audio_release);
-#else
-    server_ctl = jackctl_server_create(NULL, NULL);
-#endif
-    if (server_ctl == NULL) {
-        fprintf(stderr, "Failed to create server object\n");
-        return -1;
-    }
-
-    server_parameters = jackctl_server_get_parameters(server_ctl);
-
-    // Default setting
-    param = jackctl_get_parameter(server_parameters, "realtime");
-    if (param != NULL) {
-        value.b = true;
-        jackctl_parameter_set_value(param, &value);
-    }
-
-    opterr = 0;
-    while (!master_driver_name &&
-            (opt = getopt_long(argc, argv, options,
-                               long_options, &option_index)) != EOF) {
-        switch (opt) {
-
-        #ifdef __linux__
-            case 'c':
-                param = jackctl_get_parameter(server_parameters, "clock-source");
-                if (param != NULL) {
-                    if (tolower (optarg[0]) == 'h') {
-                        value.ui = JACK_TIMER_HPET;
-                        jackctl_parameter_set_value(param, &value);
-                    } else if (tolower (optarg[0]) == 'c') {
-                        value.ui = JACK_TIMER_CYCLE_COUNTER;
-                        jackctl_parameter_set_value(param, &value);
-                    } else if (tolower (optarg[0]) == 's') {
-                        value.ui = JACK_TIMER_SYSTEM_CLOCK;
-                        jackctl_parameter_set_value(param, &value);
-                    } else {
-                        usage(stdout);
-                        goto destroy_server;
-                    }
-                }
-                break;
-        #endif
-
-            case 'd':
-                master_driver_name = optarg;
-                break;
-
-            case 'L':
-                loopback = atoi(optarg);
-                break;
-
-            case 'X':
-                slaves_list.push_back(optarg);
-                break;
-
-            case 'I':
-                internals_list.push_back(optarg);
-                break;
-
-            case 'p':
-                param = jackctl_get_parameter(server_parameters, "port-max");
-                if (param != NULL) {
-                    value.ui = atoi(optarg);
-                    jackctl_parameter_set_value(param, &value);
-                }
-                break;
-
-            case 'm':
-                do_mlock = 0;
-                break;
-
-            case 'u':
-                do_unlock = 1;
-                break;
-
-            case 'v':
-                param = jackctl_get_parameter(server_parameters, "verbose");
-                if (param != NULL) {
-                    value.b = true;
-                    jackctl_parameter_set_value(param, &value);
-                }
-                break;
-
-            case 's':
-                jack_set_error_function(silent_jack_error_callback);
-                break;
-
-            case 'S':
-                param = jackctl_get_parameter(server_parameters, "sync");
-                if (param != NULL) {
-                    value.b = true;
-                    jackctl_parameter_set_value(param, &value);
-                }
-                break;
-
-            case 'n':
-                server_name = optarg;
-                param = jackctl_get_parameter(server_parameters, "name");
-                if (param != NULL) {
-                    strncpy(value.str, optarg, JACK_PARAM_STRING_MAX);
-                    jackctl_parameter_set_value(param, &value);
-                }
-                break;
-
-            case 'P':
-                param = jackctl_get_parameter(server_parameters, "realtime-priority");
-                if (param != NULL) {
-                    value.i = atoi(optarg);
-                    jackctl_parameter_set_value(param, &value);
-                }
-                break;
-
-            case 'r':
-                param = jackctl_get_parameter(server_parameters, "realtime");
-                if (param != NULL) {
-                    value.b = false;
-                    jackctl_parameter_set_value(param, &value);
-                }
-                break;
-
-            case 'R':
-                param = jackctl_get_parameter(server_parameters, "realtime");
-                if (param != NULL) {
-                    value.b = true;
-                    jackctl_parameter_set_value(param, &value);
-                }
-                break;
-
-            case 'T':
-                param = jackctl_get_parameter(server_parameters, "temporary");
-                if (param != NULL) {
-                    value.b = true;
-                    jackctl_parameter_set_value(param, &value);
-                }
-                break;
-
-            case 't':
-                param = jackctl_get_parameter(server_parameters, "client-timeout");
-                if (param != NULL) {
-                    value.i = atoi(optarg);
-                    jackctl_parameter_set_value(param, &value);
-                }
-                break;
-
-            case 'V':
-                show_version = true;
-                break;
-
-            default:
-                fprintf(stderr, "unknown option character %c\n", optopt);
-                /*fallthru*/
-
-            case 'h':
-                usage(stdout);
-                goto destroy_server;
-        }
-    }
-
-    // Long option with no letter so treated separately
-    param = jackctl_get_parameter(server_parameters, "replace-registry");
-    if (param != NULL) {
-        value.b = replace_registry;
-        jackctl_parameter_set_value(param, &value);
-    }
-
-    if (show_version) {
-        printf( "jackdmp version " VERSION
-                " tmpdir " jack_server_dir
-                " protocol %d"
-                "\n", JACK_PROTOCOL_VERSION);
-        return -1;
-    }
-
-    if (!master_driver_name) {
-        usage(stderr);
-        goto destroy_server;
-    }
-
-    // Master driver
-    master_driver_ctl = jackctl_server_get_driver(server_ctl, master_driver_name);
-    if (master_driver_ctl == NULL) {
-        fprintf(stderr, "Unknown driver \"%s\"\n", master_driver_name);
-        goto destroy_server;
-    }
-
-    if (optind < argc) {
-        master_driver_nargs = 1 + argc - optind;
-    } else {
-        master_driver_nargs = 1;
-    }
-
-    if (master_driver_nargs == 0) {
-        fprintf(stderr, "No driver specified ... hmm. JACK won't do"
-                " anything when run like this.\n");
-        goto destroy_server;
-    }
-
-    master_driver_args = (char **) malloc(sizeof(char *) * master_driver_nargs);
-    master_driver_args[0] = master_driver_name;
-
-    for (i = 1; i < master_driver_nargs; i++) {
-        master_driver_args[i] = argv[optind++];
-    }
-
-    if (jackctl_parse_driver_params(master_driver_ctl, master_driver_nargs, master_driver_args)) {
-        goto destroy_server;
-    }
-
-    // Setup signals
-    signals = jackctl_setup_signals(0);
-
-    // Open server
-    if (! jackctl_server_open(server_ctl, master_driver_ctl)) {
-        fprintf(stderr, "Failed to open server\n");
-        goto destroy_server;
-    }
-
-    // Slave drivers
-    for (it = slaves_list.begin(); it != slaves_list.end(); it++) {
-        jackctl_driver_t * slave_driver_ctl = jackctl_server_get_driver(server_ctl, *it);
-        if (slave_driver_ctl == NULL) {
-            fprintf(stderr, "Unknown driver \"%s\"\n", *it);
-            goto close_server;
-        }
-        jackctl_server_add_slave(server_ctl, slave_driver_ctl);
-    }
-
-    // Loopback driver
-    if (loopback > 0) {
-        loopback_driver_ctl = jackctl_server_get_driver(server_ctl, "loopback");
-
-        // XX: What if this fails?
-        if (loopback_driver_ctl != NULL) {
-            const JSList * loopback_parameters = jackctl_driver_get_parameters(loopback_driver_ctl);
-            param = jackctl_get_parameter(loopback_parameters, "channels");
-            if (param != NULL) {
-                value.ui = loopback;
-                jackctl_parameter_set_value(param, &value);
-            }
-            jackctl_server_add_slave(server_ctl, loopback_driver_ctl);
-        }
-
-    }
-
-    // Start the server
-    if (!jackctl_server_start(server_ctl)) {
-        fprintf(stderr, "Failed to start server\n");
-        goto close_server;
-    }
-
-    // Internal clients
-    for (it = internals_list.begin(); it != internals_list.end(); it++) {
-        jackctl_internal_t * internal_driver_ctl = jackctl_server_get_internal(server_ctl, *it);
-        if (internal_driver_ctl == NULL) {
-            fprintf(stderr, "Unknown internal \"%s\"\n", *it);
-            goto stop_server;
-        }
-        jackctl_server_load_internal(server_ctl, internal_driver_ctl);
-    }
-
-    notify_server_start(server_name);
-    notify_sent = true;
-    return_value = 0;
-
-    // Waits for signal
-    jackctl_wait_signals(signals);
-
- stop_server:
-    if (! jackctl_server_stop(server_ctl)) {
-        fprintf(stderr, "Cannot stop server...\n");
-    }
-    if (notify_sent) {
-        notify_server_stop(server_name);
-    }
- close_server:
-    jackctl_server_close(server_ctl);
- destroy_server:
-    jackctl_server_destroy(server_ctl);
-    return return_value;
-}

=== removed directory '.waf-1.5.0-8e39a4c1c16303c1e8f010bf330305f6'
=== removed directory '.waf-1.5.0-8e39a4c1c16303c1e8f010bf330305f6/wafadmin'
=== removed file '.waf-1.5.0-8e39a4c1c16303c1e8f010bf330305f6/wafadmin/Build.py'
--- .waf-1.5.0-8e39a4c1c16303c1e8f010bf330305f6/wafadmin/Build.py	2010-06-19 18:54:29 +0000
+++ .waf-1.5.0-8e39a4c1c16303c1e8f010bf330305f6/wafadmin/Build.py	1970-01-01 00:00:00 +0000
@@ -1,525 +0,0 @@
-#! /usr/bin/env python
-# encoding: utf-8
-import sys
-if sys.hexversion < 0x020400f0: from sets import Set as set
-import os,sys,cPickle,types,imp,errno,re,glob,gc,time,shutil
-import Runner,TaskGen,Node,Scripting,Utils,Environment,Task,Logs,Options
-from Logs import debug,error,info
-from Constants import*
-SAVED_ATTRS='root srcnode bldnode node_sigs node_deps raw_deps task_sigs id_nodes'.split()
-g_modcache={}
-bld=None
-class BuildError(Utils.WafError):
-	def __init__(self,b=None,t=[]):
-		self.bld=b
-		self.tasks=t
-		self.ret=1
-		Utils.WafError.__init__(self,self.format_error())
-	def format_error(self):
-		lst=['Build failed']
-		for tsk in self.tasks:
-			txt=tsk.format_error()
-			if txt:lst.append(txt)
-		return'\n'.join(lst)
-class BuildContext(object):
-	def __init__(self):
-		global bld
-		bld=self
-		self.task_manager=Task.TaskManager()