Adding optional JACK support for mumble, this also disables ALSA and OSS because this combination is reported to be unstable

svn path=/nixpkgs/trunk/; revision=27206

2 files changed, 469 insertions, 3 deletions

diff --git a/pkgs/applications/networking/mumble/default.nix b/pkgs/applications/networking/mumble/default.nix
index 716ef85881c..5c9e215f876 100644
--- a/pkgs/applications/networking/mumble/default.nix
+++ b/pkgs/applications/networking/mumble/default.nix
@@ -1,5 +1,8 @@
 { stdenv, fetchurl, qt4, libvorbis, boost, speechd, protobuf, libsndfile,
- avahi, dbus, libcap }:
+ avahi, dbus, libcap,
+jackSupport ? false, 
+jackaudio ? null }:
+
 
 stdenv.mkDerivation rec {
   name = "mumble-" + version;
@@ -13,15 +16,21 @@ stdenv.mkDerivation rec {
   patchPhase = ''
     sed -e s/qt_ja_JP.qm// -i src/mumble/mumble.pro src/mumble11x/mumble11x.pro
     sed -e /qt_ja_JP.qm/d -i src/mumble/mumble_qt.qrc src/mumble11x/mumble_qt.qrc
+    patch -p1 < ${ ./mumble-jack-support.patch }
   '';
 
   configurePhase = ''
     qmake CONFIG+=no-g15 CONFIG+=no-update \
-      CONFIG+=no-embed-qt-translations CONFIG+=no-ice
+      CONFIG+=no-embed-qt-translations CONFIG+=no-ice \
+  '' 
+  + stdenv.lib.optionalString jackSupport ''
+    CONFIG+=no-oss CONFIG+=no-alsa CONFIG+=jackaudio
   '';
 
+
   buildInputs = [ qt4 libvorbis boost speechd protobuf libsndfile avahi dbus
-    libcap ];
+    libcap ]
+    ++ (stdenv.lib.optional jackSupport jackaudio);
 
   installPhase = ''
     ensureDir $out
diff --git a/pkgs/applications/networking/mumble/mumble-jack-support.patch b/pkgs/applications/networking/mumble/mumble-jack-support.patch
new file mode 100644
index 00000000000..7c18a33193d
--- /dev/null
+++ b/pkgs/applications/networking/mumble/mumble-jack-support.patch
@@ -0,0 +1,457 @@
+The patch was created by Filipe Coelho (falkTX) of the KXStudio
+project. http://kxstudio.sourceforge.net
+
+diff -U 3 -H -d -r -N -- mumble-1.2.2.orig/src/mumble/JackAudio.cpp mumble-1.2.2/src/mumble/JackAudio.cpp
+--- mumble-1.2.2.orig/src/mumble/JackAudio.cpp	1970-01-01 01:00:00.000000000 +0100
++++ mumble-1.2.2/src/mumble/JackAudio.cpp	2011-01-26 06:02:00.000000000 +0000
+@@ -0,0 +1,314 @@
++/* Copyright (C) 2011, Benjamin Jemlich <pcgod@users.sourceforge.net>
++   Copyright (C) 2011, Filipe Coelho <falktx@gmail.com>
++
++   All rights reserved.
++
++   Redistribution and use in source and binary forms, with or without
++   modification, are permitted provided that the following conditions
++   are met:
++
++   - Redistributions of source code must retain the above copyright notice,
++     this list of conditions and the following disclaimer.
++   - Redistributions in binary form must reproduce the above copyright notice,
++     this list of conditions and the following disclaimer in the documentation
++     and/or other materials provided with the distribution.
++   - Neither the name of the Mumble Developers nor the names of its
++     contributors may be used to endorse or promote products derived from this
++     software without specific prior written permission.
++
++   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
++   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
++   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
++   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
++   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
++   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
++   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
++   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
++   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
++   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
++   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++*/
++
++#include "JackAudio.h"
++#include "User.h"
++#include "Global.h"
++#include "MainWindow.h"
++#include "Timer.h"
++
++#include <cstring>
++
++static JackAudioSystem *jasys = NULL;
++
++class JackAudioInputRegistrar : public AudioInputRegistrar {
++        public:
++                JackAudioInputRegistrar();
++                virtual AudioInput *create();
++                virtual const QList<audioDevice> getDeviceChoices();
++                virtual void setDeviceChoice(const QVariant &, Settings &);
++                virtual bool canEcho(const QString &) const;
++};
++
++class JackAudioOutputRegistrar : public AudioOutputRegistrar {
++        public:
++                JackAudioOutputRegistrar();
++                virtual AudioOutput *create();
++                virtual const QList<audioDevice> getDeviceChoices();
++                virtual void setDeviceChoice(const QVariant &, Settings &);
++};
++
++class JackAudioInit : public DeferInit {
++        public:
++                JackAudioInputRegistrar *airJackAudio;
++                JackAudioOutputRegistrar *aorJackAudio;
++                void initialize() {
++                        jasys = new JackAudioSystem();
++                        jasys->init_jack();
++                        jasys->qmWait.lock();
++                        jasys->qwcWait.wait(&jasys->qmWait, 1000);
++                        jasys->qmWait.unlock();
++                        if (jasys->bJackIsGood) {
++                                airJackAudio = new JackAudioInputRegistrar();
++                                aorJackAudio = new JackAudioOutputRegistrar();
++                        } else {
++                                airJackAudio = NULL;
++                                aorJackAudio = NULL;
++                                delete jasys;
++                                jasys = NULL;
++                        }
++                };
++                void destroy() {
++                        if (airJackAudio)
++                                delete airJackAudio;
++                        if (aorJackAudio)
++                                delete aorJackAudio;
++                        if (jasys) {
++                                jasys->close_jack();
++                                delete jasys;
++                                jasys = NULL;
++                        }
++                };
++};
++
++static JackAudioInit jackinit; //unused
++
++JackAudioSystem::JackAudioSystem() {
++        bJackIsGood = false;
++        iSampleRate = 0;
++}
++
++JackAudioSystem::~JackAudioSystem() {
++}
++
++void JackAudioSystem::init_jack()
++{
++        client = jack_client_open("mumble", JackNullOption, 0);
++
++        if (client) {
++                in_port = jack_port_register(client, "input", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
++                out_port = jack_port_register(client, "output", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
++                jack_set_process_callback(client, process_callback, this);
++                jack_set_sample_rate_callback(client, srate_callback, this);
++                jack_on_shutdown(client, shutdown_callback, this);
++
++                iSampleRate = jack_get_sample_rate(client);
++
++                if (jack_activate(client) || in_port == NULL || out_port == NULL) {
++                    client = NULL;
++                    return;
++                }
++
++                int port_flags;
++                unsigned i = -1;
++                const char** ports = jack_get_ports(client, 0, 0, JackPortIsPhysical);
++
++                if (ports) {
++                    while (ports[++i])
++                    {
++                        jack_port_t* port = jack_port_by_name(client, ports[i]);
++                        port_flags = jack_port_flags(port);
++
++                        if (port_flags & (JackPortIsPhysical|JackPortIsOutput) && strstr(jack_port_type(port), "audio")) {
++                            jack_connect(client, ports[i], jack_port_name(in_port));
++                        }
++                        if (port_flags & (JackPortIsPhysical|JackPortIsInput) && strstr(jack_port_type(port), "audio")) {
++                            jack_connect(client, jack_port_name(out_port), ports[i]);
++                        }
++                    }
++                }
++
++                jack_free(ports);
++
++                // If we made it this far, then everything is okay
++                qhInput.insert(QString(), tr("Hardware Ports"));
++                qhOutput.insert(QString(), tr("Hardware Ports"));
++                bJackIsGood = true;
++
++            } else {
++                bJackIsGood = false;
++                client = NULL;
++            }
++}
++
++void JackAudioSystem::close_jack()
++{
++        if (client) {
++                jack_deactivate(client);
++                jack_client_close(client);
++                client = NULL;
++        }
++}
++
++int JackAudioSystem::process_callback(jack_nframes_t nframes, void *arg)
++{
++        JackAudioSystem *jas = (JackAudioSystem*)arg;
++
++        if (jas && jas->bJackIsGood) {
++                AudioInputPtr ai = g.ai;
++                AudioOutputPtr ao = g.ao;
++                JackAudioInput *jai = (JackAudioInput*)(ai.get());
++                JackAudioOutput *jao = (JackAudioOutput*)(ao.get());
++
++                if (jai && jai->bRunning && jai->iMicChannels > 0 && !jai->isFinished()) {
++                        void* input = jack_port_get_buffer(jas->in_port, nframes);
++                        if ((float*)input != 0)
++                            jai->addMic(input, nframes);
++                }
++
++                if (jao && jao->bRunning && jao->iChannels > 0 && !jao->isFinished()) {
++                        jack_default_audio_sample_t* output = (jack_default_audio_sample_t*)jack_port_get_buffer(jas->out_port, nframes);
++                        memset(output, 0, sizeof(jack_default_audio_sample_t)*nframes); //TEST
++                        jao->mix(output, nframes);
++                }
++        }
++
++        return 0;
++}
++
++int JackAudioSystem::srate_callback(jack_nframes_t frames, void *arg)
++{
++        JackAudioSystem *jas = (JackAudioSystem*)arg;
++        jas->iSampleRate = frames;
++        return 0;
++}
++
++void JackAudioSystem::shutdown_callback(void *arg)
++{
++        JackAudioSystem *jas = (JackAudioSystem*)arg;
++        jas->bJackIsGood = false;
++}
++
++JackAudioInputRegistrar::JackAudioInputRegistrar() : AudioInputRegistrar(QLatin1String("JACK"), 10) {
++}
++
++AudioInput *JackAudioInputRegistrar::create() {
++        return new JackAudioInput();
++}
++
++const QList<audioDevice> JackAudioInputRegistrar::getDeviceChoices() {
++        QList<audioDevice> qlReturn;
++
++        QStringList qlInputDevs = jasys->qhInput.keys();
++        qSort(qlInputDevs);
++
++        foreach(const QString &dev, qlInputDevs) {
++                qlReturn << audioDevice(jasys->qhInput.value(dev), dev);
++        }
++
++        return qlReturn;
++}
++
++void JackAudioInputRegistrar::setDeviceChoice(const QVariant &choice, Settings &s) {
++        Q_UNUSED(choice);
++        Q_UNUSED(s);
++}
++
++bool JackAudioInputRegistrar::canEcho(const QString &osys) const {
++        Q_UNUSED(osys);
++        return false;
++}
++
++JackAudioOutputRegistrar::JackAudioOutputRegistrar() : AudioOutputRegistrar(QLatin1String("JACK"), 10) {
++}
++
++AudioOutput *JackAudioOutputRegistrar::create() {
++        return new JackAudioOutput();
++}
++
++const QList<audioDevice> JackAudioOutputRegistrar::getDeviceChoices() {
++        QList<audioDevice> qlReturn;
++
++        QStringList qlOutputDevs = jasys->qhOutput.keys();
++        qSort(qlOutputDevs);
++
++        foreach(const QString &dev, qlOutputDevs) {
++                qlReturn << audioDevice(jasys->qhOutput.value(dev), dev);
++        }
++
++        return qlReturn;
++}
++
++void JackAudioOutputRegistrar::setDeviceChoice(const QVariant &choice, Settings &s) {
++        Q_UNUSED(choice);
++        Q_UNUSED(s);
++}
++
++JackAudioInput::JackAudioInput() {
++        bRunning = true;
++        iMicChannels = 0;
++};
++
++JackAudioInput::~JackAudioInput() {
++        bRunning = false;
++        iMicChannels = 0;
++        qmMutex.lock();
++        qwcWait.wakeAll();
++        qmMutex.unlock();
++        wait();
++}
++
++void JackAudioInput::run() {
++        if (jasys && jasys->bJackIsGood) {
++            iMicFreq = jasys->iSampleRate;
++            iMicChannels = 1;
++            eMicFormat = SampleFloat;
++            initializeMixer();
++        }
++
++        qmMutex.lock();
++        while (bRunning)
++                qwcWait.wait(&qmMutex);
++        qmMutex.unlock();
++}
++
++JackAudioOutput::JackAudioOutput() {
++        bRunning = true;
++        iChannels = 0;
++}
++
++JackAudioOutput::~JackAudioOutput() {
++        bRunning = false;
++        iChannels = 0;
++        qmMutex.lock();
++        qwcWait.wakeAll();
++        qmMutex.unlock();
++        wait();
++}
++
++void JackAudioOutput::run() {
++        if (jasys && jasys->bJackIsGood) {
++            unsigned int chanmasks[32];
++
++            chanmasks[0] = SPEAKER_FRONT_LEFT;
++            chanmasks[1] = SPEAKER_FRONT_RIGHT;
++
++            eSampleFormat = SampleFloat;
++            iMixerFreq = jasys->iSampleRate;
++            iChannels = 1;
++            initializeMixer(chanmasks);
++        }
++
++        qmMutex.lock();
++        while (bRunning)
++                qwcWait.wait(&qmMutex);
++        qmMutex.unlock();
++}
+diff -U 3 -H -d -r -N -- mumble-1.2.2.orig/src/mumble/JackAudio.h mumble-1.2.2/src/mumble/JackAudio.h
+--- mumble-1.2.2.orig/src/mumble/JackAudio.h	1970-01-01 01:00:00.000000000 +0100
++++ mumble-1.2.2/src/mumble/JackAudio.h	2011-01-26 06:03:58.000000000 +0000
+@@ -0,0 +1,97 @@
++/* Copyright (C) 2011, Benjamin Jemlich <pcgod@users.sourceforge.net>
++   Copyright (C) 2011, Filipe Coelho <falktx@gmail.com>
++
++   All rights reserved.
++
++   Redistribution and use in source and binary forms, with or without
++   modification, are permitted provided that the following conditions
++   are met:
++
++   - Redistributions of source code must retain the above copyright notice,
++     this list of conditions and the following disclaimer.
++   - Redistributions in binary form must reproduce the above copyright notice,
++     this list of conditions and the following disclaimer in the documentation
++     and/or other materials provided with the distribution.
++   - Neither the name of the Mumble Developers nor the names of its
++     contributors may be used to endorse or promote products derived from this
++     software without specific prior written permission.
++
++   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
++   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
++   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
++   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
++   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
++   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
++   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
++   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
++   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
++   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
++   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++*/
++
++#ifndef _JACKAUDIO_H
++#define _JACKAUDIO_H
++
++#include "AudioInput.h"
++#include "AudioOutput.h"
++#include <jack/jack.h>
++
++class JackAudioOutput;
++class JackAudioInput;
++
++class JackAudioSystem : public QObject {
++        private:
++                Q_OBJECT
++                Q_DISABLE_COPY(JackAudioSystem)
++        protected:
++                jack_client_t* client;
++                jack_port_t* in_port;
++                jack_port_t* out_port;
++
++                static int process_callback(jack_nframes_t nframes, void *arg);
++                static int srate_callback(jack_nframes_t frames, void *arg);
++                static void shutdown_callback(void *arg);
++        public:
++                QHash<QString, QString> qhInput;
++                QHash<QString, QString> qhOutput;
++                bool bJackIsGood;
++                int iSampleRate;
++                QMutex qmWait;
++                QWaitCondition qwcWait;
++
++                void init_jack();
++                void close_jack();
++
++                JackAudioSystem();
++                ~JackAudioSystem();
++};
++
++class JackAudioInput : public AudioInput {
++                friend class JackAudioSystem;
++        private:
++                Q_OBJECT
++                Q_DISABLE_COPY(JackAudioInput)
++        protected:
++                QMutex qmMutex;
++                QWaitCondition qwcWait;
++        public:
++                JackAudioInput();
++                ~JackAudioInput();
++                void run();
++};
++
++class JackAudioOutput : public AudioOutput {
++                friend class JackAudioSystem;
++        private:
++                Q_OBJECT
++                Q_DISABLE_COPY(JackAudioOutput)
++        protected:
++                QMutex qmMutex;
++                QWaitCondition qwcWait;
++        public:
++                JackAudioOutput();
++                ~JackAudioOutput();
++                void run();
++};
++
++#endif
+diff -U 3 -H -d -r -N -- mumble-1.2.2.orig/src/mumble/mumble.pro mumble-1.2.2/src/mumble/mumble.pro
+--- mumble-1.2.2.orig/src/mumble/mumble.pro	2010-02-09 16:34:51.000000000 +0000
++++ mumble-1.2.2/src/mumble/mumble.pro	2011-01-26 01:45:55.000000000 +0000
+@@ -93,11 +93,17 @@
+ unix {
+   HAVE_PULSEAUDIO=$$system(pkg-config --modversion --silence-errors libpulse)
+   HAVE_PORTAUDIO=$$system(pkg-config --modversion --silence-errors portaudio-2.0)
++  HAVE_JACKAUDIO=$$system(pkg-config --modversion --silence-errors jack)
+ 
+   !isEmpty(HAVE_PORTAUDIO):!CONFIG(no-portaudio) {
+     CONFIG *= portaudio
+   }
+ 
++  !isEmpty(HAVE_JACKAUDIO):!CONFIG(no-jackaudio) {
++    CONFIG -= portaudio
++    CONFIG *= jackaudio
++  }
++
+   !isEmpty(HAVE_PULSEAUDIO):!CONFIG(no-pulseaudio) {
+     CONFIG -= portaudio
+     CONFIG *= pulseaudio
+@@ -110,6 +116,13 @@
+     QMAKE_CXXFLAGS_DEBUG *= -I../../speex/include -I../../speexbuild
+   }
+ 
++  jackaudio {
++        DEFINES *= USE_JACKAUDIO
++        PKGCONFIG *= jack
++        HEADERS *= JackAudio.h
++        SOURCES *= JackAudio.cpp
++  }
++
+   CONFIG *= link_pkgconfig
+ 
+   PKGCONFIG *= openssl sndfile