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 #include "pcm-internal.h"
  32 #include "pcm_mixer.h"
  33
  34 /**
  35  * Aspects implemented in the target-specific portion:
  36  *
  37  * ==Playback==
  38  *   Public -
  39  *      pcm_postinit
  40  *      pcm_get_bytes_waiting
  41  *      pcm_play_lock
  42  *      pcm_play_unlock
  43  *   Semi-private -
  44  *      pcm_play_dma_complete_callback
  45  *      pcm_play_dma_status_callback
  46  *      pcm_play_dma_init
  47  *      pcm_play_dma_postinit
  48  *      pcm_play_dma_start
  49  *      pcm_play_dma_stop
  50  *      pcm_play_dma_pause
  51  *      pcm_play_dma_get_peak_buffer
  52  *   Data Read/Written within TSP -
  53  *      pcm_sampr (R)
  54  *      pcm_fsel (R)
  55  *      pcm_curr_sampr (R)
  56  *      pcm_playing (R)
  57  *      pcm_paused (R)
  58  *
  59  * ==Playback/Recording==
  60  *   Public -
  61  *      pcm_dma_addr
  62  *   Semi-private -
  63  *      pcm_dma_apply_settings
  64  *
  65  * ==Recording==
  66  *   Public -
  67  *      pcm_rec_lock
  68  *      pcm_rec_unlock
  69  *   Semi-private -
  70  *      pcm_rec_dma_complete_callback
  71  *      pcm_rec_dma_status_callback
  72  *      pcm_rec_dma_init
  73  *      pcm_rec_dma_close
  74  *      pcm_rec_dma_start
  75  *      pcm_rec_dma_stop
  76  *      pcm_rec_dma_get_peak_buffer
  77  *   Data Read/Written within TSP -
  78  *      pcm_recording (R)
  79  *
  80  * States are set _after_ the target's pcm driver is called so that it may
  81  * know from whence the state is changed. One exception is init.
  82  *
  83  */
  84
  85 /* 'true' when all stages of pcm initialization have completed */
  86 static bool pcm_is_ready = false;
  87
  88 /* The registered callback function to ask for more mp3 data */
  89 static volatile pcm_play_callback_type
  90     pcm_callback_for_more SHAREDBSS_ATTR = NULL;
  91 /* The registered callback function to inform of DMA status */
  92 volatile pcm_status_callback_type
  93     pcm_play_status_callback SHAREDBSS_ATTR = NULL;
  94 /* PCM playback state */
  95 volatile bool pcm_playing SHAREDBSS_ATTR = false;
  96 /* PCM paused state. paused implies playing */
  97 volatile bool pcm_paused SHAREDBSS_ATTR = false;
  98 /* samplerate of currently playing audio - undefined if stopped */
  99 unsigned long pcm_curr_sampr SHAREDBSS_ATTR = 0;
 100 /* samplerate waiting to be set */
 101 unsigned long pcm_sampr SHAREDBSS_ATTR = HW_SAMPR_DEFAULT;
 102 /* samplerate frequency selection index */
 103 int pcm_fsel SHAREDBSS_ATTR = HW_FREQ_DEFAULT;
 104
 105 /* peak data for the global peak values - i.e. what the final output is */
 106 static struct pcm_peaks global_peaks;
 107
 108 /* Called internally by functions to reset the state */
 109 static void pcm_play_stopped(void)
 110 {
 111     pcm_callback_for_more = NULL;
 112     pcm_play_status_callback = NULL;
 113     pcm_paused = false;
 114     pcm_playing = false;
 115 }
 116
 117 static void pcm_wait_for_init(void)
 118 {
 119     while (!pcm_is_ready)
 120         sleep(0);
 121 }
 122
 123 /**
 124  * Perform peak calculation on a buffer of packed 16-bit samples.
 125  *
 126  * Used for recording and playback.
 127  */
 128 static void pcm_peak_peeker(const int32_t *addr, int count, uint16_t peaks[2])
 129 {
 130     int peak_l = 0, peak_r = 0;
 131     const int32_t * const end = addr + count;
 132
 133     do
 134     {
 135         int32_t value = *addr;
 136         int ch;
 137
 138 #ifdef ROCKBOX_BIG_ENDIAN
 139         ch = value >> 16;
 140 #else
 141         ch = (int16_t)value;
 142 #endif
 143         if (ch < 0)
 144             ch = -ch;
 145         if (ch > peak_l)
 146             peak_l = ch;
 147
 148 #ifdef ROCKBOX_BIG_ENDIAN
 149         ch = (int16_t)value;
 150 #else
 151         ch = value >> 16;
 152 #endif
 153         if (ch < 0)
 154             ch = -ch;
 155         if (ch > peak_r)
 156             peak_r = ch;
 157
 158         addr += 4;
 159     }
 160     while (addr < end);
 161
 162     peaks[0] = peak_l;
 163     peaks[1] = peak_r;
 164 }
 165
 166 void pcm_do_peak_calculation(struct pcm_peaks *peaks, bool active,
 167                              const void *addr, int count)
 168 {
 169     long tick = current_tick;
 170
 171     /* Peak no farther ahead than expected period to avoid overcalculation */
 172     long period = tick - peaks->tick;
 173
 174     /* Keep reasonable limits on period */
 175     if (period < 1)
 176         period = 1;
 177     else if (period > HZ/5)
 178         period = HZ/5;
 179
 180     peaks->period = (3*peaks->period + period) >> 2;
 181     peaks->tick = tick;
 182
 183     if (active)
 184     {
 185         int framecount = peaks->period*pcm_curr_sampr / HZ;
 186         count = MIN(framecount, count);
 187
 188         if (count > 0)
 189             pcm_peak_peeker((int32_t *)addr, count, peaks->val);
 190         /* else keep previous peak values */
 191     }
 192     else
 193     {
 194         /* peaks are zero */
 195         peaks->val[0] = peaks->val[1] = 0;
 196     }
 197 }
 198
 199 void pcm_calculate_peaks(int *left, int *right)
 200 {
 201     int count;
 202     const void *addr = pcm_play_dma_get_peak_buffer(&count);
 203
 204     pcm_do_peak_calculation(&global_peaks, pcm_playing && !pcm_paused,
 205                             addr, count);
 206
 207     if (left)
 208         *left = global_peaks.val[0];
 209
 210     if (right)
 211         *right = global_peaks.val[1];
 212 }
 213
 214 const void* pcm_get_peak_buffer(int * count)
 215 {
 216     return pcm_play_dma_get_peak_buffer(count);
 217 }
 218
 219 bool pcm_is_playing(void)
 220 {
 221     return pcm_playing;
 222 }
 223
 224 bool pcm_is_paused(void)
 225 {
 226     return pcm_paused;
 227 }
 228
 229 /****************************************************************************
 230  * Functions that do not require targeted implementation but only a targeted
 231  * interface
 232  */
 233
 234 /* This should only be called at startup before any audio playback or
 235    recording is attempted */
 236 void pcm_init(void)
 237 {
 238     logf("pcm_init");
 239
 240     pcm_play_stopped();
 241
 242     pcm_set_frequency(HW_SAMPR_DEFAULT);
 243
 244     logf(" pcm_play_dma_init");
 245     pcm_play_dma_init();
 246 }
 247
 248 /* Finish delayed init */
 249 void pcm_postinit(void)
 250 {
 251     logf("pcm_postinit");
 252
 253     logf(" pcm_play_dma_postinit");
 254
 255     pcm_play_dma_postinit();
 256
 257     pcm_is_ready = true;
 258 }
 259
 260 bool pcm_is_initialized(void)
 261 {
 262     return pcm_is_ready;
 263 }
 264
 265 /* Common code to pcm_play_data and pcm_play_pause */
 266 static void pcm_play_data_start(const void *addr, size_t size)
 267 {
 268     ALIGN_AUDIOBUF(addr, size);
 269
 270     if (!(addr && size))
 271     {
 272         pcm_play_callback_type get_more = pcm_callback_for_more;
 273         addr = NULL;
 274         size = 0;
 275
 276         if (get_more)
 277         {
 278             logf(" get_more");
 279             get_more(&addr, &size);
 280             ALIGN_AUDIOBUF(addr, size);
 281         }
 282     }
 283
 284     if (addr && size)
 285     {
 286         logf(" pcm_play_dma_start");
 287         pcm_apply_settings();
 288         pcm_play_dma_start(addr, size);
 289         pcm_playing = true;
 290         pcm_paused = false;
 291         return;
 292     }
 293
 294     /* Force a stop */
 295     logf(" pcm_play_dma_stop");
 296     pcm_play_dma_stop();
 297     pcm_play_stopped();
 298 }
 299
 300 void pcm_play_data(pcm_play_callback_type get_more,
 301                    pcm_status_callback_type status_cb,
 302                    const void *start, size_t size)
 303 {
 304     logf("pcm_play_data");
 305
 306     pcm_play_lock();
 307
 308     pcm_callback_for_more = get_more;
 309     pcm_play_status_callback = status_cb;
 310
 311     logf(" pcm_play_data_start");
 312     pcm_play_data_start(start, size);
 313
 314     pcm_play_unlock();
 315 }
 316
 317 bool pcm_play_dma_complete_callback(enum pcm_dma_status status,
 318                                     const void **addr, size_t *size)
 319 {
 320     /* Check status callback first if error */
 321     if (status < PCM_DMAST_OK)
 322         status = pcm_play_dma_status_callback(status);
 323
 324     pcm_play_callback_type get_more = pcm_callback_for_more;
 325
 326     if (get_more && status >= PCM_DMAST_OK)
 327     {
 328         *addr = NULL;
 329         *size = 0;
 330
 331         /* Call registered callback to obtain next buffer */
 332         get_more(addr, size);
 333         ALIGN_AUDIOBUF(*addr, *size);
 334
 335         if (*addr && *size)
 336             return true;
 337     }
 338
 339     /* Error, callback missing or no more DMA to do */
 340     pcm_play_dma_stop();
 341     pcm_play_stopped();
 342
 343     return false;
 344 }
 345
 346 void pcm_play_pause(bool play)
 347 {
 348     logf("pcm_play_pause: %s", play ? "play" : "pause");
 349
 350     pcm_play_lock();
 351
 352     if (play == pcm_paused && pcm_playing)
 353     {
 354         if (!play)
 355         {
 356             logf(" pcm_play_dma_pause");
 357             pcm_play_dma_pause(true);
 358             pcm_paused = true;
 359         }
 360         else if (pcm_get_bytes_waiting() > 0)
 361         {
 362             logf(" pcm_play_dma_pause");
 363             pcm_apply_settings();
 364             pcm_play_dma_pause(false);
 365             pcm_paused = false;
 366         }
 367         else
 368         {
 369             logf(" pcm_play_dma_start: no data");
 370             pcm_play_data_start(NULL, 0);
 371         }
 372     }
 373     else
 374     {
 375         logf(" no change");
 376     }
 377
 378     pcm_play_unlock();
 379 }
 380
 381 void pcm_play_stop(void)
 382 {
 383     logf("pcm_play_stop");
 384
 385     pcm_play_lock();
 386
 387     if (pcm_playing)
 388     {
 389         logf(" pcm_play_dma_stop");
 390         pcm_play_dma_stop();
 391         pcm_play_stopped();
 392     }
 393     else
 394     {
 395         logf(" not playing");
 396     }
 397
 398     pcm_play_unlock();
 399 }
 400
 401 /**/
 402
 403 /* set frequency next frequency used by the audio hardware -
 404  * what pcm_apply_settings will set */
 405 void pcm_set_frequency(unsigned int samplerate)
 406 {
 407     logf("pcm_set_frequency");
 408
 409     int index;
 410
 411 #ifdef CONFIG_SAMPR_TYPES
 412     unsigned int type = samplerate & SAMPR_TYPE_MASK;
 413     samplerate &= ~SAMPR_TYPE_MASK;
 414
 415     /* For now, supported targets have direct conversion when configured with
 416      * CONFIG_SAMPR_TYPES.
 417      * Some hypothetical target with independent rates would need slightly
 418      * different handling throughout this source. */
 419     samplerate = pcm_sampr_to_hw_sampr(samplerate, type);
 420 #endif /* CONFIG_SAMPR_TYPES */
 421
 422     index = round_value_to_list32(samplerate, hw_freq_sampr,
 423                                   HW_NUM_FREQ, false);
 424
 425     if (samplerate != hw_freq_sampr[index])
 426         index = HW_FREQ_DEFAULT; /* Invalid = default */
 427
 428     pcm_sampr = hw_freq_sampr[index];
 429     pcm_fsel = index;
 430 }
 431
 432 /* apply pcm settings to the hardware */
 433 void pcm_apply_settings(void)
 434 {
 435     logf("pcm_apply_settings");
 436
 437     pcm_wait_for_init();
 438
 439     if (pcm_sampr != pcm_curr_sampr)
 440     {
 441         logf(" pcm_dma_apply_settings");
 442         pcm_dma_apply_settings();
 443         pcm_curr_sampr = pcm_sampr;
 444     }
 445 }
 446
 447 #ifdef HAVE_RECORDING
 448 /** Low level pcm recording apis **/
 449
 450 /* Next start for recording peaks */
 451 static const void * volatile pcm_rec_peak_addr SHAREDBSS_ATTR = NULL;
 452 /* the registered callback function for when more data is available */
 453 static volatile pcm_rec_callback_type
 454     pcm_callback_more_ready SHAREDBSS_ATTR = NULL;
 455 volatile pcm_status_callback_type
 456     pcm_rec_status_callback SHAREDBSS_ATTR = NULL;
 457 /* DMA transfer in is currently active */
 458 volatile bool pcm_recording SHAREDBSS_ATTR = false;
 459
 460 /* Called internally by functions to reset the state */
 461 static void pcm_recording_stopped(void)
 462 {
 463     pcm_recording = false;
 464     pcm_callback_more_ready = NULL;
 465     pcm_rec_status_callback = NULL;
 466 }
 467
 468 /**
 469  * Return recording peaks - From the end of the last peak up to
 470  *                          current write position.
 471  */
 472 void pcm_calculate_rec_peaks(int *left, int *right)
 473 {
 474     static uint16_t peaks[2];
 475
 476     if (pcm_recording)
 477     {
 478         const void *peak_addr = pcm_rec_peak_addr;
 479         const void *addr = pcm_rec_dma_get_peak_buffer();
 480
 481         if (addr != NULL)
 482         {
 483             int count = (int)(((intptr_t)addr - (intptr_t)peak_addr) >> 2);
 484
 485             if (count > 0)
 486             {
 487                 pcm_peak_peeker((int32_t *)peak_addr, count, peaks);
 488
 489                 if (peak_addr == pcm_rec_peak_addr)
 490                     pcm_rec_peak_addr = addr;
 491             }
 492         }
 493         /* else keep previous peak values */
 494     }
 495     else
 496     {
 497         peaks[0] = peaks[1] = 0;
 498     }
 499
 500     if (left)
 501         *left = peaks[0];
 502
 503     if (right)
 504         *right = peaks[1];
 505 } /* pcm_calculate_rec_peaks */
 506
 507 bool pcm_is_recording(void)
 508 {
 509     return pcm_recording;
 510 }
 511
 512 /****************************************************************************
 513  * Functions that do not require targeted implementation but only a targeted
 514  * interface
 515  */
 516
 517 void pcm_init_recording(void)
 518 {
 519     logf("pcm_init_recording");
 520
 521     pcm_wait_for_init();
 522
 523     /* Stop the beasty before attempting recording */
 524     mixer_reset();
 525
 526     /* Recording init is locked unlike general pcm init since this is not
 527      * just a one-time event at startup and it should and must be safe by
 528      * now. */
 529     pcm_rec_lock();
 530
 531     logf(" pcm_rec_dma_init");
 532     pcm_recording_stopped();
 533     pcm_rec_dma_init();
 534
 535     pcm_rec_unlock();
 536 }
 537
 538 void pcm_close_recording(void)
 539 {
 540     logf("pcm_close_recording");
 541
 542     pcm_rec_lock();
 543
 544     if (pcm_recording)
 545     {
 546         logf(" pcm_rec_dma_stop");
 547         pcm_rec_dma_stop();
 548         pcm_recording_stopped();
 549     }
 550
 551     logf(" pcm_rec_dma_close");
 552     pcm_rec_dma_close();
 553
 554     pcm_rec_unlock();
 555 }
 556
 557 void pcm_record_data(pcm_rec_callback_type more_ready,
 558                      pcm_status_callback_type status_cb,
 559                      void *addr, size_t size)
 560 {
 561     logf("pcm_record_data");
 562
 563     ALIGN_AUDIOBUF(addr, size);
 564
 565     if (!(addr && size))
 566     {
 567         logf(" no buffer");
 568         return;
 569     }
 570
 571     pcm_rec_lock();
 572
 573     pcm_callback_more_ready = more_ready;
 574     pcm_rec_status_callback = status_cb;
 575
 576     /* Need a physical DMA address translation, if not already physical. */
 577     pcm_rec_peak_addr = pcm_rec_dma_addr(addr);
 578
 579     logf(" pcm_rec_dma_start");
 580     pcm_apply_settings();
 581     pcm_rec_dma_start(addr, size);
 582     pcm_recording = true;
 583
 584     pcm_rec_unlock();
 585 } /* pcm_record_data */
 586
 587 void pcm_stop_recording(void)
 588 {
 589     logf("pcm_stop_recording");
 590
 591     pcm_rec_lock();
 592
 593     if (pcm_recording)
 594     {
 595         logf(" pcm_rec_dma_stop");
 596         pcm_rec_dma_stop();
 597         pcm_recording_stopped();
 598     }
 599
 600     pcm_rec_unlock();
 601 } /* pcm_stop_recording */
 602
 603 bool pcm_rec_dma_complete_callback(enum pcm_dma_status status,
 604                                    void **addr, size_t *size)
 605 {
 606      /* Check status callback first if error */
 607     if (status < PCM_DMAST_OK)
 608         status = pcm_rec_dma_status_callback(status);
 609
 610     pcm_rec_callback_type have_more = pcm_callback_more_ready;
 611
 612     if (have_more && status >= PCM_DMAST_OK)
 613     {
 614         /* Call registered callback to obtain next buffer */
 615         have_more(addr, size);
 616         ALIGN_AUDIOBUF(*addr, *size);
 617
 618         if (*addr && *size)
 619         {
 620             /* Need a physical DMA address translation, if not already
 621              * physical. */
 622             pcm_rec_peak_addr = pcm_rec_dma_addr(*addr);
 623             return true;
 624         }
 625     }
 626
 627     /* Error, callback missing or no more DMA to do */
 628     pcm_rec_dma_stop();
 629     pcm_recording_stopped();
 630
 631     return false;
 632 }
 633
 634 #endif /* HAVE_RECORDING */