android/JackOpenSLESDriver.cpp

   1 /*
   2 Copyright (C) 2001 Paul Davis
   3 Copyright (C) 2004-2008 Grame
   4 Copyright (C) 2013 Samsung Electronics
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20 */
  21
  22 #include "JackOpenSLESDriver.h"
  23 #include "JackDriverLoader.h"
  24 #include "JackThreadedDriver.h"
  25 #include "JackEngineControl.h"
  26 #include "JackGraphManager.h"
  27 #include "JackCompilerDeps.h"
  28 #include <iostream>
  29 #include <unistd.h>
  30 #include <fcntl.h>
  31 #include <math.h>
  32
  33 #include <android/log.h>
  34 #include "opensl_io.h"
  35
  36 #define JACK_OPENSLES_DEFAULT_SAMPLERATE   48000
  37 #define JACK_OPENSLES_DEFAULT_BUFFER_SIZE  960
  38
  39 namespace Jack
  40 {
  41
  42 static OPENSL_STREAM  *pOpenSL_stream;
  43
  44 int JackOpenSLESDriver::Open(jack_nframes_t buffer_size,
  45                               jack_nframes_t samplerate,
  46                               bool capturing,
  47                               bool playing,
  48                               int inchannels,
  49                               int outchannels,
  50                               bool monitor,
  51                               const char* capture_driver_uid,
  52                               const char* playback_driver_uid,
  53                               jack_nframes_t capture_latency,
  54                               jack_nframes_t playback_latency) {
  55     jack_log("JackOpenSLESDriver::Open");
  56
  57     // Generic JackAudioDriver Open
  58     if (JackAudioDriver::Open(buffer_size, samplerate, capturing, playing, inchannels, outchannels, monitor,
  59         capture_driver_uid, playback_driver_uid, capture_latency, playback_latency) != 0) {
  60         return -1;
  61     }
  62
  63     if (capturing) {
  64         inbuffer = (float *) malloc(sizeof(float) * buffer_size);  //mono input
  65         memset(inbuffer, 0, sizeof(float) * buffer_size);
  66     }
  67     if (playing) {
  68         outbuffer = (float *) malloc(sizeof(float) * buffer_size * 2);  //stereo output
  69         memset(outbuffer, 0, sizeof(float) * buffer_size * 2);
  70     }
  71     pOpenSL_stream = android_OpenAudioDevice(samplerate, capturing ? 1 : 0, playing ? 2 : 0, buffer_size);
  72     if (pOpenSL_stream == NULL)  return -1;
  73
  74     return 0;
  75 }
  76
  77 int JackOpenSLESDriver::Close() {
  78     jack_log("JackOpenSLESDriver::Close");
  79
  80     // Generic audio driver close
  81     int res = JackAudioDriver::Close();
  82
  83     android_CloseAudioDevice(pOpenSL_stream);
  84
  85     if (inbuffer) {
  86         free(inbuffer);
  87         inbuffer = NULL;
  88     }
  89     if (outbuffer) {
  90         free(outbuffer);
  91         outbuffer = NULL;
  92     }
  93     return res;
  94 }
  95
  96 int JackOpenSLESDriver::Read() {
  97     //jack_log("JackOpenSLESDriver::Read");
  98     jack_default_audio_sample_t* inputBuffer_1 = GetInputBuffer(0);
  99     jack_default_audio_sample_t* inputBuffer_2 = GetInputBuffer(1);
 100
 101     if (inbuffer) {
 102         int samps = android_AudioIn(pOpenSL_stream,inbuffer,fEngineControl->fBufferSize);
 103         for (int i = 0; i < samps; i++) {
 104             *(inputBuffer_1 + i) = *(inbuffer + i);
 105             *(inputBuffer_2 + i) = *(inbuffer + i);
 106         }
 107     } else {
 108         for (int i = 0; i < fCaptureChannels; i++) {
 109             memset(GetInputBuffer(i), 0, sizeof(jack_default_audio_sample_t) * fEngineControl->fBufferSize);  //silence
 110         }
 111     }
 112
 113     return 0;
 114 }
 115
 116 int JackOpenSLESDriver::Write() {
 117     //jack_log("JackOpenSLESDriver::Write");
 118     jack_default_audio_sample_t* outputBuffer_1 = GetOutputBuffer(0);
 119     jack_default_audio_sample_t* outputBuffer_2 = GetOutputBuffer(1);
 120
 121     if (outbuffer) {
 122         android_AudioOut(pOpenSL_stream, outbuffer, fEngineControl->fBufferSize * 2);  //stereo output
 123         for (unsigned int i = 0, j = 0; i < fEngineControl->fBufferSize; i++) {
 124             *(outbuffer + j) = *(outputBuffer_1 + i);  j++;
 125             *(outbuffer + j) = *(outputBuffer_2 + i);  j++;
 126         }
 127     }
 128
 129     return 0;
 130 }
 131
 132 int JackOpenSLESDriver::SetBufferSize(jack_nframes_t buffer_size) {
 133     jack_log("JackOpenSLESDriver::SetBufferSize");
 134     JackAudioDriver::SetBufferSize(buffer_size);
 135     return 0;
 136 }
 137
 138 } // end of namespace
 139
 140
 141 #ifdef __cplusplus
 142 extern "C"
 143 {
 144 #endif
 145
 146     SERVER_EXPORT jack_driver_desc_t * driver_get_descriptor () {
 147         jack_driver_desc_t * desc;
 148         jack_driver_desc_filler_t filler;
 149         jack_driver_param_value_t value;
 150
 151         desc = jack_driver_descriptor_construct("opensles", JackDriverMaster, "Timer based backend", &filler);
 152
 153         value.ui = 2U;
 154         jack_driver_descriptor_add_parameter(desc, &filler, "capture", 'C', JackDriverParamUInt, &value, NULL, "Number of capture ports", NULL);
 155         jack_driver_descriptor_add_parameter(desc, &filler, "playback", 'P', JackDriverParamUInt, &value, NULL, "Number of playback ports", NULL);
 156
 157         value.ui = 48000U;
 158         jack_driver_descriptor_add_parameter(desc, &filler, "rate", 'r', JackDriverParamUInt, &value, NULL, "Sample rate", NULL);
 159
 160         value.i = 0;
 161         jack_driver_descriptor_add_parameter(desc, &filler, "monitor", 'm', JackDriverParamBool, &value, NULL, "Provide monitor ports for the output", NULL);
 162
 163         value.ui = JACK_OPENSLES_DEFAULT_BUFFER_SIZE;
 164         jack_driver_descriptor_add_parameter(desc, &filler, "period", 'p', JackDriverParamUInt, &value, NULL, "Frames per period", NULL);
 165
 166         value.ui = 21333U;
 167         jack_driver_descriptor_add_parameter(desc, &filler, "wait", 'w', JackDriverParamUInt, &value, NULL, "Number of usecs to wait between engine processes", NULL);
 168
 169         return desc;
 170     }
 171
 172     SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize(Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params) {
 173         jack_nframes_t sample_rate = JACK_OPENSLES_DEFAULT_SAMPLERATE;
 174         jack_nframes_t buffer_size = JACK_OPENSLES_DEFAULT_BUFFER_SIZE;
 175         unsigned int capture_ports = 0;
 176         unsigned int playback_ports = 2;
 177         int wait_time = 0;
 178         const JSList * node;
 179         const jack_driver_param_t * param;
 180         bool monitor = false;
 181
 182         for (node = params; node; node = jack_slist_next (node)) {
 183             param = (const jack_driver_param_t *) node->data;
 184
 185             switch (param->character) {
 186
 187                 case 'C':
 188                     capture_ports = param->value.ui;
 189                     break;
 190
 191                 case 'P':
 192                     playback_ports = param->value.ui;
 193                     break;
 194
 195                 case 'r':
 196                     sample_rate = param->value.ui;
 197                     break;
 198
 199                 case 'p':
 200                     buffer_size = param->value.ui;
 201                     break;
 202
 203                 case 'w':
 204                     wait_time = param->value.ui;
 205                     break;
 206
 207                 case 'm':
 208                     monitor = param->value.i;
 209                     break;
 210             }
 211         }
 212
 213         if (wait_time > 0) {
 214             buffer_size = lroundf((wait_time * sample_rate) / 1000000.0f);
 215             if (buffer_size > BUFFER_SIZE_MAX) {
 216                 buffer_size = BUFFER_SIZE_MAX;
 217                 jack_error("Buffer size set to %d", BUFFER_SIZE_MAX);
 218             }
 219         }
 220
 221         Jack::JackDriverClientInterface* driver = new Jack::JackThreadedDriver(new Jack::JackOpenSLESDriver("system", "opensles_pcm", engine, table));
 222         if (driver->Open(buffer_size, sample_rate, capture_ports? 1 : 0, playback_ports? 1 : 0, capture_ports, playback_ports, monitor, "opensles", "opensles", 0, 0) == 0) {
 223             return driver;
 224         } else {
 225             delete driver;
 226             return NULL;
 227         }
 228     }
 229
 230 #ifdef __cplusplus
 231 }
 232 #endif
 233