firmware/pcm.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 by Michael Sevakis
  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 #include <stdlib.h>
  22 #include "system.h"
  23 #include "kernel.h"
  24 #include "logf.h"
  25 #include "audio.h"
  26 #include "sound.h"
  27 #include "general.h"
  28
  29 /**
  30  * Aspects implemented in the target-specific portion:
  31  *
  32  * ==Playback==
  33  *   Public -
  34  *      pcm_postinit
  35  *      pcm_get_bytes_waiting
  36  *      pcm_play_lock
  37  *      pcm_play_unlock
  38  *   Semi-private -
  39  *      pcm_play_dma_init
  40  *      pcm_play_dma_init
  41  *      pcm_play_dma_start
  42  *      pcm_play_dma_stop
  43  *      pcm_play_dma_pause
  44  *      pcm_play_dma_get_peak_buffer
  45  *   Data Read/Written within TSP -
  46  *      pcm_sampr (R)
  47  *      pcm_fsel (R)
  48  *      pcm_curr_sampr (R)
  49  *      pcm_callback_for_more (R)
  50  *      pcm_playing (R)
  51  *      pcm_paused (R)
  52  *
  53  * ==Playback/Recording==
  54  *   Semi-private -
  55  *      pcm_dma_apply_settings
  56  *      pcm_dma_addr
  57  *
  58  * ==Recording==
  59  *   Public -
  60  *      pcm_rec_lock
  61  *      pcm_rec_unlock
  62  *   Semi-private -
  63  *      pcm_rec_dma_init
  64  *      pcm_rec_dma_close
  65  *      pcm_rec_dma_start
  66  *      pcm_rec_dma_stop
  67  *      pcm_rec_dma_get_peak_buffer
  68  *   Data Read/Written within TSP -
  69  *      pcm_rec_peak_addr (R/W)
  70  *      pcm_callback_more_ready (R)
  71  *      pcm_recording (R)
  72  *
  73  * States are set _after_ the target's pcm driver is called so that it may
  74  * know from whence the state is changed. One exception is init.
  75  *
  76  */
  77
  78 /* the registered callback function to ask for more mp3 data */
  79 volatile pcm_more_callback_type pcm_callback_for_more
  80     SHAREDBSS_ATTR = NULL;
  81 /* PCM playback state */
  82 volatile bool pcm_playing SHAREDBSS_ATTR = false;
  83 /* PCM paused state. paused implies playing */
  84 volatile bool pcm_paused SHAREDBSS_ATTR = false;
  85 /* samplerate of currently playing audio - undefined if stopped */
  86 unsigned long pcm_curr_sampr SHAREDBSS_ATTR = 0;
  87 /* samplerate waiting to be set */
  88 unsigned long pcm_sampr SHAREDBSS_ATTR = HW_SAMPR_DEFAULT;
  89 /* samplerate frequency selection index */
  90 int pcm_fsel SHAREDBSS_ATTR = HW_FREQ_DEFAULT;
  91
  92 /**
  93  * Do peak calculation using distance squared from axis and save a lot
  94  * of jumps and negation. Don't bother with the calculations of left or
  95  * right only as it's never really used and won't save much time.
  96  *
  97  * Used for recording and playback.
  98  */
  99 static void pcm_peak_peeker(const void *addr, int count, int peaks[2])
 100 {
 101     int32_t peak_l = 0, peak_r = 0;
 102     int32_t peaksq_l = 0, peaksq_r = 0;
 103
 104     do
 105     {
 106         int32_t value = *(int32_t *)addr;
 107         int32_t ch, chsq;
 108 #ifdef ROCKBOX_BIG_ENDIAN
 109         ch = value >> 16;
 110 #else
 111         ch = (int16_t)value;
 112 #endif
 113         chsq = ch*ch;
 114         if (chsq > peaksq_l)
 115             peak_l = ch, peaksq_l = chsq;
 116
 117 #ifdef ROCKBOX_BIG_ENDIAN
 118         ch = (int16_t)value;
 119 #else
 120         ch = value >> 16;
 121 #endif
 122         chsq = ch*ch;
 123         if (chsq > peaksq_r)
 124             peak_r = ch, peaksq_r = chsq;
 125
 126         addr += 16;
 127         count -= 4;
 128     }
 129     while (count > 0);
 130
 131     peaks[0] = abs(peak_l);
 132     peaks[1] = abs(peak_r);
 133 }
 134
 135 void pcm_calculate_peaks(int *left, int *right)
 136 {
 137     static int peaks[2] = { 0, 0 };
 138     static unsigned long last_peak_tick = 0;
 139     static unsigned long frame_period   = 0;
 140
 141     long tick = current_tick;
 142     int count;
 143     const void *addr;
 144
 145     /* Throttled peak ahead based on calling period */
 146     long period = tick - last_peak_tick;
 147
 148     /* Keep reasonable limits on period */
 149     if (period < 1)
 150         period = 1;
 151     else if (period > HZ/5)
 152         period = HZ/5;
 153
 154     frame_period = (3*frame_period + period) >> 2;
 155
 156     last_peak_tick = tick;
 157
 158     addr = pcm_play_dma_get_peak_buffer(&count);
 159
 160     if (pcm_playing && !pcm_paused)
 161     {
 162         int framecount;
 163
 164         framecount = frame_period*pcm_curr_sampr / HZ;
 165         count = MIN(framecount, count);
 166
 167         if (count > 0)
 168             pcm_peak_peeker(addr, count, peaks);
 169         /* else keep previous peak values */
 170     }
 171     else
 172     {
 173         peaks[0] = peaks[1] = 0;
 174     }
 175
 176     if (left)
 177         *left = peaks[0];
 178
 179     if (right)
 180         *right = peaks[1];
 181 }
 182
 183 /****************************************************************************
 184  * Functions that do not require targeted implementation but only a targeted
 185  * interface
 186  */
 187
 188 /* This should only be called at startup before any audio playback or
 189    recording is attempted */
 190 void pcm_init(void)
 191 {
 192     logf("pcm_init");
 193
 194     pcm_play_dma_stopped_callback();
 195
 196     pcm_set_frequency(HW_SAMPR_DEFAULT);
 197
 198     logf(" pcm_play_dma_init");
 199     pcm_play_dma_init();
 200 }
 201
 202 /* Common code to pcm_play_data and pcm_play_pause */
 203 static void pcm_play_data_start(unsigned char *start, size_t size)
 204 {
 205     if (!(start && size))
 206     {
 207         pcm_more_callback_type get_more = pcm_callback_for_more;
 208         size = 0;
 209         if (get_more)
 210         {
 211             logf(" get_more");
 212             get_more(&start, &size);
 213         }
 214     }
 215
 216     if (start && size)
 217     {
 218         logf(" pcm_play_dma_start");
 219         pcm_apply_settings();
 220         pcm_play_dma_start(start, size);
 221         pcm_playing = true;
 222         pcm_paused = false;
 223         return;
 224     }
 225
 226     /* Force a stop */
 227     logf(" pcm_play_dma_stop");
 228     pcm_play_dma_stop();
 229     pcm_play_dma_stopped_callback();
 230 }
 231
 232 void pcm_play_data(pcm_more_callback_type get_more,
 233                    unsigned char *start, size_t size)
 234 {
 235     logf("pcm_play_data");
 236
 237     pcm_play_lock();
 238
 239     pcm_callback_for_more = get_more;
 240
 241     logf(" pcm_play_data_start");
 242     pcm_play_data_start(start, size);
 243
 244     pcm_play_unlock();
 245 }
 246
 247 void pcm_play_pause(bool play)
 248 {
 249     logf("pcm_play_pause: %s", play ? "play" : "pause");
 250
 251     pcm_play_lock();
 252
 253     if (play == pcm_paused && pcm_playing)
 254     {
 255         if (!play)
 256         {
 257             logf(" pcm_play_dma_pause");
 258             pcm_play_dma_pause(true);
 259             pcm_paused = true;
 260         }
 261         else if (pcm_get_bytes_waiting() > 0)
 262         {
 263             logf(" pcm_play_dma_pause");
 264             pcm_apply_settings();
 265             pcm_play_dma_pause(false);
 266             pcm_paused = false;
 267         }
 268         else
 269         {
 270             logf(" pcm_play_dma_start: no data");
 271             pcm_play_data_start(NULL, 0);
 272         }
 273     }
 274     else
 275     {
 276         logf(" no change");
 277     }
 278
 279     pcm_play_unlock();
 280 }
 281
 282 void pcm_play_stop(void)
 283 {
 284     logf("pcm_play_stop");
 285
 286     pcm_play_lock();
 287
 288     if (pcm_playing)
 289     {
 290         logf(" pcm_play_dma_stop");
 291         pcm_play_dma_stop();
 292         pcm_play_dma_stopped_callback();
 293     }
 294     else
 295     {
 296         logf(" not playing");
 297     }
 298
 299     pcm_play_unlock();
 300 }
 301
 302 void pcm_play_dma_stopped_callback(void)
 303 {
 304     pcm_callback_for_more = NULL;
 305     pcm_paused = false;
 306     pcm_playing = false;
 307 }
 308
 309 /**/
 310
 311 /* set frequency next frequency used by the audio hardware -
 312  * what pcm_apply_settings will set */
 313 void pcm_set_frequency(unsigned int samplerate)
 314 {
 315     logf("pcm_set_frequency");
 316
 317     int index = round_value_to_list32(samplerate, hw_freq_sampr,
 318                                       HW_NUM_FREQ, false);
 319
 320     if (samplerate != hw_freq_sampr[index])
 321         index = HW_FREQ_DEFAULT; /* Invalid = default */
 322
 323     pcm_sampr = hw_freq_sampr[index];
 324     pcm_fsel = index;
 325 }
 326
 327 /* apply pcm settings to the hardware */
 328 void pcm_apply_settings(void)
 329 {
 330     logf("pcm_apply_settings");
 331
 332     if (pcm_sampr != pcm_curr_sampr)
 333     {
 334         logf(" pcm_dma_apply_settings");
 335         pcm_dma_apply_settings();
 336         pcm_curr_sampr = pcm_sampr;
 337     }
 338 }
 339
 340 bool pcm_is_playing(void)
 341 {
 342     return pcm_playing;
 343 }
 344
 345 bool pcm_is_paused(void)
 346 {
 347     return pcm_paused;
 348 }
 349
 350 void pcm_mute(bool mute)
 351 {
 352 #ifndef SIMULATOR
 353     audiohw_mute(mute);
 354 #endif
 355
 356     if (mute)
 357         sleep(HZ/16);
 358 }
 359
 360 #ifdef HAVE_RECORDING
 361 /** Low level pcm recording apis **/
 362
 363 /* Next start for recording peaks */
 364 const volatile void *pcm_rec_peak_addr SHAREDBSS_ATTR = NULL;
 365 /* the registered callback function for when more data is available */
 366 volatile pcm_more_callback_type2
 367     pcm_callback_more_ready SHAREDBSS_ATTR = NULL;
 368 /* DMA transfer in is currently active */
 369 volatile bool pcm_recording SHAREDBSS_ATTR = false;
 370
 371 /**
 372  * Return recording peaks - From the end of the last peak up to
 373  *                          current write position.
 374  */
 375 void pcm_calculate_rec_peaks(int *left, int *right)
 376 {
 377     static int peaks[2];
 378     int count;
 379     const void *addr = pcm_rec_dma_get_peak_buffer(&count);
 380
 381     if (pcm_recording)
 382     {
 383         if (count > 0)
 384         {
 385             pcm_peak_peeker(addr, count, peaks);
 386
 387             if (addr == pcm_rec_peak_addr)
 388                 pcm_rec_peak_addr = (int32_t *)addr + count;
 389         }
 390         /* else keep previous peak values */
 391     }
 392     else
 393     {
 394         peaks[0] = peaks[1] = 0;
 395     }
 396
 397     if (left)
 398         *left = peaks[0];
 399
 400     if (right)
 401         *right = peaks[1];
 402 } /* pcm_calculate_rec_peaks */
 403
 404 /****************************************************************************
 405  * Functions that do not require targeted implementation but only a targeted
 406  * interface
 407  */
 408 void pcm_init_recording(void)
 409 {
 410     logf("pcm_init_recording");
 411
 412     /* Recording init is locked unlike general pcm init since this is not
 413      * just a one-time event at startup and it should and must be safe by
 414      * now. */
 415     pcm_rec_lock();
 416
 417     logf(" pcm_rec_dma_init");
 418     pcm_rec_dma_stopped_callback();
 419     pcm_rec_dma_init();
 420
 421     pcm_rec_unlock();
 422 }
 423
 424 void pcm_close_recording(void)
 425 {
 426     logf("pcm_close_recording");
 427
 428     pcm_rec_lock();
 429
 430     if (pcm_recording)
 431     {
 432         logf(" pcm_rec_dma_stop");
 433         pcm_rec_dma_stop();
 434         pcm_rec_dma_stopped_callback();
 435     }
 436
 437     logf(" pcm_rec_dma_close");
 438     pcm_rec_dma_close();
 439
 440     pcm_rec_unlock();
 441 }
 442
 443 void pcm_record_data(pcm_more_callback_type2 more_ready,
 444                      void *start, size_t size)
 445 {
 446     logf("pcm_record_data");
 447
 448     if (!(start && size))
 449     {
 450         logf(" no buffer");
 451         return;
 452     }
 453
 454     pcm_rec_lock();
 455
 456     pcm_callback_more_ready = more_ready;
 457
 458     logf(" pcm_rec_dma_start");
 459     pcm_apply_settings();
 460     pcm_rec_dma_start(start, size);
 461     pcm_recording = true;
 462
 463     pcm_rec_unlock();
 464 } /* pcm_record_data */
 465
 466 void pcm_stop_recording(void)
 467 {
 468     logf("pcm_stop_recording");
 469
 470     pcm_rec_lock();
 471
 472     if (pcm_recording)
 473     {
 474         logf(" pcm_rec_dma_stop");
 475         pcm_rec_dma_stop();
 476         pcm_rec_dma_stopped_callback();
 477     }
 478
 479     pcm_rec_unlock();
 480 } /* pcm_stop_recording */
 481
 482 bool pcm_is_recording(void)
 483 {
 484     return pcm_recording;
 485 }
 486
 487 void pcm_rec_dma_stopped_callback(void)
 488 {
 489     pcm_recording = false;
 490     pcm_callback_more_ready = NULL;
 491 }
 492
 493 #endif /* HAVE_RECORDING */