The Tor Browser / file revision

 /*

  * Copyright © 2013 Mozilla Foundation

  *

  * This program is made available under an ISC-style license.  See the

  * accompanying file LICENSE for details.

  */

 #if !defined(NDEBUG)

 #define NDEBUG

 #endif

 #include <assert.h>

 #include <pthread.h>

 #include <stdlib.h>

 #include <time.h>

 #include <dlfcn.h>

 #include "android/log.h"

 #include "cubeb/cubeb.h"

 #include "cubeb-internal.h"

 #include "android/audiotrack_definitions.h"

 #ifndef ALOG

 #if defined(DEBUG) || defined(FORCE_ALOG)

 #define ALOG(args...)  __android_log_print(ANDROID_LOG_INFO, "Gecko - Cubeb" , ## args)

 #else

 #define ALOG(args...)

 #endif

 #endif

 /**

  * A lot of bytes for safety. It should be possible to bring this down a bit. */

 #define SIZE_AUDIOTRACK_INSTANCE 256

 /**

  * call dlsym to get the symbol |mangled_name|, handle the error and store the

  * pointer in |pointer|. Because depending on Android version, we want different

  * symbols, not finding a symbol is not an error. */

 #define DLSYM_DLERROR(mangled_name, pointer, lib)                        \

   do {                                                                   \

     pointer = dlsym(lib, mangled_name);                                  \

     if (!pointer) {                                                      \

       ALOG("error while loading %stm: %stm\n", mangled_name, dlerror()); \

     } else {                                                             \

       ALOG("%stm: OK", mangled_name);                                    \

     }                                                                    \

   } while(0);

 static struct cubeb_ops const audiotrack_ops;

 void audiotrack_destroy(cubeb * context);

 void audiotrack_stream_destroy(cubeb_stream * stream);

 struct AudioTrack {

                /* only available on ICS and later. The second int paramter is in fact of type audio_stream_type_t. */

   /* static */ status_t (*get_min_frame_count)(int* frame_count, int stream_type, uint32_t rate);

               /* if we have a recent ctor, but can't find the above symbol, we

                * can get the minimum frame count with this signature, and we are

                * running gingerbread. */

   /* static */ status_t (*get_min_frame_count_gingerbread)(int* frame_count, int stream_type, uint32_t rate);

                /* if this symbol is not availble, and the next one is, we know

                 * we are on a Froyo (Android 2.2) device. */

                void* (*ctor)(void* instance, int, unsigned int, int, int, int, unsigned int, void (*)(int, void*, void*), void*, int, int);

                void* (*ctor_froyo)(void* instance, int, unsigned int, int, int, int, unsigned int, void (*)(int, void*, void*), void*, int);

                void* (*dtor)(void* instance);

                void (*start)(void* instance);

                void (*pause)(void* instance);

                uint32_t (*latency)(void* instance);

                status_t (*check)(void* instance);

                status_t (*get_position)(void* instance, uint32_t* position);

               /* only used on froyo. */

   /* static */ int (*get_output_frame_count)(int* frame_count, int stream);

   /* static */ int (*get_output_latency)(uint32_t* latency, int stream);

   /* static */ int (*get_output_samplingrate)(int* samplerate, int stream);

                status_t (*set_marker_position)(void* instance, unsigned int);

 };

 struct cubeb {

   struct cubeb_ops const * ops;

   void * library;

   struct AudioTrack klass;

 };

 struct cubeb_stream {

   cubeb * context;

   cubeb_stream_params params;

   cubeb_data_callback data_callback;

   cubeb_state_callback state_callback;

   void * instance;

   void * user_ptr;

   /* Number of frames that have been passed to the AudioTrack callback */

   long unsigned written;

   int draining;

 };

 static void

 audiotrack_refill(int event, void* user, void* info)

 {

   cubeb_stream * stream = user;

   switch (event) {

     case EVENT_MORE_DATA: {

       long got = 0;

       struct Buffer * b = (struct Buffer*)info;

       if (stream->draining) {

         return;

       }

       got = stream->data_callback(stream, stream->user_ptr, b->raw, b->frameCount);

       stream->written += got;

       if (got != (long)b->frameCount) {

         uint32_t p;

         stream->draining = 1;

         /* set a marker so we are notified when the are done draining, that is,

          * when every frame has been played by android. */

         stream->context->klass.set_marker_position(stream->instance, stream->written);

       }

       break;

     }

     case EVENT_UNDERRUN:

       ALOG("underrun in cubeb backend.");

       break;

     case EVENT_LOOP_END:

       assert(0 && "We don't support the loop feature of audiotrack.");

       break;

     case EVENT_MARKER:

       assert(stream->draining);

       stream->state_callback(stream, stream->user_ptr, CUBEB_STATE_DRAINED);

       break;

     case EVENT_NEW_POS:

       assert(0 && "We don't support the setPositionUpdatePeriod feature of audiotrack.");

       break;

     case EVENT_BUFFER_END:

       assert(0 && "Should not happen.");

       break;

   }

 }

 /* We are running on froyo if we found the right AudioTrack constructor */

 static int

 audiotrack_version_is_froyo(cubeb * ctx)

 {

   return ctx->klass.ctor_froyo != NULL;

 }

 /* We are running on gingerbread if we found the gingerbread signature for

  * getMinFrameCount */

 static int

 audiotrack_version_is_gingerbread(cubeb * ctx)

 {

   return ctx->klass.get_min_frame_count_gingerbread != NULL;

 }

 int

 audiotrack_get_min_frame_count(cubeb * ctx, cubeb_stream_params * params, int * min_frame_count)

 {

   status_t status;

   /* Recent Android have a getMinFrameCount method. On Froyo, we have to compute it by hand. */

   if (audiotrack_version_is_froyo(ctx)) {

     int samplerate, frame_count, latency, min_buffer_count;

     status = ctx->klass.get_output_frame_count(&frame_count, params->stream_type);

     if (status) {

       ALOG("error getting the output frame count.");

       return CUBEB_ERROR;

     }

     status = ctx->klass.get_output_latency((uint32_t*)&latency, params->stream_type);

     if (status) {

       ALOG("error getting the output frame count.");

       return CUBEB_ERROR;

     }

     status = ctx->klass.get_output_samplingrate(&samplerate, params->stream_type);

     if (status) {

       ALOG("error getting the output frame count.");

       return CUBEB_ERROR;

     }

     /* Those numbers were found reading the Android source. It is the minimum

      * numbers that will be accepted by the AudioTrack class, hence yielding the

      * best latency possible.

      * See https://android.googlesource.com/platform/frameworks/base/+/android-2.2.3_r2.1/media/libmedia/AudioTrack.cpp

      * around line 181 for Android 2.2 */

     min_buffer_count = latency / ((1000 * frame_count) / samplerate);

     min_buffer_count = min_buffer_count < 2 ? min_buffer_count : 2;

     *min_frame_count = (frame_count * params->rate * min_buffer_count) / samplerate;

     return CUBEB_OK;

   }

   /* Recent Android have a getMinFrameCount method. */

   if (!audiotrack_version_is_gingerbread(ctx)) {

     status = ctx->klass.get_min_frame_count(min_frame_count, params->stream_type, params->rate);

   } else {

     status = ctx->klass.get_min_frame_count_gingerbread(min_frame_count, params->stream_type, params->rate);

   }

   if (status != 0) {

     ALOG("error getting the min frame count");

     return CUBEB_ERROR;

   }

   return CUBEB_OK;

 }

 int

 audiotrack_init(cubeb ** context, char const * context_name)

 {

   cubeb * ctx;

   struct AudioTrack* c;

   assert(context);

   *context = NULL;

   ctx = calloc(1, sizeof(*ctx));

   assert(ctx);

   /* If we use an absolute path here ("/system/lib/libmedia.so"), and on Android

    * 2.2, the dlopen succeeds, all the dlsym succeed, but a segfault happens on

    * the first call to a dlsym'ed function. Somehow this does not happen when

    * using only the name of the library. */

   ctx->library = dlopen("libmedia.so", RTLD_LAZY);

   if (!ctx->library) {

     ALOG("dlopen error: %s.", dlerror());

     free(ctx);

     return CUBEB_ERROR;

   }

   /* Recent Android first, then Froyo. */

   DLSYM_DLERROR("_ZN7android10AudioTrackC1EijiiijPFviPvS1_ES1_ii", ctx->klass.ctor, ctx->library);

   if (!ctx->klass.ctor) {

     DLSYM_DLERROR("_ZN7android10AudioTrackC1EijiiijPFviPvS1_ES1_i", ctx->klass.ctor_froyo, ctx->library);

     assert(ctx->klass.ctor_froyo);

   }

   DLSYM_DLERROR("_ZN7android10AudioTrackD1Ev", ctx->klass.dtor, ctx->library);

   DLSYM_DLERROR("_ZNK7android10AudioTrack7latencyEv", ctx->klass.latency, ctx->library);

   DLSYM_DLERROR("_ZNK7android10AudioTrack9initCheckEv", ctx->klass.check, ctx->library);

   DLSYM_DLERROR("_ZN7android11AudioSystem21getOutputSamplingRateEPii", ctx->klass.get_output_samplingrate, ctx->library);

   /* |getMinFrameCount| is not available on Froyo, and is available on

    * gingerbread and ICS with a different signature. */

   if (audiotrack_version_is_froyo(ctx)) {

     DLSYM_DLERROR("_ZN7android11AudioSystem19getOutputFrameCountEPii", ctx->klass.get_output_frame_count, ctx->library);

     DLSYM_DLERROR("_ZN7android11AudioSystem16getOutputLatencyEPji", ctx->klass.get_output_latency, ctx->library);

   } else {

     DLSYM_DLERROR("_ZN7android10AudioTrack16getMinFrameCountEPi19audio_stream_type_tj", ctx->klass.get_min_frame_count, ctx->library);

     if (!ctx->klass.get_min_frame_count) {

       DLSYM_DLERROR("_ZN7android10AudioTrack16getMinFrameCountEPiij", ctx->klass.get_min_frame_count_gingerbread, ctx->library);

     }

   }

   DLSYM_DLERROR("_ZN7android10AudioTrack5startEv", ctx->klass.start, ctx->library);

   DLSYM_DLERROR("_ZN7android10AudioTrack5pauseEv", ctx->klass.pause, ctx->library);

   DLSYM_DLERROR("_ZN7android10AudioTrack11getPositionEPj", ctx->klass.get_position, ctx->library);

   DLSYM_DLERROR("_ZN7android10AudioTrack17setMarkerPositionEj", ctx->klass.set_marker_position, ctx->library);

   /* check that we have a combination of symbol that makes sense */

   c = &ctx->klass;

   if(!((c->ctor || c->ctor_froyo) && /* at least on ctor. */

      c->dtor && c->latency && c->check &&

      /* at least one way to get the minimum frame count to request. */

      ((c->get_output_frame_count && c->get_output_latency && c->get_output_samplingrate) ||

       c->get_min_frame_count ||

       c->get_min_frame_count_gingerbread) &&

      c->start && c->pause && c->get_position && c->set_marker_position)) {

     ALOG("Could not find all the symbols we need.");

     audiotrack_destroy(ctx);

     return CUBEB_ERROR;

   }

   ctx->ops = &audiotrack_ops;

   *context = ctx;

   return CUBEB_OK;

 }

 char const *

 audiotrack_get_backend_id(cubeb * context)

 {

   return "audiotrack";

 }

 static int

 audiotrack_get_max_channel_count(cubeb * ctx, uint32_t * max_channels)

 {

   assert(ctx && max_channels);

   /* The android mixer handles up to two channels, see

   http://androidxref.com/4.2.2_r1/xref/frameworks/av/services/audioflinger/AudioFlinger.h#67 */

   *max_channels = 2;

   return CUBEB_OK;

 }

 static int

 audiotrack_get_min_latency(cubeb * ctx, cubeb_stream_params params, uint32_t * latency_ms)

 {

   /* We always use the lowest latency possible when using this backend (see

    * audiotrack_stream_init), so this value is not going to be used. */

   int rv;

   rv = audiotrack_get_min_frame_count(ctx, &params, (int *)latency_ms);

   if (rv != CUBEB_OK) {

     return CUBEB_ERROR;

   }

   /* Convert to milliseconds. */

   *latency_ms = *latency_ms * 1000 / params.rate;

   return CUBEB_OK;

 }

 static int

 audiotrack_get_preferred_sample_rate(cubeb * ctx, uint32_t * rate)

 {

   status_t rv;

   rv = ctx->klass.get_output_samplingrate((int32_t *)rate, 3 /* MUSIC */);

   return rv == 0 ? CUBEB_OK : CUBEB_ERROR;

 }

 void

 audiotrack_destroy(cubeb * context)

 {

   assert(context);

   dlclose(context->library);

   free(context);

 }

 int

 audiotrack_stream_init(cubeb * ctx, cubeb_stream ** stream, char const * stream_name,

                        cubeb_stream_params stream_params, unsigned int latency,

                        cubeb_data_callback data_callback,

                        cubeb_state_callback state_callback,

                        void * user_ptr)

 {

   cubeb_stream * stm;

   int32_t channels;

   uint32_t min_frame_count;

   assert(ctx && stream);

   if (stream_params.format == CUBEB_SAMPLE_FLOAT32LE ||

       stream_params.format == CUBEB_SAMPLE_FLOAT32BE) {

     return CUBEB_ERROR_INVALID_FORMAT;

   }

   if (audiotrack_get_min_frame_count(ctx, &stream_params, (int *)&min_frame_count)) {

     return CUBEB_ERROR;

   }

   stm = calloc(1, sizeof(*stm));

   assert(stm);

   stm->context = ctx;

   stm->data_callback = data_callback;

   stm->state_callback = state_callback;

   stm->user_ptr = user_ptr;

   stm->params = stream_params;

   stm->instance = calloc(SIZE_AUDIOTRACK_INSTANCE, 1);

   (*(uint32_t*)((intptr_t)stm->instance + SIZE_AUDIOTRACK_INSTANCE - 4)) = 0xbaadbaad;

   assert(stm->instance && "cubeb: EOM");

   /* gingerbread uses old channel layout enum */

   if (audiotrack_version_is_froyo(ctx) || audiotrack_version_is_gingerbread(ctx)) {

     channels = stm->params.channels == 2 ? AUDIO_CHANNEL_OUT_STEREO_Legacy : AUDIO_CHANNEL_OUT_MONO_Legacy;

   } else {

     channels = stm->params.channels == 2 ? AUDIO_CHANNEL_OUT_STEREO_ICS : AUDIO_CHANNEL_OUT_MONO_ICS;

   }

   if (audiotrack_version_is_froyo(ctx)) {

     ctx->klass.ctor_froyo(stm->instance,

                           stm->params.stream_type,

                           stm->params.rate,

                           AUDIO_FORMAT_PCM_16_BIT,

                           channels,

                           min_frame_count,

                           0,

                           audiotrack_refill,

                           stm,

                           0);

   } else {

     ctx->klass.ctor(stm->instance,

                     stm->params.stream_type,

                     stm->params.rate,

                     AUDIO_FORMAT_PCM_16_BIT,

                     channels,

                     min_frame_count,

                     0,

                     audiotrack_refill,

                     stm,

                     0,

                     0);

   }

   assert((*(uint32_t*)((intptr_t)stm->instance + SIZE_AUDIOTRACK_INSTANCE - 4)) == 0xbaadbaad);

   if (ctx->klass.check(stm->instance)) {

     ALOG("stream not initialized properly.");

     audiotrack_stream_destroy(stm);

     return CUBEB_ERROR;

   }

   *stream = stm;

   return CUBEB_OK;

 }

 void

 audiotrack_stream_destroy(cubeb_stream * stream)

 {

   assert(stream->context);

   stream->context->klass.dtor(stream->instance);

   free(stream->instance);

   stream->instance = NULL;

   free(stream);

 }

 int

 audiotrack_stream_start(cubeb_stream * stream)

 {

   assert(stream->instance);

   stream->context->klass.start(stream->instance);

   stream->state_callback(stream, stream->user_ptr, CUBEB_STATE_STARTED);

   return CUBEB_OK;

 }

 int

 audiotrack_stream_stop(cubeb_stream * stream)

 {

   assert(stream->instance);

   stream->context->klass.pause(stream->instance);

   stream->state_callback(stream, stream->user_ptr, CUBEB_STATE_STOPPED);

   return CUBEB_OK;

 }

 int

 audiotrack_stream_get_position(cubeb_stream * stream, uint64_t * position)

 {

   uint32_t p;

   assert(stream->instance && position);

   stream->context->klass.get_position(stream->instance, &p);

   *position = p;

   return CUBEB_OK;

 }

 int

 audiotrack_stream_get_latency(cubeb_stream * stream, uint32_t * latency)

 {

   assert(stream->instance && latency);

   /* Android returns the latency in ms, we want it in frames. */

   *latency = stream->context->klass.latency(stream->instance);

   /* with rate <= 96000, we won't overflow until 44.739 seconds of latency */

   *latency = (*latency * stream->params.rate) / 1000;

   return 0;

 }

 static struct cubeb_ops const audiotrack_ops = {

   .init = audiotrack_init,

   .get_backend_id = audiotrack_get_backend_id,

   .get_max_channel_count = audiotrack_get_max_channel_count,

   .get_min_latency = audiotrack_get_min_latency,

   .get_preferred_sample_rate = audiotrack_get_preferred_sample_rate,

   .destroy = audiotrack_destroy,

   .stream_init = audiotrack_stream_init,

   .stream_destroy = audiotrack_stream_destroy,

   .stream_start = audiotrack_stream_start,

   .stream_stop = audiotrack_stream_stop,

   .stream_get_position = audiotrack_stream_get_position,

   .stream_get_latency = audiotrack_stream_get_latency

 };