src/bindings/qt4/raopservice.cpp

   1 /**
   2  * Copyright (C) 2012  Juho Vähä-Herttua
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining
   5  * a copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sublicense, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included
  13  * in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  18  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  19  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  20  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  21  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include "raopservice.h"
  25 #include "raopcallbackhandler.h"
  26
  27 #include <QThread>
  28 #include <QDebug>
  29
  30 #define RSA_KEY \
  31 "-----BEGIN RSA PRIVATE KEY-----\n"\
  32 "MIIEpQIBAAKCAQEA59dE8qLieItsH1WgjrcFRKj6eUWqi+bGLOX1HL3U3GhC/j0Qg90u3sG/1CUt\n"\
  33 "wC5vOYvfDmFI6oSFXi5ELabWJmT2dKHzBJKa3k9ok+8t9ucRqMd6DZHJ2YCCLlDRKSKv6kDqnw4U\n"\
  34 "wPdpOMXziC/AMj3Z/lUVX1G7WSHCAWKf1zNS1eLvqr+boEjXuBOitnZ/bDzPHrTOZz0Dew0uowxf\n"\
  35 "/+sG+NCK3eQJVxqcaJ/vEHKIVd2M+5qL71yJQ+87X6oV3eaYvt3zWZYD6z5vYTcrtij2VZ9Zmni/\n"\
  36 "UAaHqn9JdsBWLUEpVviYnhimNVvYFZeCXg/IdTQ+x4IRdiXNv5hEewIDAQABAoIBAQDl8Axy9XfW\n"\
  37 "BLmkzkEiqoSwF0PsmVrPzH9KsnwLGH+QZlvjWd8SWYGN7u1507HvhF5N3drJoVU3O14nDY4TFQAa\n"\
  38 "LlJ9VM35AApXaLyY1ERrN7u9ALKd2LUwYhM7Km539O4yUFYikE2nIPscEsA5ltpxOgUGCY7b7ez5\n"\
  39 "NtD6nL1ZKauw7aNXmVAvmJTcuPxWmoktF3gDJKK2wxZuNGcJE0uFQEG4Z3BrWP7yoNuSK3dii2jm\n"\
  40 "lpPHr0O/KnPQtzI3eguhe0TwUem/eYSdyzMyVx/YpwkzwtYL3sR5k0o9rKQLtvLzfAqdBxBurciz\n"\
  41 "aaA/L0HIgAmOit1GJA2saMxTVPNhAoGBAPfgv1oeZxgxmotiCcMXFEQEWflzhWYTsXrhUIuz5jFu\n"\
  42 "a39GLS99ZEErhLdrwj8rDDViRVJ5skOp9zFvlYAHs0xh92ji1E7V/ysnKBfsMrPkk5KSKPrnjndM\n"\
  43 "oPdevWnVkgJ5jxFuNgxkOLMuG9i53B4yMvDTCRiIPMQ++N2iLDaRAoGBAO9v//mU8eVkQaoANf0Z\n"\
  44 "oMjW8CN4xwWA2cSEIHkd9AfFkftuv8oyLDCG3ZAf0vrhrrtkrfa7ef+AUb69DNggq4mHQAYBp7L+\n"\
  45 "k5DKzJrKuO0r+R0YbY9pZD1+/g9dVt91d6LQNepUE/yY2PP5CNoFmjedpLHMOPFdVgqDzDFxU8hL\n"\
  46 "AoGBANDrr7xAJbqBjHVwIzQ4To9pb4BNeqDndk5Qe7fT3+/H1njGaC0/rXE0Qb7q5ySgnsCb3DvA\n"\
  47 "cJyRM9SJ7OKlGt0FMSdJD5KG0XPIpAVNwgpXXH5MDJg09KHeh0kXo+QA6viFBi21y340NonnEfdf\n"\
  48 "54PX4ZGS/Xac1UK+pLkBB+zRAoGAf0AY3H3qKS2lMEI4bzEFoHeK3G895pDaK3TFBVmD7fV0Zhov\n"\
  49 "17fegFPMwOII8MisYm9ZfT2Z0s5Ro3s5rkt+nvLAdfC/PYPKzTLalpGSwomSNYJcB9HNMlmhkGzc\n"\
  50 "1JnLYT4iyUyx6pcZBmCd8bD0iwY/FzcgNDaUmbX9+XDvRA0CgYEAkE7pIPlE71qvfJQgoA9em0gI\n"\
  51 "LAuE4Pu13aKiJnfft7hIjbK+5kyb3TysZvoyDnb3HOKvInK7vXbKuU4ISgxB2bB3HcYzQMGsz1qJ\n"\
  52 "2gG0N5hvJpzwwhbhXqFKA4zaaSrw622wDniAK5MlIE0tIAKKP4yxNGjoD2QYjhBGuhvkWKY=\n"\
  53 "-----END RSA PRIVATE KEY-----\n"
  54
  55 typedef struct {
  56     QThread *             cb_thread;
  57     RaopCallbackHandler * cb_handler;
  58     void *                cb_session;
  59 } audio_session_t;
  60
  61 static void*
  62 audio_init_cb(void *cls, int bits, int channels, int samplerate)
  63 {
  64     audio_session_t *audio_session = 0;
  65
  66     audio_session = (audio_session_t *)calloc(1, sizeof(audio_session_t));
  67     audio_session->cb_thread = new QThread();
  68     audio_session->cb_thread->start();
  69
  70     /* This whole hack is required because QAudioOutput
  71      * needs to be created in a QThread, threads created
  72      * outside Qt are not allowed (they have no eventloop) */
  73     audio_session->cb_handler = new RaopCallbackHandler();
  74     audio_session->cb_handler->moveToThread(audio_session->cb_thread);
  75     audio_session->cb_handler->init((RaopCallbacks *)cls);
  76
  77     QMetaObject::invokeMethod(audio_session->cb_handler, "audioInit",
  78                               Qt::BlockingQueuedConnection,
  79                               Q_ARG(void*, (void*)&audio_session->cb_session),
  80                               Q_ARG(int, bits),
  81                               Q_ARG(int, channels),
  82                               Q_ARG(int, samplerate));
  83     return audio_session;
  84 }
  85
  86 static void
  87 audio_process_cb(void *cls, void *session, const void *buffer, int buflen)
  88 {
  89     Q_UNUSED(cls)
  90     audio_session_t *audio_session = (audio_session_t *)session;
  91     QMetaObject::invokeMethod(audio_session->cb_handler, "audioProcess",
  92                               Qt::BlockingQueuedConnection,
  93                               Q_ARG(void*, audio_session->cb_session),
  94                               Q_ARG(void*, (void*)buffer),
  95                               Q_ARG(int, buflen));
  96 }
  97
  98 static void
  99 audio_destroy_cb(void *cls, void *session)
 100 {
 101     Q_UNUSED(cls)
 102     audio_session_t *audio_session = (audio_session_t *)session;
 103     QMetaObject::invokeMethod(audio_session->cb_handler, "audioDestroy",
 104                               Qt::BlockingQueuedConnection,
 105                               Q_ARG(void*, audio_session->cb_session));
 106
 107     // Wait until the session thread has finished
 108     audio_session->cb_thread->quit();
 109     audio_session->cb_thread->wait();
 110
 111     // Delete all session variables
 112     delete audio_session->cb_handler;
 113     delete audio_session->cb_thread;
 114     free(audio_session);
 115 }
 116
 117 static void
 118 audio_flush_cb(void *cls, void *session)
 119 {
 120     Q_UNUSED(cls)
 121     audio_session_t *audio_session = (audio_session_t *)session;
 122     QMetaObject::invokeMethod(audio_session->cb_handler, "audioFlush",
 123                               Qt::BlockingQueuedConnection,
 124                               Q_ARG(void*, audio_session->cb_session));
 125 }
 126
 127 static void
 128 audio_set_volume_cb(void *cls, void *session, float volume)
 129 {
 130     Q_UNUSED(cls)
 131     audio_session_t *audio_session = (audio_session_t *)session;
 132     QMetaObject::invokeMethod(audio_session->cb_handler, "audioSetVolume",
 133                               Qt::BlockingQueuedConnection,
 134                               Q_ARG(void*, audio_session->cb_session),
 135                               Q_ARG(float, volume));
 136 }
 137
 138 static void
 139 audio_set_metadata_cb(void *cls, void *session, const void *buffer, int buflen)
 140 {
 141     Q_UNUSED(cls)
 142     audio_session_t *audio_session = (audio_session_t *)session;
 143     QMetaObject::invokeMethod(audio_session->cb_handler, "audioSetVolume",
 144                               Qt::BlockingQueuedConnection,
 145                               Q_ARG(void*, audio_session->cb_session),
 146                               Q_ARG(void*, (void*)buffer),
 147                               Q_ARG(int, buflen));
 148 }
 149
 150 static void
 151 audio_set_coverart_cb(void *cls, void *session, const void *buffer, int buflen)
 152 {
 153     Q_UNUSED(cls)
 154     audio_session_t *audio_session = (audio_session_t *)session;
 155     QMetaObject::invokeMethod(audio_session->cb_handler, "audioSetVolume",
 156                               Qt::BlockingQueuedConnection,
 157                               Q_ARG(void*, audio_session->cb_session),
 158                               Q_ARG(void*, (void*)buffer),
 159                               Q_ARG(int, buflen));
 160 }
 161
 162 RaopService::RaopService(QObject *parent) :
 163     QObject(parent),
 164     m_raop(0)
 165 {
 166 }
 167
 168 RaopService::~RaopService()
 169 {
 170     this->stop();
 171     raop_destroy(m_raop);
 172 }
 173
 174 bool RaopService::init(int max_clients, RaopCallbacks *callbacks)
 175 {
 176     raop_callbacks_t raop_cbs;
 177
 178     raop_cbs.cls = callbacks;
 179     raop_cbs.audio_init = &audio_init_cb;
 180     raop_cbs.audio_process = &audio_process_cb;
 181     raop_cbs.audio_destroy = &audio_destroy_cb;
 182     raop_cbs.audio_flush = &audio_flush_cb;
 183     raop_cbs.audio_set_volume = &audio_set_volume_cb;
 184     raop_cbs.audio_set_metadata = &audio_set_metadata_cb;
 185     raop_cbs.audio_set_coverart = &audio_set_coverart_cb;
 186
 187     m_raop = raop_init(max_clients, &raop_cbs, RSA_KEY);
 188     if (!m_raop) {
 189         return false;
 190     }
 191     return true;
 192 }
 193
 194 bool RaopService::isRunning()
 195 {
 196     return (raop_is_running(m_raop) != 0);
 197 }
 198
 199 bool RaopService::start(quint16 port, const QByteArray & hwaddr)
 200 {
 201     int ret;
 202     ret = raop_start(m_raop, &port, hwaddr.data(), hwaddr.size(), 0);
 203     if (ret < 0) {
 204         return false;
 205     }
 206     return true;
 207 }
 208
 209 void RaopService::stop()
 210 {
 211     if (m_raop) {
 212         raop_stop(m_raop);
 213     }
 214 }