git.sesse.net Git - vlc/blob - modules/audio_output/opensles_android.c

   1 /*****************************************************************************
   2  * opensles_android.c : audio output for android native code
   3  *****************************************************************************
   4  * Copyright © 2011-2012 VideoLAN
   5  *
   6  * Authors: Dominique Martinet <asmadeus@codewreck.org>
   7  *          Hugo Beauzée-Luyssen <beauze.h@gmail.com>
   8  *          Rafaël Carré <funman@videolanorg>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32
  33 #include <vlc_common.h>
  34 #include <vlc_plugin.h>
  35 #include <vlc_aout.h>
  36 #include <assert.h>
  37 #include <dlfcn.h>
  38 #include <math.h>
  39
  40 // For native audio
  41 #include <SLES/OpenSLES.h>
  42 #include <SLES/OpenSLES_Android.h>
  43
  44 #define OPENSLES_BUFFERS 255 /* maximum number of buffers */
  45 #define OPENSLES_BUFLEN  10   /* ms */
  46 /*
  47  * 10ms of precision when mesasuring latency should be enough,
  48  * with 255 buffers we can buffer 2.55s of audio.
  49  */
  50
  51 #define CHECK_OPENSL_ERROR(msg)                \
  52     if (unlikely(result != SL_RESULT_SUCCESS)) \
  53     {                                          \
  54         msg_Err(aout, msg" (%lu)", result);    \
  55         goto error;                            \
  56     }
  57
  58 typedef SLresult (*slCreateEngine_t)(
  59         SLObjectItf*, SLuint32, const SLEngineOption*, SLuint32,
  60         const SLInterfaceID*, const SLboolean*);
  61
  62 #define Destroy(a) (*a)->Destroy(a);
  63 #define SetPlayState(a, b) (*a)->SetPlayState(a, b)
  64 #define RegisterCallback(a, b, c) (*a)->RegisterCallback(a, b, c)
  65 #define GetInterface(a, b, c) (*a)->GetInterface(a, b, c)
  66 #define Realize(a, b) (*a)->Realize(a, b)
  67 #define CreateOutputMix(a, b, c, d, e) (*a)->CreateOutputMix(a, b, c, d, e)
  68 #define CreateAudioPlayer(a, b, c, d, e, f, g) \
  69     (*a)->CreateAudioPlayer(a, b, c, d, e, f, g)
  70 #define Enqueue(a, b, c) (*a)->Enqueue(a, b, c)
  71 #define Clear(a) (*a)->Clear(a)
  72 #define GetState(a, b) (*a)->GetState(a, b)
  73 #define SetPositionUpdatePeriod(a, b) (*a)->SetPositionUpdatePeriod(a, b)
  74 #define SetVolumeLevel(a, b) (*a)->SetVolumeLevel(a, b)
  75 #define SetMute(a, b) (*a)->SetMute(a, b)
  76
  77 /*****************************************************************************
  78  *
  79  *****************************************************************************/
  80 struct aout_sys_t
  81 {
  82     /* OpenSL objects */
  83     SLObjectItf                     engineObject;
  84     SLObjectItf                     outputMixObject;
  85     SLAndroidSimpleBufferQueueItf   playerBufferQueue;
  86     SLObjectItf                     playerObject;
  87     SLVolumeItf                     volumeItf;
  88     SLEngineItf                     engineEngine;
  89     SLPlayItf                       playerPlay;
  90
  91     /* OpenSL symbols */
  92     void                           *p_so_handle;
  93
  94     slCreateEngine_t                slCreateEnginePtr;
  95     SLInterfaceID                   SL_IID_ENGINE;
  96     SLInterfaceID                   SL_IID_ANDROIDSIMPLEBUFFERQUEUE;
  97     SLInterfaceID                   SL_IID_VOLUME;
  98     SLInterfaceID                   SL_IID_PLAY;
  99
 100     /* */
 101
 102     vlc_mutex_t                     lock;
 103
 104     /* audio buffered through opensles */
 105     uint8_t                        *buf;
 106     size_t                          samples_per_buf;
 107     int                             next_buf;
 108
 109     int                             rate;
 110
 111     /* if we can measure latency already */
 112     bool                            started;
 113
 114     /* audio not yet buffered through opensles */
 115     block_t                        *p_buffer_chain;
 116     block_t                       **pp_buffer_last;
 117     size_t                          samples;
 118 };
 119
 120 /*****************************************************************************
 121  * Local prototypes.
 122  *****************************************************************************/
 123 static int  Open  (vlc_object_t *);
 124 static void Close (vlc_object_t *);
 125
 126 /*****************************************************************************
 127  * Module descriptor
 128  *****************************************************************************/
 129
 130 vlc_module_begin ()
 131     set_description(N_("OpenSLES audio output"))
 132     set_shortname(N_("OpenSLES"))
 133     set_category(CAT_AUDIO)
 134     set_subcategory(SUBCAT_AUDIO_AOUT)
 135
 136     set_capability("audio output", 170)
 137     add_shortcut("opensles", "android")
 138     set_callbacks(Open, Close)
 139 vlc_module_end ()
 140
 141 /*****************************************************************************
 142  *
 143  *****************************************************************************/
 144
 145 static inline int bytesPerSample(void)
 146 {
 147     return 2 /* S16 */ * 2 /* stereo */;
 148 }
 149
 150 static int TimeGet(audio_output_t* aout, mtime_t* restrict drift)
 151 {
 152     aout_sys_t *sys = aout->sys;
 153
 154     SLAndroidSimpleBufferQueueState st;
 155     SLresult res = GetState(sys->playerBufferQueue, &st);
 156     if (unlikely(res != SL_RESULT_SUCCESS)) {
 157         msg_Err(aout, "Could not query buffer queue state in TimeGet (%lu)", res);
 158         return -1;
 159     }
 160
 161     vlc_mutex_lock(&sys->lock);
 162     bool started = sys->started;
 163     vlc_mutex_unlock(&sys->lock);
 164
 165     if (!started)
 166         return -1;
 167
 168     *drift = (CLOCK_FREQ * OPENSLES_BUFLEN * st.count / 1000)
 169         + sys->samples * CLOCK_FREQ / sys->rate;
 170
 171     msg_Dbg(aout, "latency %"PRId64" ms, %d/%d buffers", *drift / 1000,
 172         (int)st.count, OPENSLES_BUFFERS);
 173
 174     return 0;
 175 }
 176
 177 static void Flush(audio_output_t *aout, bool drain)
 178 {
 179     aout_sys_t *sys = aout->sys;
 180
 181     if (drain) {
 182         mtime_t delay;
 183         if (!TimeGet(aout, &delay))
 184             msleep(delay);
 185     } else {
 186         vlc_mutex_lock(&sys->lock);
 187         SetPlayState(sys->playerPlay, SL_PLAYSTATE_STOPPED);
 188         Clear(sys->playerBufferQueue);
 189         SetPlayState(sys->playerPlay, SL_PLAYSTATE_PLAYING);
 190
 191         /* release audio data not yet written to opensles */
 192         block_ChainRelease(sys->p_buffer_chain);
 193         sys->p_buffer_chain = NULL;
 194         sys->pp_buffer_last = &sys->p_buffer_chain;
 195
 196         sys->samples = 0;
 197         sys->started = false;
 198
 199         vlc_mutex_unlock(&sys->lock);
 200     }
 201 }
 202
 203 static int VolumeSet(audio_output_t *aout, float vol)
 204 {
 205     if (!aout->sys->volumeItf)
 206         return -1;
 207
 208     /* Convert UI volume to linear factor (cube) */
 209     vol = vol * vol * vol;
 210
 211     /* millibels from linear amplification */
 212     int mb = lroundf(2000.f * log10f(vol));
 213     if (mb < SL_MILLIBEL_MIN)
 214         mb = SL_MILLIBEL_MIN;
 215     else if (mb > 0)
 216         mb = 0; /* maximum supported level could be higher: GetMaxVolumeLevel */
 217
 218     SLresult r = SetVolumeLevel(aout->sys->volumeItf, mb);
 219     return (r == SL_RESULT_SUCCESS) ? 0 : -1;
 220 }
 221
 222 static int MuteSet(audio_output_t *aout, bool mute)
 223 {
 224     if (!aout->sys->volumeItf)
 225         return -1;
 226
 227     SLresult r = SetMute(aout->sys->volumeItf, mute);
 228     return (r == SL_RESULT_SUCCESS) ? 0 : -1;
 229 }
 230
 231 static void Pause(audio_output_t *aout, bool pause, mtime_t date)
 232 {
 233     (void)date;
 234     aout_sys_t *sys = aout->sys;
 235     SetPlayState(sys->playerPlay,
 236         pause ? SL_PLAYSTATE_PAUSED : SL_PLAYSTATE_PLAYING);
 237 }
 238
 239 static int WriteBuffer(audio_output_t *aout)
 240 {
 241     aout_sys_t *sys = aout->sys;
 242     const size_t unit_size = sys->samples_per_buf * bytesPerSample();
 243
 244     block_t *b = sys->p_buffer_chain;
 245     if (!b)
 246         return false;
 247
 248     /* Check if we can fill at least one buffer unit by chaining blocks */
 249     if (b->i_buffer < unit_size) {
 250         if (!b->p_next)
 251             return false;
 252         ssize_t needed = unit_size - b->i_buffer;
 253         for (block_t *next = b->p_next; next; next = next->p_next) {
 254             needed -= next->i_buffer;
 255             if (needed <= 0)
 256                 break;
 257         }
 258
 259         if (needed > 0)
 260             return false;
 261     }
 262
 263     SLAndroidSimpleBufferQueueState st;
 264     SLresult res = GetState(sys->playerBufferQueue, &st);
 265     if (unlikely(res != SL_RESULT_SUCCESS)) {
 266         msg_Err(aout, "Could not query buffer queue state in %s (%lu)", __func__, res);
 267         return false;
 268     }
 269
 270     if (st.count == OPENSLES_BUFFERS)
 271         return false;
 272
 273     size_t done = 0;
 274     while (done < unit_size) {
 275         size_t cur = b->i_buffer;
 276         if (cur > unit_size - done)
 277             cur = unit_size - done;
 278
 279         memcpy(&sys->buf[unit_size * sys->next_buf + done], b->p_buffer, cur);
 280         b->i_buffer -= cur;
 281         b->p_buffer += cur;
 282         done += cur;
 283
 284         block_t *next = b->p_next;
 285         if (b->i_buffer == 0) {
 286             block_Release(b);
 287             b = NULL;
 288         }
 289
 290         if (done == unit_size)
 291             break;
 292         else
 293             b = next;
 294     }
 295
 296     sys->p_buffer_chain = b;
 297     if (!b)
 298         sys->pp_buffer_last = &sys->p_buffer_chain;
 299
 300     SLresult r = Enqueue(sys->playerBufferQueue,
 301         &sys->buf[unit_size * sys->next_buf], unit_size);
 302
 303     sys->samples -= sys->samples_per_buf;
 304
 305     if (r == SL_RESULT_SUCCESS) {
 306         if (++sys->next_buf == OPENSLES_BUFFERS)
 307             sys->next_buf = 0;
 308         return true;
 309     } else {
 310         /* XXX : if writing fails, we don't retry */
 311         msg_Err(aout, "error %lu when writing %d bytes %s",
 312                 r, b->i_buffer,
 313                 (r == SL_RESULT_BUFFER_INSUFFICIENT) ? " (buffer insufficient)" : "");
 314         return false;
 315     }
 316 }
 317
 318 /*****************************************************************************
 319  * Play: play a sound
 320  *****************************************************************************/
 321 static void Play(audio_output_t *aout, block_t *p_buffer)
 322 {
 323     aout_sys_t *sys = aout->sys;
 324
 325     p_buffer->p_next = NULL; /* Make sur our linked list doesn't use old references */
 326     vlc_mutex_lock(&sys->lock);
 327
 328     sys->samples += p_buffer->i_buffer / bytesPerSample();
 329
 330     /* Hold this block until we can write it into the OpenSL buffer */
 331     block_ChainLastAppend(&sys->pp_buffer_last, p_buffer);
 332
 333     /* Fill OpenSL buffer */
 334     while (WriteBuffer(aout))
 335         ;
 336
 337     vlc_mutex_unlock(&sys->lock);
 338 }
 339
 340 static void PlayedCallback (SLAndroidSimpleBufferQueueItf caller, void *pContext)
 341 {
 342     (void)caller;
 343     audio_output_t *aout = pContext;
 344     aout_sys_t *sys = aout->sys;
 345
 346     assert (caller == sys->playerBufferQueue);
 347
 348     vlc_mutex_lock(&sys->lock);
 349     sys->started = true;
 350     vlc_mutex_unlock(&sys->lock);
 351 }
 352 /*****************************************************************************
 353  *
 354  *****************************************************************************/
 355 static void Clean(aout_sys_t *sys)
 356 {
 357     if (sys->playerObject)
 358         Destroy(sys->playerObject);
 359     if (sys->outputMixObject)
 360         Destroy(sys->outputMixObject);
 361     if (sys->engineObject)
 362         Destroy(sys->engineObject);
 363 }
 364
 365 static int Start(audio_output_t *aout, audio_sample_format_t *restrict fmt)
 366 {
 367     SLresult       result;
 368
 369     aout_sys_t *sys = aout->sys;
 370
 371     // configure audio source - this defines the number of samples you can enqueue.
 372     SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {
 373         SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE,
 374         OPENSLES_BUFFERS
 375     };
 376
 377     SLDataFormat_PCM format_pcm;
 378     format_pcm.formatType       = SL_DATAFORMAT_PCM;
 379     format_pcm.numChannels      = 2;
 380     format_pcm.samplesPerSec    = ((SLuint32) fmt->i_rate * 1000) ;
 381     format_pcm.bitsPerSample    = SL_PCMSAMPLEFORMAT_FIXED_16;
 382     format_pcm.containerSize    = SL_PCMSAMPLEFORMAT_FIXED_16;
 383     format_pcm.channelMask      = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
 384     format_pcm.endianness       = SL_BYTEORDER_LITTLEENDIAN;
 385
 386     SLDataSource audioSrc = {&loc_bufq, &format_pcm};
 387
 388     // configure audio sink
 389     SLDataLocator_OutputMix loc_outmix = {
 390         SL_DATALOCATOR_OUTPUTMIX,
 391         sys->outputMixObject
 392     };
 393     SLDataSink audioSnk = {&loc_outmix, NULL};
 394
 395     //create audio player
 396     const SLInterfaceID ids2[] = { sys->SL_IID_ANDROIDSIMPLEBUFFERQUEUE, sys->SL_IID_VOLUME };
 397     static const SLboolean req2[] = { SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE };
 398     result = CreateAudioPlayer(sys->engineEngine, &sys->playerObject, &audioSrc,
 399                                     &audioSnk, sizeof(ids2) / sizeof(*ids2),
 400                                     ids2, req2);
 401     CHECK_OPENSL_ERROR("Failed to create audio player");
 402
 403     result = Realize(sys->playerObject, SL_BOOLEAN_FALSE);
 404     CHECK_OPENSL_ERROR("Failed to realize player object.");
 405
 406     result = GetInterface(sys->playerObject, sys->SL_IID_PLAY, &sys->playerPlay);
 407     CHECK_OPENSL_ERROR("Failed to get player interface.");
 408
 409     result = GetInterface(sys->playerObject, sys->SL_IID_VOLUME, &sys->volumeItf);
 410     CHECK_OPENSL_ERROR("failed to get volume interface.");
 411
 412     result = GetInterface(sys->playerObject, sys->SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
 413                                                   &sys->playerBufferQueue);
 414     CHECK_OPENSL_ERROR("Failed to get buff queue interface");
 415
 416     result = RegisterCallback(sys->playerBufferQueue, PlayedCallback,
 417                                    (void*)aout);
 418     CHECK_OPENSL_ERROR("Failed to register buff queue callback.");
 419
 420     // set the player's state to playing
 421     result = SetPlayState(sys->playerPlay, SL_PLAYSTATE_PLAYING);
 422     CHECK_OPENSL_ERROR("Failed to switch to playing state");
 423
 424     /* XXX: rounding shouldn't affect us at normal sampling rate */
 425     sys->rate = fmt->i_rate;
 426     sys->samples_per_buf = OPENSLES_BUFLEN * fmt->i_rate / 1000;
 427     sys->buf = malloc(OPENSLES_BUFFERS * sys->samples_per_buf * bytesPerSample());
 428     if (!sys->buf)
 429         goto error;
 430
 431     sys->started = false;
 432     sys->next_buf = 0;
 433
 434     sys->p_buffer_chain = NULL;
 435     sys->pp_buffer_last = &sys->p_buffer_chain;
 436     sys->samples = 0;
 437
 438     // we want 16bit signed data native endian.
 439     fmt->i_format              = VLC_CODEC_S16N;
 440     fmt->i_physical_channels   = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
 441
 442     SetPositionUpdatePeriod(sys->playerPlay, AOUT_MIN_PREPARE_TIME * 1000 / CLOCK_FREQ);
 443
 444     aout_FormatPrepare(fmt);
 445
 446     return VLC_SUCCESS;
 447
 448 error:
 449     Clean(sys);
 450     return VLC_EGENERIC;
 451 }
 452
 453 static void Stop(audio_output_t *aout)
 454 {
 455     aout_sys_t *sys = aout->sys;
 456
 457     SetPlayState(sys->playerPlay, SL_PLAYSTATE_STOPPED);
 458     //Flush remaining buffers if any.
 459     Clear(sys->playerBufferQueue);
 460
 461     free(sys->buf);
 462     block_ChainRelease(sys->p_buffer_chain);
 463 }
 464
 465 /*****************************************************************************
 466  *
 467  *****************************************************************************/
 468 static void Close(vlc_object_t *obj)
 469 {
 470     audio_output_t *aout = (audio_output_t *)obj;
 471     aout_sys_t *sys = aout->sys;
 472
 473     Clean(sys);
 474     dlclose(sys->p_so_handle);
 475     vlc_mutex_destroy(&sys->lock);
 476     free(sys);
 477 }
 478
 479 static int Open (vlc_object_t *obj)
 480 {
 481     audio_output_t *aout = (audio_output_t *)obj;
 482     aout_sys_t *sys;
 483     SLresult result;
 484
 485     aout->sys = sys = calloc(1, sizeof(*sys));
 486     if (unlikely(sys == NULL))
 487         return VLC_ENOMEM;
 488
 489     sys->p_so_handle = dlopen("libOpenSLES.so", RTLD_NOW);
 490     if (sys->p_so_handle == NULL)
 491     {
 492         msg_Err(aout, "Failed to load libOpenSLES");
 493         goto error;
 494     }
 495
 496     sys->slCreateEnginePtr = dlsym(sys->p_so_handle, "slCreateEngine");
 497     if (unlikely(sys->slCreateEnginePtr == NULL))
 498     {
 499         msg_Err(aout, "Failed to load symbol slCreateEngine");
 500         goto error;
 501     }
 502
 503 #define OPENSL_DLSYM(dest, name)                       \
 504     do {                                                       \
 505         const SLInterfaceID *sym = dlsym(sys->p_so_handle, "SL_IID_"name);        \
 506         if (unlikely(sym == NULL))                             \
 507         {                                                      \
 508             msg_Err(aout, "Failed to load symbol SL_IID_"name); \
 509             goto error;                                        \
 510         }                                                      \
 511         sys->dest = *sym;                                           \
 512     } while(0)
 513
 514     OPENSL_DLSYM(SL_IID_ANDROIDSIMPLEBUFFERQUEUE, "ANDROIDSIMPLEBUFFERQUEUE");
 515     OPENSL_DLSYM(SL_IID_ENGINE, "ENGINE");
 516     OPENSL_DLSYM(SL_IID_PLAY, "PLAY");
 517     OPENSL_DLSYM(SL_IID_VOLUME, "VOLUME");
 518 #undef OPENSL_DLSYM
 519
 520     // create engine
 521     result = sys->slCreateEnginePtr(&sys->engineObject, 0, NULL, 0, NULL, NULL);
 522     CHECK_OPENSL_ERROR("Failed to create engine");
 523
 524     // realize the engine in synchronous mode
 525     result = Realize(sys->engineObject, SL_BOOLEAN_FALSE);
 526     CHECK_OPENSL_ERROR("Failed to realize engine");
 527
 528     // get the engine interface, needed to create other objects
 529     result = GetInterface(sys->engineObject, sys->SL_IID_ENGINE, &sys->engineEngine);
 530     CHECK_OPENSL_ERROR("Failed to get the engine interface");
 531
 532     // create output mix, with environmental reverb specified as a non-required interface
 533     const SLInterfaceID ids1[] = { sys->SL_IID_VOLUME };
 534     const SLboolean req1[] = { SL_BOOLEAN_FALSE };
 535     result = CreateOutputMix(sys->engineEngine, &sys->outputMixObject, 1, ids1, req1);
 536     CHECK_OPENSL_ERROR("Failed to create output mix");
 537
 538     // realize the output mix in synchronous mode
 539     result = Realize(sys->outputMixObject, SL_BOOLEAN_FALSE);
 540     CHECK_OPENSL_ERROR("Failed to realize output mix");
 541
 542     vlc_mutex_init(&sys->lock);
 543
 544     aout->start      = Start;
 545     aout->stop       = Stop;
 546     aout->time_get   = TimeGet;
 547     aout->play       = Play;
 548     aout->pause      = Pause;
 549     aout->flush      = Flush;
 550     aout->mute_set   = MuteSet;
 551     aout->volume_set = VolumeSet;
 552
 553     return VLC_SUCCESS;
 554
 555 error:
 556     Clean(sys);
 557     if (sys->p_so_handle)
 558         dlclose(sys->p_so_handle);
 559     free(sys);
 560     return VLC_EGENERIC;
 561 }