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