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