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