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  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include <stdbool.h>
  21 #include <stdio.h>
  22 #include "config.h"
  23 #include "debug.h"
  24 #include "panic.h"
  25 #include <kernel.h>
  26 #include "pcmbuf.h"
  27 #include "pcm_playback.h"
  28 #include "logf.h"
  29 #ifndef SIMULATOR
  30 #include "cpu.h"
  31 #endif
  32 #include "system.h"
  33 #include <string.h>
  34 #include "buffer.h"
  35 #include "settings.h"
  36 #include "audio.h"
  37 #include "dsp.h"
  38 #include "thread.h"
  39
  40 /* Define PCMBUF_MUTING if the codec requires muting to prevent pops */
  41 #if !defined(HAVE_UDA1380) && !defined(HAVE_TLV320) && !defined(HAVE_AS3514)
  42 #define PCMBUF_MUTING
  43 #endif
  44
  45 /* Keep watermark high for iPods at least (2s) */
  46 #define PCMBUF_WATERMARK     (NATIVE_FREQUENCY * 4 * 2)
  47
  48 /* Structure we can use to queue pcm chunks in memory to be played
  49  * by the driver code. */
  50 struct pcmbufdesc
  51 {
  52     void *addr;
  53     size_t size;
  54     struct pcmbufdesc* link;
  55     /* Call this when the buffer has been played */
  56     void (*callback)(void);
  57 };
  58
  59 #define PCMBUF_DESCS(bufsize) \
  60     ((bufsize) / PCMBUF_MINAVG_CHUNK)
  61 #define PCMBUF_DESCS_SIZE(bufsize) \
  62     (PCMBUF_DESCS(bufsize)*sizeof(struct pcmbufdesc))
  63
  64 /* Size of the PCM buffer. */
  65 static size_t pcmbuf_size IDATA_ATTR = 0;
  66 static char *pcmbuf_bufend IDATA_ATTR;
  67 static char *audiobuffer IDATA_ATTR;
  68 /* Current audio buffer write index. */
  69 static size_t audiobuffer_pos IDATA_ATTR;
  70 /* Amount audiobuffer_pos will be increased.*/
  71 static size_t audiobuffer_fillpos IDATA_ATTR;
  72 static char *fadebuf IDATA_ATTR;
  73 static char *voicebuf IDATA_ATTR;
  74
  75 static void (*pcmbuf_event_handler)(void) IDATA_ATTR;
  76 static void (*position_callback)(size_t size) IDATA_ATTR;
  77
  78 /* Crossfade related state */
  79 static bool crossfade_enabled;
  80 static bool crossfade_enabled_pending;
  81 static bool crossfade_mixmode;
  82 static bool crossfade_active IDATA_ATTR;
  83 static bool crossfade_init IDATA_ATTR;
  84
  85 /* Track the current location for processing crossfade */
  86 static struct pcmbufdesc *crossfade_chunk IDATA_ATTR;
  87 static size_t crossfade_sample IDATA_ATTR;
  88
  89 /* Counters for fading in new data */
  90 static size_t crossfade_fade_in_total IDATA_ATTR;
  91 static size_t crossfade_fade_in_rem IDATA_ATTR;
  92
  93 static size_t pcmbuf_descsize;
  94 static struct pcmbufdesc *pcmbuf_read IDATA_ATTR;
  95 static struct pcmbufdesc *pcmbuf_read_end IDATA_ATTR;
  96 static struct pcmbufdesc *pcmbuf_write IDATA_ATTR;
  97 static struct pcmbufdesc *pcmbuf_write_end IDATA_ATTR;
  98 static size_t last_chunksize IDATA_ATTR;
  99
 100 static size_t pcmbuf_unplayed_bytes IDATA_ATTR;
 101 static size_t pcmbuf_watermark IDATA_ATTR;
 102
 103 static struct pcmbufdesc *pcmbuf_mix_chunk IDATA_ATTR;
 104 static size_t pcmbuf_mix_sample IDATA_ATTR;
 105
 106 static bool low_latency_mode = false;
 107 static bool pcmbuf_flush;
 108
 109 #ifdef HAVE_PRIORITY_SCHEDULING
 110 static int codec_thread_priority = 0;
 111 #endif
 112
 113 extern struct thread_entry *codec_thread_p;
 114
 115 /* Helpful macros for use in conditionals this assumes some of the above
 116  * static variable names */
 117 #define NEED_FLUSH(position) \
 118     (audiobuffer_fillpos > PCMBUF_TARGET_CHUNK || position >= pcmbuf_size)
 119 #define LOW_DATA(quarter_secs) \
 120     (pcmbuf_unplayed_bytes < NATIVE_FREQUENCY * quarter_secs)
 121
 122 static bool prepare_insert(size_t length);
 123 static void pcmbuf_under_watermark(void);
 124 static bool pcmbuf_flush_fillpos(void);
 125
 126 #define CALL_IF_EXISTS(function, args...) if (function) function(args)
 127 /* This function has 2 major logical parts (separated by brackets both for
 128  * readability and variable scoping).  The first part performs the
 129  * operastions related to finishing off the last buffer we fed to the DMA.
 130  * The second part performs the operations involved in sending a new buffer
 131  * to the DMA.  Finally the function checks the status of the buffer and
 132  * boosts if necessary */
 133 static void pcmbuf_callback(unsigned char** start, size_t* size) ICODE_ATTR;
 134 static void pcmbuf_callback(unsigned char** start, size_t* size)
 135 {
 136     {
 137         struct pcmbufdesc *pcmbuf_current = pcmbuf_read;
 138         /* Take the finished buffer out of circulation */
 139         pcmbuf_read = pcmbuf_current->link;
 140
 141         /* The buffer is finished, call the callback functions */
 142         CALL_IF_EXISTS(position_callback, last_chunksize);
 143         CALL_IF_EXISTS(pcmbuf_current->callback);
 144
 145         /* Put the finished buffer back into circulation */
 146         pcmbuf_write_end->link = pcmbuf_current;
 147         pcmbuf_write_end = pcmbuf_current;
 148
 149         /* If we've read over the mix chunk while it's still mixing there */
 150         if (pcmbuf_current == pcmbuf_mix_chunk)
 151             pcmbuf_mix_chunk = NULL;
 152         /* If we've read over the crossfade chunk while it's still fading */
 153         if (pcmbuf_current == crossfade_chunk)
 154             crossfade_chunk = pcmbuf_read;
 155     }
 156
 157 process_new_buffer:
 158     {
 159         /* Send the new buffer to the pcm */
 160         struct pcmbufdesc *pcmbuf_new = pcmbuf_read;
 161         size_t *realsize = size;
 162         unsigned char** realstart = start;
 163         if(pcmbuf_new)
 164         {
 165             size_t current_size = pcmbuf_new->size;
 166
 167             pcmbuf_unplayed_bytes -= current_size;
 168             last_chunksize = current_size;
 169             *realsize = current_size;
 170             *realstart = pcmbuf_new->addr;
 171         }
 172         else
 173         {
 174             /* There may be more data waiting to flush, try to use it */
 175             if (pcmbuf_flush_fillpos())
 176                 goto process_new_buffer;
 177
 178             /* No more buffers */
 179             last_chunksize = 0;
 180             *realsize = 0;
 181             *realstart = NULL;
 182             CALL_IF_EXISTS(pcmbuf_event_handler);
 183         }
 184     }
 185 }
 186
 187 void pcmbuf_set_position_callback(void (*callback)(size_t size))
 188 {
 189     position_callback = callback;
 190 }
 191
 192 static void pcmbuf_set_watermark_bytes(void)
 193 {
 194     pcmbuf_watermark = (crossfade_enabled && pcmbuf_size) ?
 195         /* If crossfading, try to keep the buffer full other than 1 second */
 196         (pcmbuf_size - (NATIVE_FREQUENCY * 4 * 1)) :
 197         /* Otherwise, just keep it above 2 second */
 198         PCMBUF_WATERMARK;
 199 }
 200
 201 /* This is really just part of pcmbuf_flush_fillpos, but is easier to keep
 202  * in a separate function for the moment */
 203 static inline void pcmbuf_add_chunk(void)
 204 {
 205     register size_t size = audiobuffer_fillpos;
 206     /* Grab the next description to write, and change the write pointer */
 207     register struct pcmbufdesc *pcmbuf_current = pcmbuf_write;
 208     pcmbuf_write = pcmbuf_current->link;
 209     /* Fill in the values in the new buffer chunk */
 210     pcmbuf_current->addr = &audiobuffer[audiobuffer_pos];
 211     pcmbuf_current->size = size;
 212     pcmbuf_current->callback = pcmbuf_event_handler;
 213     pcmbuf_current->link = NULL;
 214     /* This is single use only */
 215     pcmbuf_event_handler = NULL;
 216     if (pcmbuf_read != NULL) {
 217         if (pcmbuf_flush)
 218         {
 219             pcmbuf_write_end->link = pcmbuf_read->link;
 220             pcmbuf_read->link = pcmbuf_current;
 221             while (pcmbuf_write_end->link)
 222             {
 223                 pcmbuf_write_end = pcmbuf_write_end->link;
 224                 pcmbuf_unplayed_bytes -= pcmbuf_write_end->size;
 225             }
 226             pcmbuf_flush = false;
 227         }
 228         /* If there is already a read buffer setup, add to it */
 229         else
 230             pcmbuf_read_end->link = pcmbuf_current;
 231     } else {
 232         /* Otherwise create the buffer */
 233         pcmbuf_read = pcmbuf_current;
 234     }
 235     /* This is now the last buffer to read */
 236     pcmbuf_read_end = pcmbuf_current;
 237
 238     /* Update bytes counters */
 239     pcmbuf_unplayed_bytes += size;
 240
 241     audiobuffer_pos += size;
 242     if (audiobuffer_pos >= pcmbuf_size)
 243         audiobuffer_pos -= pcmbuf_size;
 244
 245     audiobuffer_fillpos = 0;
 246 }
 247
 248 #ifdef HAVE_PRIORITY_SCHEDULING
 249 static void boost_codec_thread(bool boost)
 250 {
 251     if (boost)
 252     {
 253         if (codec_thread_priority == 0)
 254             codec_thread_priority = thread_set_priority(
 255                 codec_thread_p, PRIORITY_REALTIME);
 256     }
 257     else if (codec_thread_priority != 0)
 258     {
 259         thread_set_priority(codec_thread_p, codec_thread_priority);
 260         codec_thread_priority = 0;
 261     }
 262 }
 263 #endif /* HAVE_PRIORITY_SCHEDULING */
 264
 265 static void pcmbuf_under_watermark(void)
 266 {
 267     /* Only codec thread initiates boost - voice boosts the cpu when playing
 268        a clip */
 269 #ifndef SIMULATOR
 270     if (thread_get_current() == codec_thread_p)
 271 #endif /* SIMULATOR */
 272     {
 273 #ifdef HAVE_PRIORITY_SCHEDULING
 274         /* If buffer is critically low, override UI priority, else
 275            set back to the original priority. */
 276         boost_codec_thread(LOW_DATA(2) && pcm_is_playing());
 277 #endif
 278         /* Fill audio buffer by boosting cpu */
 279         trigger_cpu_boost();
 280     }
 281
 282     /* Disable crossfade if < .5s of audio */
 283     if (LOW_DATA(2))
 284     {
 285         crossfade_active = false;
 286     }
 287 }
 288
 289 void pcmbuf_set_event_handler(void (*event_handler)(void))
 290 {
 291     pcmbuf_event_handler = event_handler;
 292 }
 293
 294 unsigned int pcmbuf_get_latency(void)
 295 {
 296     /* Be careful how this calculation is rearranted, it's easy to overflow */
 297     size_t bytes = pcmbuf_unplayed_bytes + pcm_get_bytes_waiting();
 298     return bytes / 4 / (NATIVE_FREQUENCY/1000);
 299 }
 300
 301 void pcmbuf_set_low_latency(bool state)
 302 {
 303     low_latency_mode = state;
 304 }
 305
 306 bool pcmbuf_is_lowdata(void)
 307 {
 308     if (!pcm_is_playing() || pcm_is_paused() ||
 309             crossfade_init || crossfade_active)
 310         return false;
 311
 312     /* 1 seconds of buffer is low data */
 313     return LOW_DATA(4);
 314 }
 315
 316 /* Amount of bytes left in the buffer. */
 317 inline size_t pcmbuf_free(void)
 318 {
 319     if (pcmbuf_read != NULL)
 320     {
 321         void *read = pcmbuf_read->addr;
 322         void *write = &audiobuffer[audiobuffer_pos + audiobuffer_fillpos];
 323         if (read < write)
 324             return (size_t)(read - write) + pcmbuf_size;
 325         else
 326             return (size_t) (read - write);
 327     }
 328     return pcmbuf_size;
 329 }
 330
 331 bool pcmbuf_crossfade_init(bool manual_skip)
 332 {
 333     /* Can't do two crossfades at once and, no fade if pcm is off now */
 334     if (crossfade_init || crossfade_active || !pcm_is_playing())
 335     {
 336         pcmbuf_play_stop();
 337         return false;
 338     }
 339
 340     trigger_cpu_boost();
 341
 342     /* Not enough data, or crossfade disabled, flush the old data instead */
 343     if (LOW_DATA(2) || !pcmbuf_is_crossfade_enabled() || low_latency_mode)
 344     {
 345         pcmbuf_flush_fillpos();
 346         pcmbuf_flush = true;
 347         return false;
 348     }
 349
 350     /* Don't enable mix mode when skipping tracks manually. */
 351     if (manual_skip)
 352         crossfade_mixmode = false;
 353     else
 354         crossfade_mixmode = global_settings.crossfade_fade_out_mixmode;
 355
 356     crossfade_init = true;
 357
 358     return true;
 359
 360 }
 361
 362 void pcmbuf_play_stop(void)
 363 {
 364     pcm_play_stop();
 365
 366     pcmbuf_unplayed_bytes = 0;
 367     pcmbuf_mix_chunk = NULL;
 368     if (pcmbuf_read) {
 369         pcmbuf_write_end->link = pcmbuf_read;
 370         pcmbuf_write_end = pcmbuf_read_end;
 371         pcmbuf_read = pcmbuf_read_end = NULL;
 372     }
 373     audiobuffer_pos = 0;
 374     audiobuffer_fillpos = 0;
 375     crossfade_init = false;
 376     crossfade_active = false;
 377     pcmbuf_flush = false;
 378
 379 #ifdef HAVE_PRIORITY_SCHEDULING
 380     /* Can unboost the codec thread here no matter who's calling */
 381     boost_codec_thread(false);
 382 #endif
 383 }
 384
 385 int pcmbuf_used_descs(void) {
 386     struct pcmbufdesc *pcmbuf_temp = pcmbuf_read;
 387     unsigned int i = 0;
 388     while (pcmbuf_temp) {
 389         pcmbuf_temp = pcmbuf_temp->link;
 390         i++;
 391     }
 392     return i;
 393 }
 394
 395 int pcmbuf_descs(void) {
 396     return PCMBUF_DESCS(pcmbuf_size);
 397 }
 398
 399 size_t get_pcmbuf_descsize(void) {
 400     return pcmbuf_descsize;
 401 }
 402
 403 static void pcmbuf_init_pcmbuffers(void) {
 404     struct pcmbufdesc *next = pcmbuf_write;
 405     next++;
 406     pcmbuf_write_end = pcmbuf_write;
 407     while ((void *)next < (void *)pcmbuf_bufend) {
 408         pcmbuf_write_end->link=next;
 409         pcmbuf_write_end=next;
 410         next++;
 411     }
 412 }
 413
 414 static size_t pcmbuf_get_next_required_pcmbuf_size(void)
 415 {
 416 #if MEM > 1
 417     size_t seconds = 1;
 418
 419     if (crossfade_enabled_pending)
 420         seconds += global_settings.crossfade_fade_out_delay
 421                    + global_settings.crossfade_fade_out_duration;
 422
 423     /* Buffer has to be at least 2s long. */
 424     seconds += 2;
 425     logf("pcmbuf len: %ld", seconds);
 426     return seconds * (NATIVE_FREQUENCY*4);
 427 #else
 428     return NATIVE_FREQUENCY*2;
 429 #endif
 430 }
 431
 432 static char *pcmbuf_calc_audiobuffer_ptr(size_t bufsize)
 433 {
 434     return pcmbuf_bufend - (bufsize + PCMBUF_MIX_CHUNK * 2 +
 435                PCMBUF_DESCS_SIZE(bufsize));
 436 }
 437
 438 bool pcmbuf_is_same_size(void)
 439 {
 440     if (audiobuffer == NULL)
 441         return true; /* Not set up yet even once so always */
 442
 443     size_t bufsize = pcmbuf_get_next_required_pcmbuf_size();
 444     return pcmbuf_calc_audiobuffer_ptr(bufsize) == audiobuffer;
 445 }
 446
 447 /* Initialize the pcmbuffer the structure looks like this:
 448  * ...|---------PCMBUF---------|FADEBUF|VOICEBUF|DESCS|... */
 449 size_t pcmbuf_init(unsigned char *bufend)
 450 {
 451     pcmbuf_bufend = bufend;
 452     pcmbuf_size = pcmbuf_get_next_required_pcmbuf_size();
 453     audiobuffer = pcmbuf_calc_audiobuffer_ptr(pcmbuf_size);
 454     fadebuf = &audiobuffer[pcmbuf_size];
 455     voicebuf = &fadebuf[PCMBUF_MIX_CHUNK];
 456     pcmbuf_write = (struct pcmbufdesc *)&voicebuf[PCMBUF_MIX_CHUNK];
 457
 458     pcmbuf_descsize = PCMBUF_DESCS_SIZE(pcmbuf_size);
 459     pcmbuf_init_pcmbuffers();
 460
 461     position_callback = NULL;
 462     pcmbuf_event_handler = NULL;
 463
 464     pcmbuf_crossfade_enable_finished();
 465
 466     pcmbuf_play_stop();
 467
 468     return pcmbuf_bufend - audiobuffer;
 469 }
 470
 471 size_t pcmbuf_get_bufsize(void)
 472 {
 473     return pcmbuf_size;
 474 }
 475
 476 #ifdef ROCKBOX_HAS_LOGF
 477 unsigned char * pcmbuf_get_meminfo(size_t *length)
 478 {
 479     *length = pcmbuf_bufend - audiobuffer;
 480     return audiobuffer;
 481 }
 482 #endif
 483
 484 void pcmbuf_pause(bool pause)
 485 {
 486 #ifdef PCMBUF_MUTING
 487     if (pause)
 488        pcm_mute(true);
 489 #endif
 490     pcm_play_pause(!pause);
 491 #ifdef PCMBUF_MUTING
 492     if (!pause)
 493         pcm_mute(false);
 494 #endif
 495     trigger_cpu_boost();
 496 }
 497
 498 /* Force playback. */
 499 void pcmbuf_play_start(void)
 500 {
 501     if (!pcm_is_playing() && pcmbuf_unplayed_bytes && pcmbuf_read != NULL)
 502     {
 503         last_chunksize = pcmbuf_read->size;
 504         pcmbuf_unplayed_bytes -= last_chunksize;
 505         pcm_play_data(pcmbuf_callback,
 506             (unsigned char *)pcmbuf_read->addr, last_chunksize);
 507     }
 508 }
 509
 510 /**
 511  * Commit samples waiting to the pcm buffer.
 512  */
 513 static bool pcmbuf_flush_fillpos(void)
 514 {
 515     if (audiobuffer_fillpos) {
 516         /* Never use the last buffer descriptor */
 517         while (pcmbuf_write == pcmbuf_write_end) {
 518             /* If this happens, something is being stupid */
 519             if (!pcm_is_playing()) {
 520                 logf("pcmbuf_flush_fillpos error");
 521                 pcmbuf_play_start();
 522             }
 523             /* Let approximately one chunk of data playback */
 524             sleep(HZ*PCMBUF_TARGET_CHUNK/(NATIVE_FREQUENCY*4));
 525         }
 526         pcmbuf_add_chunk();
 527         return true;
 528     }
 529     return false;
 530 }
 531
 532 /**
 533  * Completely process the crossfade fade out effect with current pcm buffer.
 534  */
 535 static void crossfade_process_buffer(size_t fade_in_delay,
 536         size_t fade_out_delay, size_t fade_out_rem)
 537 {
 538     if (!crossfade_mixmode)
 539     {
 540         /* Fade out the specified amount of the already processed audio */
 541         size_t total_fade_out = fade_out_rem;
 542         size_t fade_out_sample;
 543         struct pcmbufdesc *fade_out_chunk = crossfade_chunk;
 544
 545         /* Find the right chunk to start fading out */
 546         fade_out_delay += crossfade_sample * 2;
 547         while (fade_out_delay != 0 && fade_out_delay >= fade_out_chunk->size)
 548         {
 549             fade_out_delay -= fade_out_chunk->size;
 550             fade_out_chunk = fade_out_chunk->link;
 551         }
 552         /* The start sample within the chunk */
 553         fade_out_sample = fade_out_delay / 2;
 554
 555         while (fade_out_rem > 0)
 556         {
 557             /* Each 1/10 second of audio will have the same fade applied */
 558             size_t block_rem = MIN(NATIVE_FREQUENCY * 4 / 10, fade_out_rem);
 559             int factor = (fade_out_rem << 8) / total_fade_out;
 560
 561             fade_out_rem -= block_rem;
 562
 563             /* Fade this block */
 564             while (block_rem > 0 && fade_out_chunk != NULL)
 565             {
 566                 /* Fade one sample */
 567                 short *buf = (short *)(fade_out_chunk->addr);
 568                 int sample = buf[fade_out_sample];
 569                 buf[fade_out_sample++] = (sample * factor) >> 8;
 570
 571                 block_rem -= 2;
 572                 /* Move to the next chunk as needed */
 573                 if (fade_out_sample * 2 >= fade_out_chunk->size)
 574                 {
 575                     fade_out_chunk = fade_out_chunk->link;
 576                     fade_out_sample = 0;
 577                 }
 578             }
 579         }
 580     }
 581
 582     /* Find the right chunk and sample to start fading in */
 583     fade_in_delay += crossfade_sample * 2;
 584     while (fade_in_delay != 0 && fade_in_delay >= crossfade_chunk->size)
 585     {
 586         fade_in_delay -= crossfade_chunk->size;
 587         crossfade_chunk = crossfade_chunk->link;
 588     }
 589     crossfade_sample = fade_in_delay / 2;
 590     logf("process done!");
 591 }
 592
 593 /* Initializes crossfader, calculates all necessary parameters and
 594  * performs fade-out with the pcm buffer.  */
 595 static void crossfade_start(void)
 596 {
 597     size_t crossfade_rem;
 598     size_t crossfade_need;
 599     size_t fade_out_rem;
 600     size_t fade_out_delay;
 601     size_t fade_in_delay;
 602
 603     crossfade_init = false;
 604     /* Reject crossfade if less than .5s of data */
 605     if (LOW_DATA(2)) {
 606         logf("crossfade rejected");
 607         pcmbuf_play_stop();
 608         return ;
 609     }
 610
 611     logf("crossfade_start");
 612     pcmbuf_flush_fillpos();
 613     crossfade_active = true;
 614
 615     /* Initialize the crossfade buffer size to all of the buffered data that
 616      * has not yet been sent to the DMA */
 617     crossfade_rem = pcmbuf_unplayed_bytes;
 618     crossfade_chunk = pcmbuf_read->link;
 619     crossfade_sample = 0;
 620
 621     /* Get fade out delay from settings. */
 622     fade_out_delay =
 623         NATIVE_FREQUENCY * global_settings.crossfade_fade_out_delay * 4;
 624
 625     /* Get fade out duration from settings. */
 626     fade_out_rem =
 627         NATIVE_FREQUENCY * global_settings.crossfade_fade_out_duration * 4;
 628
 629     crossfade_need = fade_out_delay + fade_out_rem;
 630     /* We want only to modify the last part of the buffer. */
 631     if (crossfade_rem > crossfade_need)
 632     {
 633         size_t crossfade_extra = crossfade_rem - crossfade_need;
 634         while (crossfade_extra > crossfade_chunk->size)
 635         {
 636             crossfade_extra -= crossfade_chunk->size;
 637             crossfade_chunk = crossfade_chunk->link;
 638         }
 639         crossfade_sample = crossfade_extra / 2;
 640     }
 641     /* Truncate fade out duration if necessary. */
 642     else if (crossfade_rem < crossfade_need)
 643     {
 644         size_t crossfade_short = crossfade_need - crossfade_rem;
 645         if (fade_out_rem >= crossfade_short)
 646             fade_out_rem -= crossfade_short;
 647         else
 648         {
 649             fade_out_delay -= crossfade_short - fade_out_rem;
 650             fade_out_rem = 0;
 651         }
 652     }
 653
 654     /* Get also fade in duration and delays from settings. */
 655     crossfade_fade_in_total =
 656         NATIVE_FREQUENCY * global_settings.crossfade_fade_in_duration * 4;
 657     crossfade_fade_in_rem = crossfade_fade_in_total;
 658
 659     fade_in_delay =
 660         NATIVE_FREQUENCY * global_settings.crossfade_fade_in_delay * 4;
 661
 662     crossfade_process_buffer(fade_in_delay, fade_out_delay, fade_out_rem);
 663 }
 664
 665 /* Returns the number of bytes _NOT_ mixed */
 666 static size_t crossfade_fade_mix(int factor, const char *buf, size_t fade_rem)
 667 {
 668     const short *input_buf = (const short *)buf;
 669     short *output_buf = (short *)(crossfade_chunk->addr);
 670     short *chunk_end = (short *)((size_t)output_buf + crossfade_chunk->size);
 671     output_buf = &output_buf[crossfade_sample];
 672
 673     while (fade_rem)
 674     {
 675         int sample = *input_buf++;
 676         sample = ((sample * factor) >> 8) + *output_buf;
 677         *output_buf++ = MIN(32767, MAX(-32768, sample));
 678         fade_rem -= 2;
 679
 680         if (output_buf >= chunk_end)
 681         {
 682             crossfade_chunk = crossfade_chunk->link;
 683             if (!crossfade_chunk)
 684                 return fade_rem;
 685             output_buf = (short *)(crossfade_chunk->addr);
 686             chunk_end = (short *)((size_t)output_buf + crossfade_chunk->size);
 687         }
 688     }
 689     crossfade_sample = (size_t)(output_buf - (short *)(crossfade_chunk->addr));
 690     return 0;
 691 }
 692
 693 /* Returns the number of bytes _NOT_ mixed */
 694 static size_t crossfade_mix(const char *buf, size_t length)
 695 {
 696     const short *input_buf = (const short *)buf;
 697     short *output_buf = (short *)(crossfade_chunk->addr);
 698     short *chunk_end = (short *)((size_t)output_buf + crossfade_chunk->size);
 699     output_buf = &output_buf[crossfade_sample];
 700
 701     while (length)
 702     {
 703         int sample = *input_buf++ + *output_buf;
 704         *output_buf++ = MIN(32767, MAX(-32768, sample));
 705         length -= 2;
 706
 707         if (output_buf >= chunk_end)
 708         {
 709             crossfade_chunk = crossfade_chunk->link;
 710             if (!crossfade_chunk)
 711                 return length;
 712             output_buf = (short *)(crossfade_chunk->addr);
 713             chunk_end = (short *)((size_t)output_buf + crossfade_chunk->size);
 714         }
 715     }
 716     crossfade_sample = (size_t)(output_buf - (short *)(crossfade_chunk->addr));
 717     return 0;
 718 }
 719
 720 static void pcmbuf_flush_buffer(const char *buf, size_t length)
 721 {
 722     size_t copy_n;
 723     while (length > 0) {
 724         size_t audiobuffer_index = audiobuffer_pos + audiobuffer_fillpos;
 725         if (NEED_FLUSH(audiobuffer_index))
 726         {
 727             pcmbuf_flush_fillpos();
 728             audiobuffer_index = audiobuffer_pos + audiobuffer_fillpos;
 729         }
 730         copy_n = MIN(length, pcmbuf_size - audiobuffer_index);
 731         memcpy(&audiobuffer[audiobuffer_index], buf, copy_n);
 732         buf += copy_n;
 733         audiobuffer_fillpos += copy_n;
 734         length -= copy_n;
 735     }
 736 }
 737
 738 static void flush_crossfade(char *buf, size_t length)
 739 {
 740     if (length)
 741     {
 742         if (crossfade_fade_in_rem)
 743         {
 744             size_t samples;
 745             short *input_buf;
 746
 747             /* Fade factor for this packet */
 748             int factor =
 749                 ((crossfade_fade_in_total - crossfade_fade_in_rem) << 8) /
 750                 crossfade_fade_in_total;
 751             /* Bytes to fade */
 752             size_t fade_rem = MIN(length, crossfade_fade_in_rem);
 753
 754             /* We _will_ fade this many bytes */
 755             crossfade_fade_in_rem -= fade_rem;
 756
 757             if (crossfade_chunk)
 758             {
 759                 /* Mix the data */
 760                 size_t fade_total = fade_rem;
 761                 fade_rem = crossfade_fade_mix(factor, buf, fade_rem);
 762                 length -= fade_total - fade_rem;
 763                 buf += fade_total - fade_rem;
 764                 if (!length)
 765                     return;
 766                 if (!fade_rem)
 767                     goto fade_done;
 768             }
 769
 770             samples = fade_rem / 2;
 771             input_buf = (short *)buf;
 772             /* Fade remaining samples in place */
 773             while (samples)
 774             {
 775                 int sample = *input_buf;
 776                 *input_buf++ = (sample * factor) >> 8;
 777                 samples--;
 778             }
 779         }
 780
 781 fade_done:
 782         if (crossfade_chunk)
 783         {
 784             /* Mix the data */
 785             size_t mix_total = length;
 786             length = crossfade_mix(buf, length);
 787             buf += mix_total - length;
 788             if (!length)
 789                 return;
 790         }
 791
 792         /* Flush samples to the buffer */
 793         while (!prepare_insert(length))
 794             sleep(1);
 795         pcmbuf_flush_buffer(buf, length);
 796     }
 797
 798 }
 799
 800 static bool prepare_insert(size_t length)
 801 {
 802     if (low_latency_mode)
 803     {
 804         /* 1/4s latency. */
 805         if (pcmbuf_unplayed_bytes > NATIVE_FREQUENCY * 4 / 4
 806             && pcm_is_playing())
 807             return false;
 808     }
 809
 810     /* Need to save PCMBUF_MIN_CHUNK to prevent wrapping overwriting */
 811     if (pcmbuf_free() < length + PCMBUF_MIN_CHUNK)
 812         return false;
 813
 814     if (!pcm_is_playing())
 815     {
 816         trigger_cpu_boost();
 817
 818         /* Pre-buffer 1s. */
 819 #if MEM <= 1
 820         if (!LOW_DATA(1))
 821 #else
 822         if (!LOW_DATA(4))
 823 #endif
 824         {
 825             logf("pcm starting");
 826             pcmbuf_play_start();
 827         }
 828     }
 829     else if (pcmbuf_unplayed_bytes <= pcmbuf_watermark)
 830         pcmbuf_under_watermark();
 831
 832     return true;
 833 }
 834
 835 void* pcmbuf_request_buffer(int *count)
 836 {
 837     if (crossfade_init)
 838         crossfade_start();
 839
 840     if (crossfade_active) {
 841         *count = MIN(*count, PCMBUF_MIX_CHUNK/4);
 842         return fadebuf;
 843     }
 844     else
 845     {
 846         if(prepare_insert(*count << 2))
 847         {
 848             size_t audiobuffer_index = audiobuffer_pos + audiobuffer_fillpos;
 849             if (pcmbuf_size - audiobuffer_index >= PCMBUF_MIN_CHUNK)
 850             {
 851                 /* Usual case, there's space here */
 852                 return &audiobuffer[audiobuffer_index];
 853             }
 854             else
 855             {
 856                 /* Flush and wrap the buffer */
 857                 pcmbuf_flush_fillpos();
 858                 audiobuffer_pos = 0;
 859                 return &audiobuffer[0];
 860             }
 861         }
 862         else
 863         {
 864             return NULL;
 865         }
 866     }
 867 }
 868
 869 void* pcmbuf_request_voice_buffer(int *count, bool mix)
 870 {
 871     if (mix)
 872     {
 873         if (pcmbuf_read ==  NULL)
 874         {
 875             return NULL;
 876         }
 877         else if (pcmbuf_mix_chunk || pcmbuf_read->link)
 878         {
 879             *count = MIN(*count, PCMBUF_MIX_CHUNK/4);
 880             return voicebuf;
 881         }
 882         else
 883         {
 884             return NULL;
 885         }
 886     }
 887     else
 888         return pcmbuf_request_buffer(count);
 889 }
 890
 891 bool pcmbuf_is_crossfade_active(void)
 892 {
 893     return crossfade_active || crossfade_init;
 894 }
 895
 896 void pcmbuf_write_complete(int count)
 897 {
 898     size_t length = (size_t)(unsigned int)count << 2;
 899
 900     if (crossfade_active)
 901     {
 902         flush_crossfade(fadebuf, length);
 903         if (!(crossfade_fade_in_rem || crossfade_chunk))
 904             crossfade_active = false;
 905     }
 906     else
 907     {
 908         audiobuffer_fillpos += length;
 909
 910         if (NEED_FLUSH(audiobuffer_pos + audiobuffer_fillpos))
 911             pcmbuf_flush_fillpos();
 912     }
 913 }
 914
 915 #if 0
 916 bool pcmbuf_insert_buffer(char *buf, int count)
 917 {
 918     size_t length = (size_t)(unsigned int)count << 2;
 919
 920     if (crossfade_active)
 921     {
 922         flush_crossfade(buf, length);
 923         if (!(crossfade_fade_in_rem || crossfade_chunk))
 924             crossfade_active = false;
 925     }
 926     else
 927     {
 928         if (!prepare_insert(length))
 929             return false;
 930         pcmbuf_flush_buffer(buf, length);
 931     }
 932     return true;
 933 }
 934 #endif
 935
 936 /* Generates a constant square wave sound with a given frequency
 937    in Hertz for a duration in milliseconds. */
 938 void pcmbuf_beep(unsigned int frequency, size_t duration, int amplitude)
 939 {
 940     unsigned int count = 0, i = 0;
 941     unsigned int interval = NATIVE_FREQUENCY / frequency;
 942     long sample;
 943     short *buf;
 944     short *pcmbuf_end = (short *)fadebuf;
 945     size_t samples = NATIVE_FREQUENCY / 1000 * duration;
 946
 947     if (pcm_is_playing() && pcmbuf_read != NULL)
 948     {
 949         if (pcmbuf_read->link)
 950         {
 951             /* Get the next chunk */
 952             char *pcmbuf_mix_buf = pcmbuf_read->link->addr;
 953             /* Give at least 1/8s clearance. */
 954             buf = (short *)&pcmbuf_mix_buf[NATIVE_FREQUENCY * 4 / 8];
 955         }
 956         else
 957         {
 958             logf("No place to beep");
 959             return;
 960         }
 961
 962         while (i++ < samples)
 963         {
 964             sample = *buf;
 965             *buf++ = MIN(MAX(sample + amplitude, -32768), 32767);
 966             if (buf > pcmbuf_end)
 967                 buf = (short *)audiobuffer;
 968             sample = *buf;
 969             *buf++ = MIN(MAX(sample + amplitude, -32768), 32767);
 970
 971             /* Toggle square wav side */
 972             if (++count >= interval)
 973             {
 974                 count = 0;
 975                 amplitude = -amplitude;
 976             }
 977             if (buf > pcmbuf_end)
 978                 buf = (short *)audiobuffer;
 979         }
 980     }
 981     else
 982     {
 983         buf = (short *)audiobuffer;
 984         while (i++ < samples)
 985         {
 986             *buf++ = amplitude;
 987             if (buf > pcmbuf_end)
 988                 buf = (short *)audiobuffer;
 989             *buf++ = amplitude;
 990
 991             /* Toggle square wav side */
 992             if (++count >= interval)
 993             {
 994                 count = 0;
 995                 amplitude = -amplitude;
 996             }
 997             if (buf > pcmbuf_end)
 998                 buf = (short *)audiobuffer;
 999         }
1000         pcm_play_data(NULL, (unsigned char *)audiobuffer, samples * 4);
1001     }
1002 }
1003
1004 /* Returns pcm buffer usage in percents (0 to 100). */
1005 int pcmbuf_usage(void)
1006 {
1007     return pcmbuf_unplayed_bytes * 100 / pcmbuf_size;
1008 }
1009
1010 int pcmbuf_mix_free(void)
1011 {
1012     if (pcmbuf_mix_chunk)
1013     {
1014         size_t my_mix_end =
1015             (size_t)&((short *)pcmbuf_mix_chunk->addr)[pcmbuf_mix_sample];
1016         size_t my_write_pos = (size_t)&audiobuffer[audiobuffer_pos];
1017         if (my_write_pos < my_mix_end)
1018             my_write_pos += pcmbuf_size;
1019         return (my_write_pos - my_mix_end) * 100 / pcmbuf_unplayed_bytes;
1020     }
1021     return 100;
1022 }
1023
1024 void pcmbuf_mix_voice(int count)
1025 {
1026     short *ibuf = (short *)voicebuf;
1027     short *obuf;
1028     size_t chunk_samples;
1029
1030     if (pcmbuf_mix_chunk == NULL && pcmbuf_read != NULL)
1031     {
1032         pcmbuf_mix_chunk = pcmbuf_read->link;
1033         /* Start 1/8s into the next chunk */
1034         pcmbuf_mix_sample = NATIVE_FREQUENCY * 4 / 16;
1035     }
1036     if (!pcmbuf_mix_chunk)
1037         return;
1038
1039     obuf = (short *)pcmbuf_mix_chunk->addr;
1040     chunk_samples = pcmbuf_mix_chunk->size / 2;
1041
1042     count <<= 1;
1043
1044     while (count-- > 0) {
1045         int sample = *ibuf++;
1046         if (pcmbuf_mix_sample >= chunk_samples)
1047         {
1048             pcmbuf_mix_chunk = pcmbuf_mix_chunk->link;
1049             if (!pcmbuf_mix_chunk)
1050                 return;
1051             pcmbuf_mix_sample = 0;
1052             obuf = pcmbuf_mix_chunk->addr;
1053             chunk_samples = pcmbuf_mix_chunk->size / 2;
1054         }
1055         sample += obuf[pcmbuf_mix_sample] >> 2;
1056         obuf[pcmbuf_mix_sample++] = MIN(MAX(sample, -32768), 32767);
1057     }
1058 }
1059
1060 void pcmbuf_crossfade_enable(bool on_off)
1061 {
1062 #if MEM > 1
1063     /* Next setting to be used, not applied now */
1064     crossfade_enabled_pending = on_off;
1065 #endif
1066     (void)on_off;
1067 }
1068
1069 void pcmbuf_crossfade_enable_finished(void)
1070 {
1071     /* Copy the pending setting over now */
1072     crossfade_enabled = crossfade_enabled_pending;
1073     pcmbuf_set_watermark_bytes();
1074 }
1075
1076 bool pcmbuf_is_crossfade_enabled(void)
1077 {
1078     if (global_settings.crossfade == CROSSFADE_ENABLE_SHUFFLE)
1079         return global_settings.playlist_shuffle;
1080
1081     return crossfade_enabled;
1082 }