apps/pcmbuf.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 by Miika Pekkarinen
  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 <stdio.h>
  22 #include "config.h"
  23 #include "system.h"
  24 #include "debug.h"
  25 #include <kernel.h>
  26 #include "pcmbuf.h"
  27 #include "pcm.h"
  28 #include "playback.h"
  29
  30 /* Define LOGF_ENABLE to enable logf output in this file */
  31 /*#define LOGF_ENABLE*/
  32 #include "logf.h"
  33 #ifndef SIMULATOR
  34 #include "cpu.h"
  35 #endif
  36 #include <string.h>
  37 #include "settings.h"
  38 #include "audio.h"
  39 #include "voice_thread.h"
  40 #include "dsp.h"
  41
  42 #define PCMBUF_TARGET_CHUNK 32768 /* This is the target fill size of chunks
  43                                      on the pcm buffer */
  44 #define PCMBUF_MINAVG_CHUNK 24576 /* This is the minimum average size of
  45                                      chunks on the pcm buffer (or we run out
  46                                      of buffer descriptors, which is
  47                                      non-fatal) */
  48 #define PCMBUF_MIN_CHUNK     4096 /* We try to never feed a chunk smaller than
  49                                      this to the DMA */
  50 #define PCMBUF_MIX_CHUNK     8192 /* This is the maximum size of one packet
  51                                      for mixing (crossfade or voice) */
  52
  53 /* number of bytes played per second (sample rate * 2 channels * 2 bytes/sample) */
  54 #define BYTERATE            (NATIVE_FREQUENCY * 4)
  55
  56 #if MEMORYSIZE > 2
  57 /* Keep watermark high for iPods at least (2s) */
  58 #define PCMBUF_WATERMARK    (BYTERATE * 2)
  59 #else
  60 #define PCMBUF_WATERMARK    (BYTERATE / 4)  /* 0.25 seconds */
  61 #endif
  62
  63 /* Structure we can use to queue pcm chunks in memory to be played
  64  * by the driver code. */
  65 struct chunkdesc
  66 {
  67     void *addr;
  68     size_t size;
  69     struct chunkdesc* link;
  70     /* true if last chunk in the track */
  71     bool end_of_track;
  72 };
  73
  74 #define NUM_CHUNK_DESCS(bufsize) \
  75     ((bufsize) / PCMBUF_MINAVG_CHUNK)
  76
  77 /* Size of the PCM buffer. */
  78 static size_t pcmbuf_size IDATA_ATTR = 0;
  79 static char *pcmbuf_bufend IDATA_ATTR;
  80 static char *pcmbuffer IDATA_ATTR;
  81 /* Current PCM buffer write index. */
  82 static size_t pcmbuffer_pos IDATA_ATTR;
  83 /* Amount pcmbuffer_pos will be increased.*/
  84 static size_t pcmbuffer_fillpos IDATA_ATTR;
  85
  86 /* Gapless playback */
  87 static bool end_of_track IDATA_ATTR;
  88 bool track_transition IDATA_ATTR;
  89
  90 #ifdef HAVE_CROSSFADE
  91 /* Crossfade buffer */
  92 static char *fadebuf IDATA_ATTR;
  93
  94 /* Crossfade related state */
  95 static bool crossfade_enabled;
  96 static bool crossfade_enable_request;
  97 static bool crossfade_mixmode;
  98 static bool crossfade_auto_skip;
  99 static bool crossfade_active IDATA_ATTR;
 100 static bool crossfade_track_change_started IDATA_ATTR;
 101
 102 /* Track the current location for processing crossfade */
 103 static struct chunkdesc *crossfade_chunk IDATA_ATTR;
 104 static size_t crossfade_sample IDATA_ATTR;
 105
 106 /* Counters for fading in new data */
 107 static size_t crossfade_fade_in_total IDATA_ATTR;
 108 static size_t crossfade_fade_in_rem IDATA_ATTR;
 109 #endif
 110
 111 static struct chunkdesc *read_chunk IDATA_ATTR;
 112 static struct chunkdesc *read_end_chunk IDATA_ATTR;
 113 static struct chunkdesc *write_chunk IDATA_ATTR;
 114 static struct chunkdesc *write_end_chunk IDATA_ATTR;
 115 static size_t last_chunksize IDATA_ATTR;
 116
 117 static size_t pcmbuf_unplayed_bytes IDATA_ATTR;
 118 static size_t pcmbuf_watermark IDATA_ATTR;
 119
 120 /* Voice */
 121 static char *voicebuf IDATA_ATTR;
 122 static struct chunkdesc *mix_chunk IDATA_ATTR;
 123 static size_t pcmbuf_mix_sample IDATA_ATTR;
 124
 125 static bool low_latency_mode = false;
 126 static bool flush_pcmbuf = false;
 127
 128 #ifdef HAVE_PRIORITY_SCHEDULING
 129 static int codec_thread_priority = PRIORITY_PLAYBACK;
 130 #endif
 131
 132 extern unsigned int codec_thread_id;
 133
 134 /* Helpful macros for use in conditionals this assumes some of the above
 135  * static variable names */
 136 #define COMMIT_IF_NEEDED if(pcmbuffer_fillpos > PCMBUF_TARGET_CHUNK || \
 137     (pcmbuffer_pos + pcmbuffer_fillpos) >= pcmbuf_size) commit_chunk(false)
 138 #define LOW_DATA(quarter_secs) \
 139     (pcmbuf_unplayed_bytes < NATIVE_FREQUENCY * quarter_secs)
 140
 141 #ifdef HAVE_CROSSFADE
 142 static void crossfade_start(void);
 143 static void write_to_crossfade(size_t length);
 144 static void pcmbuf_finish_crossfade_enable(void);
 145 #endif
 146
 147
 148 /**************************************/
 149
 150 /* define this to show detailed chunkdesc usage information on the sim console */
 151 /*#define DESC_DEBUG*/
 152
 153 #ifndef SIMULATOR
 154 #undef DESC_DEBUG
 155 #endif
 156 #ifdef DESC_DEBUG
 157 static struct chunkdesc *first_desc;
 158 static bool show_desc_in_use = false;
 159 #define DISPLAY_DESC(caller) while(!show_desc(caller))
 160 #define DESC_IDX(desc)       (desc ? desc - first_desc : -1)
 161 #define SHOW_DESC(desc)      if(DESC_IDX(desc)==-1) DEBUGF("--"); \
 162                              else DEBUGF("%02d", DESC_IDX(desc))
 163 #define SHOW_DESC_LINK(desc) if(desc){SHOW_DESC(desc->link);DEBUGF(" ");} \
 164                              else DEBUGF("-- ")
 165 #define SHOW_DETAIL(desc)    DEBUGF(":");SHOW_DESC(desc); DEBUGF(">"); \
 166                              SHOW_DESC_LINK(desc)
 167 #define SHOW_POINT(tag,desc) DEBUGF("%s",tag);SHOW_DETAIL(desc)
 168 #define SHOW_NUM(num,desc)   DEBUGF("%02d>",num);SHOW_DESC_LINK(desc)
 169
 170 static bool show_desc(char *caller)
 171 {
 172     if (show_desc_in_use) return false;
 173     show_desc_in_use = true;
 174     DEBUGF("%-14s\t", caller);
 175     SHOW_POINT("r",  read_chunk);
 176     SHOW_POINT("re", read_end_chunk);
 177     DEBUGF(" ");
 178     SHOW_POINT("w",  write_chunk);
 179     SHOW_POINT("we", write_end_chunk);
 180     DEBUGF("\n");
 181     int i;
 182     for (i = 0; i < pcmbuf_descs(); i++)
 183     {
 184         SHOW_NUM(i, (first_desc + i));
 185         if (i%10 == 9) DEBUGF("\n");
 186     }
 187     DEBUGF("\n\n");
 188     show_desc_in_use = false;
 189     return true;
 190 }
 191 #else
 192 #define DISPLAY_DESC(caller) do{}while(0)
 193 #endif
 194
 195
 196 /** Accept new PCM data */
 197
 198 /* Commit PCM buffer samples as a new chunk for playback */
 199 static void commit_chunk(bool flush_next_time)
 200 {
 201     if (!pcmbuffer_fillpos)
 202         return;
 203
 204     /* Never use the last buffer descriptor */
 205     while (write_chunk == write_end_chunk) {
 206         /* If this happens, something is being stupid */
 207         if (!pcm_is_playing()) {
 208             logf("commit_chunk error");
 209             pcmbuf_play_start();
 210         }
 211         /* Let approximately one chunk of data playback */
 212         sleep(HZ * PCMBUF_TARGET_CHUNK / BYTERATE);
 213     }
 214
 215     /* commit the chunk */
 216
 217     register size_t size = pcmbuffer_fillpos;
 218     /* Grab the next description to write, and change the write pointer */
 219     register struct chunkdesc *pcmbuf_current = write_chunk;
 220     write_chunk = pcmbuf_current->link;
 221     /* Fill in the values in the new buffer chunk */
 222     pcmbuf_current->addr = &pcmbuffer[pcmbuffer_pos];
 223     pcmbuf_current->size = size;
 224     pcmbuf_current->end_of_track = end_of_track;
 225     pcmbuf_current->link = NULL;
 226     end_of_track = false;   /* This is single use only */
 227
 228     if (read_chunk != NULL)
 229     {
 230         if (flush_pcmbuf)
 231         {
 232             /* Flush! Discard all data after the currently playing chunk,
 233                and make the current chunk play next */
 234             logf("commit_chunk: flush");
 235             write_end_chunk->link = read_chunk->link;
 236             read_chunk->link = pcmbuf_current;
 237             while (write_end_chunk->link)
 238             {
 239                 write_end_chunk = write_end_chunk->link;
 240                 pcmbuf_unplayed_bytes -= write_end_chunk->size;
 241             }
 242         }
 243         /* If there is already a read buffer setup, add to it */
 244         else
 245             read_end_chunk->link = pcmbuf_current;
 246     }
 247     else
 248     {
 249         /* Otherwise create the buffer */
 250         read_chunk = pcmbuf_current;
 251     }
 252
 253     /* If flush_next_time is true, then the current chunk will be thrown out
 254      * and the next chunk to be committed will be the next to be played.
 255      * This is used to empty the PCM buffer for a track change. */
 256     flush_pcmbuf = flush_next_time;
 257
 258     /* This is now the last buffer to read */
 259     read_end_chunk = pcmbuf_current;
 260
 261     /* Update bytes counters */
 262     pcmbuf_unplayed_bytes += size;
 263
 264     pcmbuffer_pos += size;
 265     if (pcmbuffer_pos >= pcmbuf_size)
 266         pcmbuffer_pos -= pcmbuf_size;
 267
 268     pcmbuffer_fillpos = 0;
 269     DISPLAY_DESC("commit_chunk");
 270 }
 271
 272 /* Set priority of the codec thread */
 273 #ifdef HAVE_PRIORITY_SCHEDULING
 274 static void boost_codec_thread(bool boost)
 275 {
 276     /* Keep voice and codec threads at the same priority or else voice
 277      * will starve if the codec thread's priority is boosted. */
 278     if (boost)
 279     {
 280         int priority = (PRIORITY_PLAYBACK - PRIORITY_PLAYBACK_MAX)*pcmbuf_unplayed_bytes
 281                           / (2*NATIVE_FREQUENCY) + PRIORITY_PLAYBACK_MAX;
 282
 283         if (priority != codec_thread_priority)
 284         {
 285             codec_thread_priority = priority;
 286             thread_set_priority(codec_thread_id, priority);
 287             voice_thread_set_priority(priority);
 288         }
 289     }
 290     else if (codec_thread_priority != PRIORITY_PLAYBACK)
 291     {
 292         thread_set_priority(codec_thread_id, PRIORITY_PLAYBACK);
 293         voice_thread_set_priority(PRIORITY_PLAYBACK);
 294         codec_thread_priority = PRIORITY_PLAYBACK;
 295     }
 296 }
 297 #else
 298 #define boost_codec_thread(boost) do{}while(0)
 299 #endif /* HAVE_PRIORITY_SCHEDULING */
 300
 301 /* Return true if the PCM buffer is able to receive new data.
 302  * Also maintain buffer level above the watermark. */
 303 static bool prepare_insert(size_t length)
 304 {
 305     if (low_latency_mode)
 306     {
 307         /* 1/4s latency. */
 308         if (!LOW_DATA(1) && pcm_is_playing())
 309             return false;
 310     }
 311
 312     /* Need to save PCMBUF_MIN_CHUNK to prevent wrapping overwriting */
 313     if (pcmbuf_free() < length + PCMBUF_MIN_CHUNK)
 314         return false;
 315
 316     /* Maintain the buffer level above the watermark */
 317     if (pcm_is_playing())
 318     {
 319         /* Only codec thread initiates boost - voice boosts the cpu when playing
 320            a clip */
 321 #ifndef SIMULATOR
 322         if (thread_get_current() == codec_thread_id)
 323 #endif /* SIMULATOR */
 324         {
 325             if (pcmbuf_unplayed_bytes <= pcmbuf_watermark)
 326             {
 327                 /* Fill PCM buffer by boosting cpu */
 328                 trigger_cpu_boost();
 329                 /* If buffer is critically low, override UI priority, else
 330                    set back to the original priority. */
 331                 boost_codec_thread(LOW_DATA(2));
 332             }
 333             else
 334             {
 335                 boost_codec_thread(false);
 336             }
 337         }
 338
 339 #ifdef HAVE_CROSSFADE
 340         /* Disable crossfade if < .5s of audio */
 341         if (LOW_DATA(2))
 342         {
 343             crossfade_active = false;
 344         }
 345 #endif
 346     }
 347     else    /* pcm_is_playing */
 348     {
 349         /* Boost CPU for pre-buffer */
 350         trigger_cpu_boost();
 351
 352         /* If pre-buffered to the watermark, start playback */
 353 #if MEMORYSIZE > 2
 354         if (!LOW_DATA(4))
 355 #else
 356         if (pcmbuf_unplayed_bytes > pcmbuf_watermark)
 357 #endif
 358         {
 359             logf("pcm starting");
 360             if (!(audio_status() & AUDIO_STATUS_PAUSE))
 361                 pcmbuf_play_start();
 362         }
 363     }
 364
 365     return true;
 366 }
 367
 368 /* Request space in the buffer for writing output samples */
 369 void *pcmbuf_request_buffer(int *count)
 370 {
 371 #ifdef HAVE_CROSSFADE
 372     /* we're going to crossfade to a new track, which is now on its way */
 373     if (crossfade_track_change_started)
 374         crossfade_start();
 375
 376     /* crossfade has begun, put the new track samples in fadebuf */
 377     if (crossfade_active)
 378     {
 379         *count = MIN(*count, PCMBUF_MIX_CHUNK/4);
 380         return fadebuf;
 381     }
 382     else
 383 #endif
 384     /* if possible, reserve room in the PCM buffer for new samples */
 385     {
 386         if(prepare_insert(*count << 2))
 387         {
 388             size_t pcmbuffer_index = pcmbuffer_pos + pcmbuffer_fillpos;
 389             if (pcmbuf_size - pcmbuffer_index >= PCMBUF_MIN_CHUNK)
 390             {
 391                 /* Usual case, there's space here */
 392                 return &pcmbuffer[pcmbuffer_index];
 393             }
 394             else
 395             {
 396                 /* Wrap the buffer, the new samples go at the beginning */
 397                 commit_chunk(false);
 398                 pcmbuffer_pos = 0;
 399                 return &pcmbuffer[0];
 400             }
 401         }
 402     }
 403     /* PCM buffer not ready to receive new data yet */
 404     return NULL;
 405 }
 406
 407 /* Handle new samples to the buffer */
 408 void pcmbuf_write_complete(int count)
 409 {
 410     size_t length = (size_t)(unsigned int)count << 2;
 411 #ifdef HAVE_CROSSFADE
 412     if (crossfade_active)
 413         write_to_crossfade(length);
 414     else
 415 #endif
 416     {
 417         pcmbuffer_fillpos += length;
 418         COMMIT_IF_NEEDED;
 419     }
 420 }
 421
 422
 423 /** Init */
 424
 425 static inline void init_pcmbuffers(void)
 426 {
 427 #ifdef DESC_DEBUG
 428     first_desc = write_chunk;
 429 #endif
 430     struct chunkdesc *next = write_chunk;
 431     next++;
 432     write_end_chunk = write_chunk;
 433     while ((void *)next < (void *)pcmbuf_bufend) {
 434         write_end_chunk->link=next;
 435         write_end_chunk=next;
 436         next++;
 437     }
 438     DISPLAY_DESC("init");
 439 }
 440
 441 static size_t get_next_required_pcmbuf_size(void)
 442 {
 443     size_t seconds = 1;
 444
 445 #ifdef HAVE_CROSSFADE
 446     if (crossfade_enable_request)
 447         seconds += global_settings.crossfade_fade_out_delay +
 448                    global_settings.crossfade_fade_out_duration;
 449 #endif
 450
 451 #if MEMORYSIZE > 2
 452     /* Buffer has to be at least 2s long. */
 453     seconds += 2;
 454 #endif
 455     logf("pcmbuf len: %ld", (long)seconds);
 456     return seconds * BYTERATE;
 457 }
 458
 459 /* Initialize the pcmbuffer the structure looks like this:
 460  * ...|---------PCMBUF---------|FADEBUF|VOICEBUF|DESCS|... */
 461 size_t pcmbuf_init(unsigned char *bufend)
 462 {
 463     pcmbuf_bufend = bufend;
 464     pcmbuf_size = get_next_required_pcmbuf_size();
 465     write_chunk = (struct chunkdesc *)pcmbuf_bufend -
 466         NUM_CHUNK_DESCS(pcmbuf_size);
 467     voicebuf = (char *)write_chunk - PCMBUF_MIX_CHUNK;
 468 #ifdef HAVE_CROSSFADE
 469     fadebuf = voicebuf - PCMBUF_MIX_CHUNK;
 470     pcmbuffer = fadebuf - pcmbuf_size;
 471 #else
 472     pcmbuffer = voicebuf - pcmbuf_size;
 473 #endif
 474
 475     init_pcmbuffers();
 476
 477 #ifdef HAVE_CROSSFADE
 478     pcmbuf_finish_crossfade_enable();
 479 #else
 480     pcmbuf_watermark = PCMBUF_WATERMARK;
 481 #endif
 482
 483     pcmbuf_play_stop();
 484
 485     return pcmbuf_bufend - pcmbuffer;
 486 }
 487
 488
 489 /** Track change */
 490
 491 void pcmbuf_start_track_change(bool auto_skip)
 492 {
 493     bool crossfade = false;
 494 #ifdef HAVE_CROSSFADE
 495     /* Determine whether this track change needs to crossfade */
 496     if(crossfade_enabled && !pcmbuf_is_crossfade_active())
 497     {
 498         switch(global_settings.crossfade)
 499         {
 500             case CROSSFADE_ENABLE_AUTOSKIP:
 501                 crossfade = auto_skip;
 502                 break;
 503             case CROSSFADE_ENABLE_MANSKIP:
 504                 crossfade = !auto_skip;
 505                 break;
 506             case CROSSFADE_ENABLE_SHUFFLE:
 507                 crossfade = global_settings.playlist_shuffle;
 508                 break;
 509             case CROSSFADE_ENABLE_SHUFFLE_OR_MANSKIP:
 510                 crossfade = global_settings.playlist_shuffle || !auto_skip;
 511                 break;
 512             case CROSSFADE_ENABLE_ALWAYS:
 513                 crossfade = true;
 514                 break;
 515         }
 516     }
 517 #endif
 518
 519     if (!auto_skip || crossfade)
 520     /* manual skip or crossfade */
 521     {
 522         if (crossfade)
 523             { logf("  crossfade track change"); }
 524         else
 525             { logf("  manual track change"); }
 526
 527         /* Notify the wps that the track change starts now */
 528         audio_post_track_change(false);
 529
 530         /* Can't do two crossfades at once and, no fade if pcm is off now */
 531         if (
 532 #ifdef HAVE_CROSSFADE
 533             pcmbuf_is_crossfade_active() ||
 534 #endif
 535             !pcm_is_playing())
 536         {
 537             pcmbuf_play_stop();
 538             return;
 539         }
 540
 541         trigger_cpu_boost();
 542
 543         /* Not enough data, or not crossfading, flush the old data instead */
 544         if (LOW_DATA(2) || !crossfade || low_latency_mode)
 545         {
 546             commit_chunk(true);
 547             return;
 548         }
 549
 550 #ifdef HAVE_CROSSFADE
 551         /* Don't enable mix mode when skipping tracks manually. */
 552         crossfade_mixmode = auto_skip && global_settings.crossfade_fade_out_mixmode;
 553
 554         crossfade_auto_skip = auto_skip;
 555
 556         crossfade_track_change_started = crossfade;
 557 #endif
 558     }
 559     else    /* automatic and not crossfading, so do gapless track change */
 560     {
 561         /* The codec is moving on to the next track, but the current track will
 562          * continue to play.  Set a flag to make sure the elapsed time of the
 563          * current track will be updated properly, and mark the current chunk
 564          * as the last one in the track. */
 565         logf("  gapless track change");
 566         track_transition = true;
 567         end_of_track = true;
 568     }
 569 }
 570
 571
 572 /** Playback */
 573
 574 /* PCM driver callback
 575  * This function has 3 major logical parts (separated by brackets both for
 576  * readability and variable scoping).  The first part performs the
 577  * operations related to finishing off the last chunk we fed to the DMA.
 578  * The second part detects the end of playlist condition when the PCM
 579  * buffer is empty except for uncommitted samples.  Then they are committed
 580  * and sent to the PCM driver for playback.  The third part performs the
 581  * operations involved in sending a new chunk to the DMA. */
 582 static void pcmbuf_pcm_callback(unsigned char** start, size_t* size) ICODE_ATTR;
 583 static void pcmbuf_pcm_callback(unsigned char** start, size_t* size)
 584 {
 585     {
 586         struct chunkdesc *pcmbuf_current = read_chunk;
 587         /* Take the finished chunk out of circulation */
 588         read_chunk = pcmbuf_current->link;
 589
 590         /* if during a track transition, update the elapsed time in ms */
 591         if (track_transition)
 592             audio_pcmbuf_position_callback(last_chunksize * 1000 / BYTERATE);
 593
 594         /* if last chunk in the track, stop updates and notify audio thread */
 595         if (pcmbuf_current->end_of_track)
 596         {
 597             track_transition = false;
 598             audio_post_track_change(true);
 599         }
 600
 601         /* Put the finished chunk back into circulation */
 602         write_end_chunk->link = pcmbuf_current;
 603         write_end_chunk = pcmbuf_current;
 604
 605         /* If we've read over the mix chunk while it's still mixing there */
 606         if (pcmbuf_current == mix_chunk)
 607             mix_chunk = NULL;
 608
 609 #ifdef HAVE_CROSSFADE
 610         /* If we've read over the crossfade chunk while it's still fading */
 611         if (pcmbuf_current == crossfade_chunk)
 612             crossfade_chunk = read_chunk;
 613 #endif
 614     }
 615
 616     {
 617         /* Commit last samples at end of playlist */
 618         if (pcmbuffer_fillpos && !read_chunk)
 619         {
 620             logf("pcmbuf_pcm_callback: commit last samples");
 621             commit_chunk(false);
 622         }
 623     }
 624
 625     {
 626         /* Send the new chunk to the PCM */
 627         if(read_chunk)
 628         {
 629             size_t current_size = read_chunk->size;
 630
 631             pcmbuf_unplayed_bytes -= current_size;
 632             last_chunksize = current_size;
 633             *size = current_size;
 634             *start = read_chunk->addr;
 635         }
 636         else
 637         {
 638             /* No more chunks */
 639             logf("pcmbuf_pcm_callback: no more chunks");
 640             last_chunksize = 0;
 641             *size = 0;
 642             *start = NULL;
 643         }
 644     }
 645     DISPLAY_DESC("callback");
 646 }
 647
 648 /* Force playback */
 649 void pcmbuf_play_start(void)
 650 {
 651     if (!pcm_is_playing() && pcmbuf_unplayed_bytes && read_chunk != NULL)
 652     {
 653         logf("pcmbuf_play_start");
 654         last_chunksize = read_chunk->size;
 655         pcmbuf_unplayed_bytes -= last_chunksize;
 656         pcm_play_data(pcmbuf_pcm_callback,
 657             (unsigned char *)read_chunk->addr, last_chunksize);
 658     }
 659 }
 660
 661 void pcmbuf_play_stop(void)
 662 {
 663     logf("pcmbuf_play_stop");
 664     pcm_play_stop();
 665
 666     pcmbuf_unplayed_bytes = 0;
 667     mix_chunk = NULL;
 668     if (read_chunk) {
 669         write_end_chunk->link = read_chunk;
 670         write_end_chunk = read_end_chunk;
 671         read_chunk = read_end_chunk = NULL;
 672     }
 673     pcmbuffer_pos = 0;
 674     pcmbuffer_fillpos = 0;
 675 #ifdef HAVE_CROSSFADE
 676     crossfade_track_change_started = false;
 677     crossfade_active = false;
 678 #endif
 679     end_of_track = false;
 680     track_transition = false;
 681     flush_pcmbuf = false;
 682     DISPLAY_DESC("play_stop");
 683
 684     /* Can unboost the codec thread here no matter who's calling */
 685     boost_codec_thread(false);
 686 }
 687
 688 void pcmbuf_pause(bool pause)
 689 {
 690     logf("pcmbuf_pause: %s", pause?"pause":"play");
 691     if (pcm_is_playing())
 692         pcm_play_pause(!pause);
 693     else if (!pause)
 694         pcmbuf_play_start();
 695 }
 696
 697
 698 /** Crossfade */
 699
 700 /* Clip sample to signed 16 bit range */
 701 static inline int32_t clip_sample_16(int32_t sample)
 702 {
 703     if ((int16_t)sample != sample)
 704         sample = 0x7fff ^ (sample >> 31);
 705     return sample;
 706 }
 707
 708 #ifdef HAVE_CROSSFADE
 709 /* Find the chunk that's (length) deep in the list. Return the position within
 710  * the chunk, and leave the chunkdesc pointer pointing to the chunk. */
 711 static size_t find_chunk(size_t length, struct chunkdesc **chunk)
 712 {
 713     while (*chunk && length >= (*chunk)->size)
 714     {
 715         length -= (*chunk)->size;
 716         *chunk = (*chunk)->link;
 717     }
 718     return length / 2;
 719 }
 720
 721 /* Returns the number of bytes _NOT_ mixed/faded */
 722 static size_t crossfade_mix_fade(int factor, size_t length, const char *buf,
 723                                  size_t *out_sample, struct chunkdesc **out_chunk)
 724 {
 725     const int16_t *input_buf = (const int16_t *)buf;
 726     int16_t *output_buf = (int16_t *)((*out_chunk)->addr);
 727     int16_t *chunk_end = SKIPBYTES(output_buf, (*out_chunk)->size);
 728     output_buf = &output_buf[*out_sample];
 729     int32_t sample;
 730
 731     while (length)
 732     {
 733         /* fade left and right channel at once to keep buffer alignment */
 734         int i;
 735         for (i = 0; i < 2; i++)
 736         {
 737             if (input_buf)
 738             /* fade the input buffer and mix into the chunk */
 739             {
 740                 sample = *input_buf++;
 741                 sample = ((sample * factor) >> 8) + *output_buf;
 742                 *output_buf++ = clip_sample_16(sample);
 743             }
 744             else
 745             /* fade the chunk only */
 746             {
 747                 sample = *output_buf;
 748                 *output_buf++ = (sample * factor) >> 8;
 749             }
 750         }
 751
 752         length -= 4; /* 2 samples, each 16 bit -> 4 bytes */
 753
 754         /* move to next chunk as needed */
 755         if (output_buf >= chunk_end)
 756         {
 757             *out_chunk = (*out_chunk)->link;
 758             if (!(*out_chunk))
 759                 return length;
 760             output_buf = (int16_t *)((*out_chunk)->addr);
 761             chunk_end = SKIPBYTES(output_buf, (*out_chunk)->size);
 762         }
 763     }
 764     *out_sample = output_buf - (int16_t *)((*out_chunk)->addr);
 765     return 0;
 766 }
 767
 768 /* Initializes crossfader, calculates all necessary parameters and performs
 769  * fade-out with the PCM buffer.  */
 770 static void crossfade_start(void)
 771 {
 772     size_t crossfade_rem;
 773     size_t crossfade_need;
 774     size_t fade_out_rem;
 775     size_t fade_out_delay;
 776     size_t fade_in_delay;
 777
 778     crossfade_track_change_started = false;
 779     /* Reject crossfade if less than .5s of data */
 780     if (LOW_DATA(2)) {
 781         logf("crossfade rejected");
 782         pcmbuf_play_stop();
 783         return ;
 784     }
 785
 786     logf("crossfade_start");
 787     commit_chunk(false);
 788     crossfade_active = true;
 789
 790     /* Initialize the crossfade buffer size to all of the buffered data that
 791      * has not yet been sent to the DMA */
 792     crossfade_rem = pcmbuf_unplayed_bytes;
 793     crossfade_chunk = read_chunk->link;
 794     crossfade_sample = 0;
 795
 796     /* Get fade out info from settings. */
 797     fade_out_delay = global_settings.crossfade_fade_out_delay * BYTERATE;
 798     fade_out_rem = global_settings.crossfade_fade_out_duration * BYTERATE;
 799
 800     crossfade_need = fade_out_delay + fade_out_rem;
 801     if (crossfade_rem > crossfade_need)
 802     {
 803         if (crossfade_auto_skip)
 804         /* Automatic track changes only modify the last part of the buffer,
 805          * so find the right chunk and sample to start the crossfade */
 806         {
 807             crossfade_sample = find_chunk(crossfade_rem - crossfade_need,
 808                 &crossfade_chunk);
 809             crossfade_rem = crossfade_need;
 810         }
 811         else
 812         /* Manual skips occur immediately, but give time to process */
 813         {
 814             crossfade_rem -= crossfade_chunk->size;
 815             crossfade_chunk = crossfade_chunk->link;
 816         }
 817     }
 818     /* Truncate fade out duration if necessary. */
 819     if (crossfade_rem < crossfade_need)
 820     {
 821         size_t crossfade_short = crossfade_need - crossfade_rem;
 822         if (fade_out_rem >= crossfade_short)
 823             fade_out_rem -= crossfade_short;
 824         else
 825         {
 826             fade_out_delay -= crossfade_short - fade_out_rem;
 827             fade_out_rem = 0;
 828         }
 829     }
 830     crossfade_rem -= fade_out_delay + fade_out_rem;
 831
 832     /* Completely process the crossfade fade-out effect with current PCM buffer */
 833     if (!crossfade_mixmode)
 834     {
 835         /* Fade out the specified amount of the already processed audio */
 836         size_t total_fade_out = fade_out_rem;
 837         size_t fade_out_sample;
 838         struct chunkdesc *fade_out_chunk = crossfade_chunk;
 839
 840         /* Find the right chunk and sample to start fading out */
 841         fade_out_delay += crossfade_sample * 2;
 842         fade_out_sample = find_chunk(fade_out_delay, &fade_out_chunk);
 843
 844         while (fade_out_rem > 0)
 845         {
 846             /* Each 1/10 second of audio will have the same fade applied */
 847             size_t block_rem = MIN(BYTERATE / 10, fade_out_rem);
 848             int factor = (fade_out_rem << 8) / total_fade_out;
 849
 850             fade_out_rem -= block_rem;
 851
 852             crossfade_mix_fade(factor, block_rem, NULL,
 853                 &fade_out_sample, &fade_out_chunk);
 854         }
 855
 856         /* zero out the rest of the buffer */
 857         crossfade_mix_fade(0, crossfade_rem, NULL,
 858             &fade_out_sample, &fade_out_chunk);
 859     }
 860
 861     /* Initialize fade-in counters */
 862     crossfade_fade_in_total = global_settings.crossfade_fade_in_duration * BYTERATE;
 863     crossfade_fade_in_rem = crossfade_fade_in_total;
 864
 865     fade_in_delay = global_settings.crossfade_fade_in_delay * BYTERATE;
 866
 867     /* Find the right chunk and sample to start fading in */
 868     fade_in_delay += crossfade_sample * 2;
 869     crossfade_sample = find_chunk(fade_in_delay, &crossfade_chunk);
 870     logf("crossfade_start done!");
 871 }
 872
 873 /* Perform fade-in of new track */
 874 static void write_to_crossfade(size_t length)
 875 {
 876     if (length)
 877     {
 878         char *buf = fadebuf;
 879         if (crossfade_fade_in_rem)
 880         {
 881             size_t samples;
 882             int16_t *input_buf;
 883
 884             /* Fade factor for this packet */
 885             int factor =
 886                 ((crossfade_fade_in_total - crossfade_fade_in_rem) << 8) /
 887                 crossfade_fade_in_total;
 888             /* Bytes to fade */
 889             size_t fade_rem = MIN(length, crossfade_fade_in_rem);
 890
 891             /* We _will_ fade this many bytes */
 892             crossfade_fade_in_rem -= fade_rem;
 893
 894             if (crossfade_chunk)
 895             {
 896                 /* Mix the data */
 897                 size_t fade_total = fade_rem;
 898                 fade_rem = crossfade_mix_fade(factor, fade_rem, buf,
 899                     &crossfade_sample, &crossfade_chunk);
 900                 length -= fade_total - fade_rem;
 901                 buf += fade_total - fade_rem;
 902                 if (!length)
 903                     return;
 904             }
 905
 906             samples = fade_rem / 2;
 907             input_buf = (int16_t *)buf;
 908             /* Fade remaining samples in place */
 909             while (samples--)
 910             {
 911                 int32_t sample = *input_buf;
 912                 *input_buf++ = (sample * factor) >> 8;
 913             }
 914         }
 915
 916         if (crossfade_chunk)
 917         {
 918             /* Mix the data */
 919             size_t mix_total = length;
 920             /* A factor of 256 means mix only, no fading */
 921             length = crossfade_mix_fade(256, length, buf,
 922                     &crossfade_sample, &crossfade_chunk);
 923             buf += mix_total - length;
 924             if (!length)
 925                 return;
 926         }
 927
 928         /* Commit samples to the buffer */
 929         while (!prepare_insert(length))
 930             sleep(1);
 931         while (length > 0)
 932         {
 933             COMMIT_IF_NEEDED;
 934             size_t pcmbuffer_index = pcmbuffer_pos + pcmbuffer_fillpos;
 935             size_t copy_n = MIN(length, pcmbuf_size - pcmbuffer_index);
 936             memcpy(&pcmbuffer[pcmbuffer_index], buf, copy_n);
 937             buf += copy_n;
 938             pcmbuffer_fillpos += copy_n;
 939             length -= copy_n;
 940         }
 941     }
 942     /* if no more fading-in to do, stop the crossfade */
 943     if (!(crossfade_fade_in_rem || crossfade_chunk))
 944         crossfade_active = false;
 945 }
 946
 947 static void pcmbuf_finish_crossfade_enable(void)
 948 {
 949     /* Copy the pending setting over now */
 950     crossfade_enabled = crossfade_enable_request;
 951
 952     pcmbuf_watermark = (crossfade_enabled && pcmbuf_size) ?
 953         /* If crossfading, try to keep the buffer full other than 1 second */
 954         (pcmbuf_size - BYTERATE) :
 955         /* Otherwise, just use the default */
 956         PCMBUF_WATERMARK;
 957 }
 958
 959 bool pcmbuf_is_crossfade_active(void)
 960 {
 961     return crossfade_active || crossfade_track_change_started;
 962 }
 963
 964 void pcmbuf_request_crossfade_enable(bool on_off)
 965 {
 966     /* Next setting to be used, not applied now */
 967     crossfade_enable_request = on_off;
 968 }
 969
 970 bool pcmbuf_is_same_size(void)
 971 {
 972     /* if pcmbuffer is NULL, then not set up yet even once so always */
 973     bool same_size = pcmbuffer ?
 974         (get_next_required_pcmbuf_size() == pcmbuf_size) : true;
 975
 976     /* no buffer change needed, so finish crossfade setup now */
 977     if (same_size)
 978         pcmbuf_finish_crossfade_enable();
 979
 980     return same_size;
 981 }
 982 #endif /* HAVE_CROSSFADE */
 983
 984
 985 /** Voice */
 986
 987 /* Returns pcm buffer usage in percents (0 to 100). */
 988 static int pcmbuf_usage(void)
 989 {
 990     return pcmbuf_unplayed_bytes * 100 / pcmbuf_size;
 991 }
 992
 993 static int pcmbuf_mix_free(void)
 994 {
 995     if (mix_chunk)
 996     {
 997         size_t my_mix_end =
 998             (size_t)&((int16_t *)mix_chunk->addr)[pcmbuf_mix_sample];
 999         size_t my_write_pos = (size_t)&pcmbuffer[pcmbuffer_pos];
1000         if (my_write_pos < my_mix_end)
1001             my_write_pos += pcmbuf_size;
1002         return (my_write_pos - my_mix_end) * 100 / pcmbuf_unplayed_bytes;
1003     }
1004     return 100;
1005 }
1006
1007 void *pcmbuf_request_voice_buffer(int *count)
1008 {
1009     /* A get-it-to-work-for-now hack (audio status could change by
1010        completion) */
1011     if (audio_status() & AUDIO_STATUS_PLAY)
1012     {
1013         if (read_chunk == NULL)
1014         {
1015             return NULL;
1016         }
1017         else if (pcmbuf_usage() >= 10 && pcmbuf_mix_free() >= 30 &&
1018                  (mix_chunk || read_chunk->link))
1019         {
1020             *count = MIN(*count, PCMBUF_MIX_CHUNK/4);
1021             return voicebuf;
1022         }
1023         else
1024         {
1025             return NULL;
1026         }
1027     }
1028     else
1029     {
1030         return pcmbuf_request_buffer(count);
1031     }
1032 }
1033
1034 void pcmbuf_write_voice_complete(int count)
1035 {
1036     /* A get-it-to-work-for-now hack (audio status could have changed) */
1037     if (!(audio_status() & AUDIO_STATUS_PLAY))
1038     {
1039         pcmbuf_write_complete(count);
1040         return;
1041     }
1042
1043     int16_t *ibuf = (int16_t *)voicebuf;
1044     int16_t *obuf;
1045     size_t chunk_samples;
1046
1047     if (mix_chunk == NULL && read_chunk != NULL)
1048     {
1049         mix_chunk = read_chunk->link;
1050         /* Start 1/8s into the next chunk */
1051         pcmbuf_mix_sample = BYTERATE / 16;
1052     }
1053
1054     if (!mix_chunk)
1055         return;
1056
1057     obuf = (int16_t *)mix_chunk->addr;
1058     chunk_samples = mix_chunk->size / sizeof (int16_t);
1059
1060     count <<= 1;
1061
1062     while (count-- > 0)
1063     {
1064         int32_t sample = *ibuf++;
1065
1066         if (pcmbuf_mix_sample >= chunk_samples)
1067         {
1068             mix_chunk = mix_chunk->link;
1069             if (!mix_chunk)
1070                 return;
1071             pcmbuf_mix_sample = 0;
1072             obuf = mix_chunk->addr;
1073             chunk_samples = mix_chunk->size / 2;
1074         }
1075         sample += obuf[pcmbuf_mix_sample] >> 2;
1076         obuf[pcmbuf_mix_sample++] = clip_sample_16(sample);
1077     }
1078 }
1079
1080
1081 /** Debug menu, other metrics */
1082
1083 /* Amount of bytes left in the buffer. */
1084 size_t pcmbuf_free(void)
1085 {
1086     if (read_chunk != NULL)
1087     {
1088         void *read = read_chunk->addr;
1089         void *write = &pcmbuffer[pcmbuffer_pos + pcmbuffer_fillpos];
1090         if (read < write)
1091             return (size_t)(read - write) + pcmbuf_size;
1092         else
1093             return (size_t) (read - write);
1094     }
1095     return pcmbuf_size - pcmbuffer_fillpos;
1096 }
1097
1098 size_t pcmbuf_get_bufsize(void)
1099 {
1100     return pcmbuf_size;
1101 }
1102
1103 int pcmbuf_used_descs(void)
1104 {
1105     struct chunkdesc *temp = read_chunk;
1106     unsigned int i = 0;
1107     while (temp) {
1108         temp = temp->link;
1109         i++;
1110     }
1111     return i;
1112 }
1113
1114 int pcmbuf_descs(void)
1115 {
1116     return NUM_CHUNK_DESCS(pcmbuf_size);
1117 }
1118
1119 #ifdef ROCKBOX_HAS_LOGF
1120 unsigned char *pcmbuf_get_meminfo(size_t *length)
1121 {
1122     *length = pcmbuf_bufend - pcmbuffer;
1123     return pcmbuffer;
1124 }
1125 #endif
1126
1127
1128 /** Misc */
1129
1130 bool pcmbuf_is_lowdata(void)
1131 {
1132     if (!pcm_is_playing() || pcm_is_paused()
1133 #ifdef HAVE_CROSSFADE
1134         || pcmbuf_is_crossfade_active()
1135 #endif
1136         )
1137         return false;
1138
1139 #if MEMORYSIZE > 2
1140     /* 1 seconds of buffer is low data */
1141     return LOW_DATA(4);
1142 #else
1143     /* under watermark is low data */
1144     return (pcmbuf_unplayed_bytes < pcmbuf_watermark);
1145 #endif
1146 }
1147
1148 void pcmbuf_set_low_latency(bool state)
1149 {
1150     low_latency_mode = state;
1151 }
1152
1153 unsigned long pcmbuf_get_latency(void)
1154 {
1155     return (pcmbuf_unplayed_bytes + pcm_get_bytes_waiting()) * 1000 / BYTERATE;
1156 }
1157
1158 #ifndef HAVE_HARDWARE_BEEP
1159 #define MINIBUF_SAMPLES (NATIVE_FREQUENCY / 1000 * KEYCLICK_DURATION)
1160 #define MINIBUF_SIZE (MINIBUF_SAMPLES*4)
1161
1162 /* Generates a constant square wave sound with a given frequency
1163    in Hertz for a duration in milliseconds. */
1164 void pcmbuf_beep(unsigned int frequency, size_t duration, int amplitude)
1165 {
1166     unsigned int step = 0xffffffffu / NATIVE_FREQUENCY * frequency;
1167     int32_t phase = 0;
1168     int16_t *bufptr, *bufstart, *bufend;
1169     int32_t sample;
1170     int nsamples = NATIVE_FREQUENCY / 1000 * duration;
1171     bool mix = read_chunk != NULL && read_chunk->link != NULL;
1172     int i;
1173
1174     bufend = SKIPBYTES((int16_t *)pcmbuffer, pcmbuf_size);
1175
1176     /* Find the insertion point and set bufstart to the start of it */
1177     if (mix)
1178     {
1179         /* Get the currently playing chunk at the current position. */
1180         bufstart = (int16_t *)pcm_play_dma_get_peak_buffer(&i);
1181
1182         /* If above isn't implemented or pcm is stopped, no beepeth. */
1183         if (!bufstart || !pcm_is_playing())
1184             return;
1185
1186         /* Give 5ms clearance. */
1187         bufstart += BYTERATE / 200;
1188
1189 #ifdef HAVE_PCM_DMA_ADDRESS
1190         /* Returned peak addresses are DMA addresses */
1191         bufend = pcm_dma_addr(bufend);
1192 #endif
1193
1194         /* Wrapped above? */
1195         if (bufstart >= bufend)
1196             bufstart -= pcmbuf_size;
1197
1198         /* NOTE: On some targets using hardware DMA, cache range flushing may
1199          * be required or the writes may not be picked up by the controller.
1200          * An incremental flush should be done periodically during the mixdown. */
1201     }
1202     else if (nsamples <= MINIBUF_SAMPLES)
1203     {
1204         static int16_t minibuf[MINIBUF_SAMPLES*2] __attribute__((aligned(4)));
1205         /* Use mini buffer */
1206         bufstart = minibuf;
1207         bufend = SKIPBYTES(bufstart, MINIBUF_SIZE);
1208     }
1209     else if (!audio_buffer_state_trashed())
1210     {
1211         /* Use pcmbuffer */
1212         bufstart = (int16_t *)pcmbuffer;
1213     }
1214     else
1215     {
1216         /* No place */
1217         return;
1218     }
1219
1220     bufptr = bufstart;
1221
1222     /* Mix square wave into buffer */
1223     for (i = 0; i < nsamples; ++i)
1224     {
1225         int32_t amp = (phase >> 31) ^ (int32_t)amplitude;
1226         sample = mix ? *bufptr : 0;
1227         *bufptr++ = clip_sample_16(sample + amp);
1228         if (bufptr >= bufend)
1229             bufptr = (int16_t *)pcmbuffer;
1230         sample = mix ? *bufptr : 0;
1231         *bufptr++ = clip_sample_16(sample + amp);
1232         if (bufptr >= bufend)
1233             bufptr = (int16_t *)pcmbuffer;
1234
1235         phase += step;
1236     }
1237
1238     pcm_play_lock();
1239 #ifdef HAVE_RECORDING
1240     pcm_rec_lock();
1241 #endif
1242
1243     /* Kick off playback if required and it won't interfere */
1244     if (!pcm_is_playing()
1245 #ifdef HAVE_RECORDING
1246         && !pcm_is_recording()
1247 #endif
1248         )
1249     {
1250         pcm_play_data(NULL, (unsigned char *)bufstart, nsamples * 4);
1251     }
1252
1253     pcm_play_unlock();
1254 #ifdef HAVE_RECORDING
1255     pcm_rec_unlock();
1256 #endif
1257 }
1258 #endif /* HAVE_HARDWARE_BEEP */