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     /* Convert UI volume to linear factor (cube) */
 206     vol = vol * vol * vol;
 207
 208     /* millibels from linear amplification */
 209     int mb = lroundf(2000.f * log10f(vol));
 210     if (mb < SL_MILLIBEL_MIN)
 211         mb = SL_MILLIBEL_MIN;
 212     else if (mb > 0)
 213         mb = 0; /* maximum supported level could be higher: GetMaxVolumeLevel */
 214
 215     SLresult r = SetVolumeLevel(aout->sys->volumeItf, mb);
 216     return (r == SL_RESULT_SUCCESS) ? 0 : -1;
 217 }
 218
 219 static int MuteSet(audio_output_t *aout, bool mute)
 220 {
 221     SLresult r = SetMute(aout->sys->volumeItf, mute);
 222     return (r == SL_RESULT_SUCCESS) ? 0 : -1;
 223 }
 224
 225 static void Pause(audio_output_t *aout, bool pause, mtime_t date)
 226 {
 227     (void)date;
 228     aout_sys_t *sys = aout->sys;
 229     SetPlayState(sys->playerPlay,
 230         pause ? SL_PLAYSTATE_PAUSED : SL_PLAYSTATE_PLAYING);
 231 }
 232
 233 static int WriteBuffer(audio_output_t *aout)
 234 {
 235     aout_sys_t *sys = aout->sys;
 236     const size_t unit_size = sys->samples_per_buf * bytesPerSample();
 237
 238     block_t *b = sys->p_buffer_chain;
 239     if (!b)
 240         return false;
 241
 242     /* Check if we can fill at least one buffer unit by chaining blocks */
 243     if (b->i_buffer < unit_size) {
 244         if (!b->p_next)
 245             return false;
 246         ssize_t needed = unit_size - b->i_buffer;
 247         for (block_t *next = b->p_next; next; next = next->p_next) {
 248             needed -= next->i_buffer;
 249             if (needed <= 0)
 250                 break;
 251         }
 252
 253         if (needed > 0)
 254             return false;
 255     }
 256
 257     SLAndroidSimpleBufferQueueState st;
 258     SLresult res = GetState(sys->playerBufferQueue, &st);
 259     if (unlikely(res != SL_RESULT_SUCCESS)) {
 260         msg_Err(aout, "Could not query buffer queue state in %s (%lu)", __func__, res);
 261         return false;
 262     }
 263
 264     if (st.count == OPENSLES_BUFFERS)
 265         return false;
 266
 267     size_t done = 0;
 268     while (done < unit_size) {
 269         size_t cur = b->i_buffer;
 270         if (cur > unit_size - done)
 271             cur = unit_size - done;
 272
 273         memcpy(&sys->buf[unit_size * sys->next_buf + done], b->p_buffer, cur);
 274         b->i_buffer -= cur;
 275         b->p_buffer += cur;
 276         done += cur;
 277
 278         block_t *next = b->p_next;
 279         if (b->i_buffer == 0) {
 280             block_Release(b);
 281             b = NULL;
 282         }
 283
 284         if (done == unit_size)
 285             break;
 286         else
 287             b = next;
 288     }
 289
 290     sys->p_buffer_chain = b;
 291     if (!b)
 292         sys->pp_buffer_last = &sys->p_buffer_chain;
 293
 294     SLresult r = Enqueue(sys->playerBufferQueue,
 295         &sys->buf[unit_size * sys->next_buf], unit_size);
 296
 297     sys->samples -= sys->samples_per_buf;
 298
 299     if (r == SL_RESULT_SUCCESS) {
 300         if (++sys->next_buf == OPENSLES_BUFFERS)
 301             sys->next_buf = 0;
 302         return true;
 303     } else {
 304         /* XXX : if writing fails, we don't retry */
 305         msg_Err(aout, "error %lu when writing %d bytes %s",
 306                 r, b->i_buffer,
 307                 (r == SL_RESULT_BUFFER_INSUFFICIENT) ? " (buffer insufficient)" : "");
 308         return false;
 309     }
 310 }
 311
 312 /*****************************************************************************
 313  * Play: play a sound
 314  *****************************************************************************/
 315 static void Play(audio_output_t *aout, block_t *p_buffer)
 316 {
 317     aout_sys_t *sys = aout->sys;
 318
 319     p_buffer->p_next = NULL; /* Make sur our linked list doesn't use old references */
 320     vlc_mutex_lock(&sys->lock);
 321
 322     sys->samples += p_buffer->i_buffer / bytesPerSample();
 323
 324     /* Hold this block until we can write it into the OpenSL buffer */
 325     block_ChainLastAppend(&sys->pp_buffer_last, p_buffer);
 326
 327     /* Fill OpenSL buffer */
 328     while (WriteBuffer(aout))
 329         ;
 330
 331     vlc_mutex_unlock(&sys->lock);
 332 }
 333
 334 static void PlayedCallback (SLAndroidSimpleBufferQueueItf caller, void *pContext)
 335 {
 336     (void)caller;
 337     audio_output_t *aout = pContext;
 338     aout_sys_t *sys = aout->sys;
 339
 340     assert (caller == sys->playerBufferQueue);
 341
 342     vlc_mutex_lock(&sys->lock);
 343     sys->started = true;
 344     vlc_mutex_unlock(&sys->lock);
 345 }
 346 /*****************************************************************************
 347  *
 348  *****************************************************************************/
 349 static void Clean(aout_sys_t *sys)
 350 {
 351     if (sys->playerObject)
 352         Destroy(sys->playerObject);
 353     if (sys->outputMixObject)
 354         Destroy(sys->outputMixObject);
 355     if (sys->engineObject)
 356         Destroy(sys->engineObject);
 357 }
 358
 359 static int Start(audio_output_t *aout, audio_sample_format_t *restrict fmt)
 360 {
 361     SLresult       result;
 362
 363     aout_sys_t *sys = aout->sys;
 364
 365     // configure audio source - this defines the number of samples you can enqueue.
 366     SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {
 367         SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE,
 368         OPENSLES_BUFFERS
 369     };
 370
 371     SLDataFormat_PCM format_pcm;
 372     format_pcm.formatType       = SL_DATAFORMAT_PCM;
 373     format_pcm.numChannels      = 2;
 374     format_pcm.samplesPerSec    = ((SLuint32) fmt->i_rate * 1000) ;
 375     format_pcm.bitsPerSample    = SL_PCMSAMPLEFORMAT_FIXED_16;
 376     format_pcm.containerSize    = SL_PCMSAMPLEFORMAT_FIXED_16;
 377     format_pcm.channelMask      = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
 378     format_pcm.endianness       = SL_BYTEORDER_LITTLEENDIAN;
 379
 380     SLDataSource audioSrc = {&loc_bufq, &format_pcm};
 381
 382     // configure audio sink
 383     SLDataLocator_OutputMix loc_outmix = {
 384         SL_DATALOCATOR_OUTPUTMIX,
 385         sys->outputMixObject
 386     };
 387     SLDataSink audioSnk = {&loc_outmix, NULL};
 388
 389     //create audio player
 390     const SLInterfaceID ids2[] = { sys->SL_IID_ANDROIDSIMPLEBUFFERQUEUE, sys->SL_IID_VOLUME };
 391     static const SLboolean req2[] = { SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE };
 392     result = CreateAudioPlayer(sys->engineEngine, &sys->playerObject, &audioSrc,
 393                                     &audioSnk, sizeof(ids2) / sizeof(*ids2),
 394                                     ids2, req2);
 395     CHECK_OPENSL_ERROR("Failed to create audio player");
 396
 397     result = Realize(sys->playerObject, SL_BOOLEAN_FALSE);
 398     CHECK_OPENSL_ERROR("Failed to realize player object.");
 399
 400     result = GetInterface(sys->playerObject, sys->SL_IID_PLAY, &sys->playerPlay);
 401     CHECK_OPENSL_ERROR("Failed to get player interface.");
 402
 403     result = GetInterface(sys->playerObject, sys->SL_IID_VOLUME, &sys->volumeItf);
 404     CHECK_OPENSL_ERROR("failed to get volume interface.");
 405
 406     result = GetInterface(sys->playerObject, sys->SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
 407                                                   &sys->playerBufferQueue);
 408     CHECK_OPENSL_ERROR("Failed to get buff queue interface");
 409
 410     result = RegisterCallback(sys->playerBufferQueue, PlayedCallback,
 411                                    (void*)aout);
 412     CHECK_OPENSL_ERROR("Failed to register buff queue callback.");
 413
 414     // set the player's state to playing
 415     result = SetPlayState(sys->playerPlay, SL_PLAYSTATE_PLAYING);
 416     CHECK_OPENSL_ERROR("Failed to switch to playing state");
 417
 418     /* XXX: rounding shouldn't affect us at normal sampling rate */
 419     sys->rate = fmt->i_rate;
 420     sys->samples_per_buf = OPENSLES_BUFLEN * fmt->i_rate / 1000;
 421     sys->buf = malloc(OPENSLES_BUFFERS * sys->samples_per_buf * bytesPerSample());
 422     if (!sys->buf)
 423         goto error;
 424
 425     sys->started = false;
 426     sys->next_buf = 0;
 427
 428     sys->p_buffer_chain = NULL;
 429     sys->pp_buffer_last = &sys->p_buffer_chain;
 430     sys->samples = 0;
 431
 432     // we want 16bit signed data native endian.
 433     fmt->i_format              = VLC_CODEC_S16N;
 434     fmt->i_physical_channels   = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
 435
 436     SetPositionUpdatePeriod(sys->playerPlay, AOUT_MIN_PREPARE_TIME * 1000 / CLOCK_FREQ);
 437
 438     aout_FormatPrepare(fmt);
 439
 440     return VLC_SUCCESS;
 441
 442 error:
 443     Clean(sys);
 444     return VLC_EGENERIC;
 445 }
 446
 447 static void Stop(audio_output_t *aout)
 448 {
 449     aout_sys_t *sys = aout->sys;
 450
 451     SetPlayState(sys->playerPlay, SL_PLAYSTATE_STOPPED);
 452     //Flush remaining buffers if any.
 453     Clear(sys->playerBufferQueue);
 454
 455     free(sys->buf);
 456     block_ChainRelease(sys->p_buffer_chain);
 457 }
 458
 459 /*****************************************************************************
 460  *
 461  *****************************************************************************/
 462 static void Close(vlc_object_t *obj)
 463 {
 464     audio_output_t *aout = (audio_output_t *)obj;
 465     aout_sys_t *sys = aout->sys;
 466
 467     Clean(sys);
 468     dlclose(sys->p_so_handle);
 469     vlc_mutex_destroy(&sys->lock);
 470     free(sys);
 471 }
 472
 473 static int Open (vlc_object_t *obj)
 474 {
 475     audio_output_t *aout = (audio_output_t *)obj;
 476     aout_sys_t *sys;
 477     SLresult result;
 478
 479     aout->sys = sys = calloc(1, sizeof(*sys));
 480     if (unlikely(sys == NULL))
 481         return VLC_ENOMEM;
 482
 483     sys->p_so_handle = dlopen("libOpenSLES.so", RTLD_NOW);
 484     if (sys->p_so_handle == NULL)
 485     {
 486         msg_Err(aout, "Failed to load libOpenSLES");
 487         goto error;
 488     }
 489
 490     sys->slCreateEnginePtr = dlsym(sys->p_so_handle, "slCreateEngine");
 491     if (unlikely(sys->slCreateEnginePtr == NULL))
 492     {
 493         msg_Err(aout, "Failed to load symbol slCreateEngine");
 494         goto error;
 495     }
 496
 497 #define OPENSL_DLSYM(dest, name)                       \
 498     do {                                                       \
 499         const SLInterfaceID *sym = dlsym(sys->p_so_handle, "SL_IID_"name);        \
 500         if (unlikely(sym == NULL))                             \
 501         {                                                      \
 502             msg_Err(aout, "Failed to load symbol SL_IID_"name); \
 503             goto error;                                        \
 504         }                                                      \
 505         sys->dest = *sym;                                           \
 506     } while(0)
 507
 508     OPENSL_DLSYM(SL_IID_ANDROIDSIMPLEBUFFERQUEUE, "ANDROIDSIMPLEBUFFERQUEUE");
 509     OPENSL_DLSYM(SL_IID_ENGINE, "ENGINE");
 510     OPENSL_DLSYM(SL_IID_PLAY, "PLAY");
 511     OPENSL_DLSYM(SL_IID_VOLUME, "VOLUME");
 512 #undef OPENSL_DLSYM
 513
 514     // create engine
 515     result = sys->slCreateEnginePtr(&sys->engineObject, 0, NULL, 0, NULL, NULL);
 516     CHECK_OPENSL_ERROR("Failed to create engine");
 517
 518     // realize the engine in synchronous mode
 519     result = Realize(sys->engineObject, SL_BOOLEAN_FALSE);
 520     CHECK_OPENSL_ERROR("Failed to realize engine");
 521
 522     // get the engine interface, needed to create other objects
 523     result = GetInterface(sys->engineObject, sys->SL_IID_ENGINE, &sys->engineEngine);
 524     CHECK_OPENSL_ERROR("Failed to get the engine interface");
 525
 526     // create output mix, with environmental reverb specified as a non-required interface
 527     const SLInterfaceID ids1[] = { sys->SL_IID_VOLUME };
 528     const SLboolean req1[] = { SL_BOOLEAN_FALSE };
 529     result = CreateOutputMix(sys->engineEngine, &sys->outputMixObject, 1, ids1, req1);
 530     CHECK_OPENSL_ERROR("Failed to create output mix");
 531
 532     // realize the output mix in synchronous mode
 533     result = Realize(sys->outputMixObject, SL_BOOLEAN_FALSE);
 534     CHECK_OPENSL_ERROR("Failed to realize output mix");
 535
 536     vlc_mutex_init(&sys->lock);
 537
 538     aout->start      = Start;
 539     aout->stop       = Stop;
 540     aout->time_get   = TimeGet;
 541     aout->play       = Play;
 542     aout->pause      = Pause;
 543     aout->flush      = Flush;
 544     aout->mute_set   = MuteSet;
 545     aout->volume_set = VolumeSet;
 546
 547     return VLC_SUCCESS;
 548
 549 error:
 550     Clean(sys);
 551     if (sys->p_so_handle)
 552         dlclose(sys->p_so_handle);
 553     free(sys);
 554     return VLC_EGENERIC;
 555 }