firmware/target/hosted/pcm-alsa.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2010 Thomas Martitz
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22
  23 /*
  24  * Based, but heavily modified, on the example given at
  25  * http://www.alsa-project.org/alsa-doc/alsa-lib/_2test_2pcm_8c-example.html
  26  *
  27  * This driver uses the so-called unsafe async callback method and hardcoded device
  28  * names. It fails when the audio device is busy by other apps.
  29  *
  30  * To make the async callback safer, an alternative stack is installed, since
  31  * it's run from a signal hanlder (which otherwise uses the user stack). If
  32  * tick tasks are run from a signal handler too, please install
  33  * an alternative stack for it too.
  34  *
  35  * TODO: Rewrite this to do it properly with multithreading
  36  *
  37  * Alternatively, a version using polling in a tick task is provided. While
  38  * supposedly safer, it appears to use more CPU (however I didn't measure it
  39  * accurately, only looked at htop). At least, in this mode the "default"
  40  * device works which doesnt break with other apps running.
  41  * device works which doesnt break with other apps running.
  42  */
  43
  44
  45 #include "autoconf.h"
  46
  47 #include <stdlib.h>
  48 #include <stdbool.h>
  49 #include <alsa/asoundlib.h>
  50 #include "system.h"
  51 #include "debug.h"
  52 #include "kernel.h"
  53
  54 #include "pcm.h"
  55 #include "pcm-internal.h"
  56 #include "pcm_mixer.h"
  57 #include "pcm_sampr.h"
  58 #include "audiohw.h"
  59
  60 #include <pthread.h>
  61 #include <signal.h>
  62
  63 #define USE_ASYNC_CALLBACK
  64 /* plughw:0,0 works with both, however "default" is recommended.
  65  * default doesnt seem to work with async callback but doesn't break
  66  * with multple applications running */
  67 static char device[] = "plughw:0,0";                    /* playback device */
  68 static const snd_pcm_access_t access_ = SND_PCM_ACCESS_RW_INTERLEAVED; /* access mode */
  69 static const snd_pcm_format_t format = SND_PCM_FORMAT_S16;    /* sample format */
  70 static const int channels = 2;                                /* count of channels */
  71 static unsigned int rate = 44100;                       /* stream rate */
  72
  73 static snd_pcm_t *handle;
  74 static snd_pcm_sframes_t buffer_size = MIX_FRAME_SAMPLES * 32; /* ~16k */
  75 static snd_pcm_sframes_t period_size = MIX_FRAME_SAMPLES * 4;  /*  ~4k */
  76 static short *frames;
  77
  78 static const void  *pcm_data = 0;
  79 static size_t       pcm_size = 0;
  80
  81 #ifdef USE_ASYNC_CALLBACK
  82 static snd_async_handler_t *ahandler;
  83 static pthread_mutex_t pcm_mtx;
  84 static char signal_stack[SIGSTKSZ];
  85 #else
  86 static int recursion;
  87 #endif
  88
  89 static int set_hwparams(snd_pcm_t *handle, unsigned sample_rate)
  90 {
  91     unsigned int rrate;
  92     int err;
  93     snd_pcm_hw_params_t *params;
  94     snd_pcm_hw_params_malloc(&params);
  95
  96
  97     /* choose all parameters */
  98     err = snd_pcm_hw_params_any(handle, params);
  99     if (err < 0)
 100     {
 101         printf("Broken configuration for playback: no configurations available: %s\n", snd_strerror(err));
 102         goto error;
 103     }
 104     /* set the interleaved read/write format */
 105     err = snd_pcm_hw_params_set_access(handle, params, access_);
 106     if (err < 0)
 107     {
 108         printf("Access type not available for playback: %s\n", snd_strerror(err));
 109         goto error;
 110     }
 111     /* set the sample format */
 112     err = snd_pcm_hw_params_set_format(handle, params, format);
 113     if (err < 0)
 114     {
 115         printf("Sample format not available for playback: %s\n", snd_strerror(err));
 116         goto error;
 117     }
 118     /* set the count of channels */
 119     err = snd_pcm_hw_params_set_channels(handle, params, channels);
 120     if (err < 0)
 121     {
 122         printf("Channels count (%i) not available for playbacks: %s\n", channels, snd_strerror(err));
 123         goto error;
 124     }
 125     /* set the stream rate */
 126     rrate = sample_rate;
 127     err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, 0);
 128     if (err < 0)
 129     {
 130         printf("Rate %iHz not available for playback: %s\n", rate, snd_strerror(err));
 131         goto error;
 132     }
 133     if (rrate != sample_rate)
 134     {
 135         printf("Rate doesn't match (requested %iHz, get %iHz)\n", sample_rate, err);
 136         err = -EINVAL;
 137         goto error;
 138     }
 139
 140     /* set the buffer size */
 141     err = snd_pcm_hw_params_set_buffer_size_near(handle, params, &buffer_size);
 142     if (err < 0)
 143     {
 144         printf("Unable to set buffer size %ld for playback: %s\n", buffer_size, snd_strerror(err));
 145         goto error;
 146     }
 147
 148     /* set the period size */
 149     err = snd_pcm_hw_params_set_period_size_near (handle, params, &period_size, NULL);
 150     if (err < 0)
 151     {
 152         printf("Unable to set period size %ld for playback: %s\n", period_size, snd_strerror(err));
 153         goto error;
 154     }
 155     if (!frames)
 156         frames = malloc(period_size * channels * sizeof(short));
 157
 158     /* write the parameters to device */
 159     err = snd_pcm_hw_params(handle, params);
 160     if (err < 0)
 161     {
 162         printf("Unable to set hw params for playback: %s\n", snd_strerror(err));
 163         goto error;
 164     }
 165
 166     err = 0; /* success */
 167 error:
 168     snd_pcm_hw_params_free(params);
 169     return err;
 170 }
 171
 172 /* Set sw params: playback start threshold and low buffer watermark */
 173 static int set_swparams(snd_pcm_t *handle)
 174 {
 175     int err;
 176
 177     snd_pcm_sw_params_t *swparams;
 178     snd_pcm_sw_params_malloc(&swparams);
 179
 180     /* get the current swparams */
 181     err = snd_pcm_sw_params_current(handle, swparams);
 182     if (err < 0)
 183     {
 184         printf("Unable to determine current swparams for playback: %s\n", snd_strerror(err));
 185         goto error;
 186     }
 187     /* start the transfer when the buffer is haalmost full */
 188     err = snd_pcm_sw_params_set_start_threshold(handle, swparams, buffer_size / 2);
 189     if (err < 0)
 190     {
 191         printf("Unable to set start threshold mode for playback: %s\n", snd_strerror(err));
 192         goto error;
 193     }
 194     /* allow the transfer when at least period_size samples can be processed */
 195     err = snd_pcm_sw_params_set_avail_min(handle, swparams, period_size);
 196     if (err < 0)
 197     {
 198         printf("Unable to set avail min for playback: %s\n", snd_strerror(err));
 199         goto error;
 200     }
 201     /* write the parameters to the playback device */
 202     err = snd_pcm_sw_params(handle, swparams);
 203     if (err < 0)
 204     {
 205         printf("Unable to set sw params for playback: %s\n", snd_strerror(err));
 206         goto error;
 207     }
 208
 209     err = 0; /* success */
 210 error:
 211     snd_pcm_sw_params_free(swparams);
 212     return err;
 213 }
 214
 215 /* copy pcm samples to a spare buffer, suitable for snd_pcm_writei() */
 216 static bool fill_frames(void)
 217 {
 218     ssize_t copy_n, frames_left = period_size;
 219     bool new_buffer = false;
 220
 221     while (frames_left > 0)
 222     {
 223         if (!pcm_size)
 224         {
 225             new_buffer = true;
 226             if (!pcm_play_dma_complete_callback(PCM_DMAST_OK, &pcm_data,
 227                                                 &pcm_size))
 228             {
 229                 return false;
 230             }
 231         }
 232         copy_n = MIN((ssize_t)pcm_size, frames_left*4);
 233         memcpy(&frames[2*(period_size-frames_left)], pcm_data, copy_n);
 234
 235         pcm_data += copy_n;
 236         pcm_size -= copy_n;
 237         frames_left -= copy_n/4;
 238
 239         if (new_buffer)
 240         {
 241             new_buffer = false;
 242             pcm_play_dma_status_callback(PCM_DMAST_STARTED);
 243         }
 244     }
 245     return true;
 246 }
 247
 248 #ifdef USE_ASYNC_CALLBACK
 249 static void async_callback(snd_async_handler_t *ahandler)
 250 {
 251     snd_pcm_t *handle = snd_async_handler_get_pcm(ahandler);
 252
 253     if (pthread_mutex_trylock(&pcm_mtx) != 0)
 254         return;
 255 #else
 256 static void pcm_tick(void)
 257 {
 258     if (snd_pcm_state(handle) != SND_PCM_STATE_RUNNING)
 259         return;
 260 #endif
 261
 262     while (snd_pcm_avail_update(handle) >= period_size)
 263     {
 264         if (fill_frames())
 265         {
 266             int err = snd_pcm_writei(handle, frames, period_size);
 267             if (err < 0 && err != period_size && err != -EAGAIN)
 268             {
 269                 printf("Write error: written %i expected %li\n", err, period_size);
 270                 break;
 271             }
 272         }
 273         else
 274         {
 275             DEBUGF("%s: No Data.\n", __func__);
 276             break;
 277         }
 278     }
 279 #ifdef USE_ASYNC_CALLBACK
 280     pthread_mutex_unlock(&pcm_mtx);
 281 #endif
 282 }
 283
 284 static int async_rw(snd_pcm_t *handle)
 285 {
 286     int err;
 287     snd_pcm_sframes_t sample_size;
 288     short *samples;
 289
 290 #ifdef USE_ASYNC_CALLBACK
 291     /* assign alternative stack for the signal handlers */
 292     stack_t ss = {
 293         .ss_sp = signal_stack,
 294         .ss_size = sizeof(signal_stack),
 295         .ss_flags = 0
 296     };
 297     struct sigaction sa;
 298
 299     err = sigaltstack(&ss, NULL);
 300     if (err < 0)
 301     {
 302         DEBUGF("Unable to install alternative signal stack: %s", strerror(err));
 303         return err;
 304     }
 305
 306     err = snd_async_add_pcm_handler(&ahandler, handle, async_callback, NULL);
 307     if (err < 0)
 308     {
 309         DEBUGF("Unable to register async handler: %s\n", snd_strerror(err));
 310         return err;
 311     }
 312
 313     /* only modify the stack the handler runs on */
 314     sigaction(SIGIO, NULL, &sa);
 315     sa.sa_flags |= SA_ONSTACK;
 316     err = sigaction(SIGIO, &sa, NULL);
 317     if (err < 0)
 318     {
 319         DEBUGF("Unable to install alternative signal stack: %s", strerror(err));
 320         return err;
 321     }
 322 #endif
 323
 324     /* fill buffer with silence to initiate playback without noisy click */
 325     sample_size = buffer_size;
 326     samples = malloc(sample_size * channels * sizeof(short));
 327
 328     snd_pcm_format_set_silence(format, samples, sample_size);
 329     err = snd_pcm_writei(handle, samples, sample_size);
 330     free(samples);
 331
 332     if (err < 0)
 333     {
 334             DEBUGF("Initial write error: %s\n", snd_strerror(err));
 335             return err;
 336     }
 337     if (err != (ssize_t)sample_size)
 338     {
 339             DEBUGF("Initial write error: written %i expected %li\n", err, sample_size);
 340             return err;
 341     }
 342     if (snd_pcm_state(handle) == SND_PCM_STATE_PREPARED)
 343     {
 344             err = snd_pcm_start(handle);
 345             if (err < 0)
 346             {
 347                 DEBUGF("Start error: %s\n", snd_strerror(err));
 348                 return err;
 349             }
 350     }
 351     return 0;
 352 }
 353
 354
 355 void cleanup(void)
 356 {
 357     free(frames);
 358     frames = NULL;
 359     snd_pcm_close(handle);
 360 }
 361
 362
 363 void pcm_play_dma_init(void)
 364 {
 365     int err;
 366     audiohw_preinit();
 367
 368     if ((err = snd_pcm_open(&handle, device, SND_PCM_STREAM_PLAYBACK, 0)) < 0)
 369     {
 370         printf("%s(): Cannot open device %s: %s\n", __func__, device, snd_strerror(err));
 371         exit(EXIT_FAILURE);
 372         return;
 373     }
 374
 375     if ((err = snd_pcm_nonblock(handle, 1)))
 376         printf("Could not set non-block mode: %s\n", snd_strerror(err));
 377
 378     if ((err = set_hwparams(handle, rate)) < 0)
 379     {
 380         printf("Setting of hwparams failed: %s\n", snd_strerror(err));
 381         exit(EXIT_FAILURE);
 382     }
 383     if ((err = set_swparams(handle)) < 0)
 384     {
 385         printf("Setting of swparams failed: %s\n", snd_strerror(err));
 386         exit(EXIT_FAILURE);
 387     }
 388
 389     pcm_dma_apply_settings();
 390
 391 #ifdef USE_ASYNC_CALLBACK
 392     pthread_mutexattr_t attr;
 393     pthread_mutexattr_init(&attr);
 394     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 395     pthread_mutex_init(&pcm_mtx, &attr);
 396 #else
 397     tick_add_task(pcm_tick);
 398 #endif
 399
 400     atexit(cleanup);
 401     return;
 402 }
 403
 404
 405 void pcm_play_lock(void)
 406 {
 407 #ifdef USE_ASYNC_CALLBACK
 408     pthread_mutex_lock(&pcm_mtx);
 409 #else
 410     if (recursion++ == 0)
 411         tick_remove_task(pcm_tick);
 412 #endif
 413 }
 414
 415 void pcm_play_unlock(void)
 416 {
 417 #ifdef USE_ASYNC_CALLBACK
 418     pthread_mutex_unlock(&pcm_mtx);
 419 #else
 420     if (--recursion == 0)
 421         tick_add_task(pcm_tick);
 422 #endif
 423 }
 424
 425 static void pcm_dma_apply_settings_nolock(void)
 426 {
 427     snd_pcm_drop(handle);
 428     set_hwparams(handle, pcm_sampr);
 429 }
 430
 431 void pcm_dma_apply_settings(void)
 432 {
 433     pcm_play_lock();
 434     pcm_dma_apply_settings_nolock();
 435     pcm_play_unlock();
 436 }
 437
 438
 439 void pcm_play_dma_pause(bool pause)
 440 {
 441     snd_pcm_pause(handle, pause);
 442 }
 443
 444
 445 void pcm_play_dma_stop(void)
 446 {
 447     snd_pcm_drain(handle);
 448 }
 449
 450 void pcm_play_dma_start(const void *addr, size_t size)
 451 {
 452     pcm_dma_apply_settings_nolock();
 453
 454     pcm_data = addr;
 455     pcm_size = size;
 456
 457     while (1)
 458     {
 459         snd_pcm_state_t state = snd_pcm_state(handle);
 460         switch (state)
 461         {
 462             case SND_PCM_STATE_RUNNING:
 463                 return;
 464             case SND_PCM_STATE_XRUN:
 465             {
 466                 DEBUGF("Trying to recover from error\n");
 467                 int err = snd_pcm_recover(handle, -EPIPE, 0);
 468                 if (err < 0)
 469                     DEBUGF("Recovery failed: %s\n", snd_strerror(err));
 470                 continue;
 471             }
 472             case SND_PCM_STATE_SETUP:
 473             {
 474                 int err = snd_pcm_prepare(handle);
 475                 if (err < 0)
 476                     printf("Prepare error: %s\n", snd_strerror(err));
 477                 /* fall through */
 478             }
 479             case SND_PCM_STATE_PREPARED:
 480             {   /* prepared state, we need to fill the buffer with silence before
 481                  * starting */
 482                 int err = async_rw(handle);
 483                 if (err < 0)
 484                     printf("Start error: %s\n", snd_strerror(err));
 485                 return;
 486             }
 487             case SND_PCM_STATE_PAUSED:
 488             {   /* paused, simply resume */
 489                 pcm_play_dma_pause(0);
 490                 return;
 491             }
 492             case SND_PCM_STATE_DRAINING:
 493                 /* run until drained */
 494                 continue;
 495             default:
 496                 DEBUGF("Unhandled state: %s\n", snd_pcm_state_name(state));
 497                 return;
 498         }
 499     }
 500 }
 501
 502 size_t pcm_get_bytes_waiting(void)
 503 {
 504     return pcm_size;
 505 }
 506
 507 const void * pcm_play_dma_get_peak_buffer(int *count)
 508 {
 509     uintptr_t addr = (uintptr_t)pcm_data;
 510     *count = pcm_size / 4;
 511     return (void *)((addr + 3) & ~3);
 512 }
 513
 514 void pcm_play_dma_postinit(void)
 515 {
 516     audiohw_postinit();
 517 }
 518
 519
 520 void pcm_set_mixer_volume(int volume)
 521 {
 522     (void)volume;
 523 }
 524 #ifdef HAVE_RECORDING
 525 void pcm_rec_lock(void)
 526 {
 527 }
 528
 529 void pcm_rec_unlock(void)
 530 {
 531 }
 532
 533 void pcm_rec_dma_init(void)
 534 {
 535 }
 536
 537 void pcm_rec_dma_close(void)
 538 {
 539 }
 540
 541 void pcm_rec_dma_start(void *start, size_t size)
 542 {
 543     (void)start;
 544     (void)size;
 545 }
 546
 547 void pcm_rec_dma_stop(void)
 548 {
 549 }
 550
 551 const void * pcm_rec_dma_get_peak_buffer(void)
 552 {
 553     return NULL;
 554 }
 555
 556 void audiohw_set_recvol(int left, int right, int type)
 557 {
 558     (void)left;
 559     (void)right;
 560     (void)type;
 561 }
 562
 563 #endif /* HAVE_RECORDING */