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