add global proxy / cache settings to httpget class. This removes the need of passing...
[Rockbox.git] / apps / pcmbuf.c
blob81531187155bb22c2bd07f4f8c97359308aaf9e0
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
10 * Copyright (C) 2005 by Miika Pekkarinen
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.
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
18 ****************************************************************************/
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"
41 /* Define PCMBUF_MUTING if the codec requires muting to prevent pops */
42 #if !defined(HAVE_UDA1380) && !defined(HAVE_TLV320) && !defined(HAVE_AS3514)
43 #define PCMBUF_MUTING
44 #endif
46 /* Clip sample to signed 16 bit range */
47 static inline int32_t clip_sample_16(int32_t sample)
49 if ((int16_t)sample != sample)
50 sample = 0x7fff ^ (sample >> 31);
51 return sample;
54 /* Keep watermark high for iPods at least (2s) */
55 #define PCMBUF_WATERMARK (NATIVE_FREQUENCY * 4 * 2)
57 /* Structure we can use to queue pcm chunks in memory to be played
58 * by the driver code. */
59 struct pcmbufdesc
61 void *addr;
62 size_t size;
63 struct pcmbufdesc* link;
64 /* Call this when the buffer has been played */
65 void (*callback)(void);
68 #define PCMBUF_DESCS(bufsize) \
69 ((bufsize) / PCMBUF_MINAVG_CHUNK)
70 #define PCMBUF_DESCS_SIZE(bufsize) \
71 (PCMBUF_DESCS(bufsize)*sizeof(struct pcmbufdesc))
73 /* Size of the PCM buffer. */
74 static size_t pcmbuf_size IDATA_ATTR = 0;
75 static char *pcmbuf_bufend IDATA_ATTR;
76 static char *audiobuffer IDATA_ATTR;
77 /* Current audio buffer write index. */
78 static size_t audiobuffer_pos IDATA_ATTR;
79 /* Amount audiobuffer_pos will be increased.*/
80 static size_t audiobuffer_fillpos IDATA_ATTR;
81 static char *fadebuf IDATA_ATTR;
82 static char *voicebuf IDATA_ATTR;
84 static void (*pcmbuf_event_handler)(void) IDATA_ATTR;
85 static void (*position_callback)(size_t size) IDATA_ATTR;
87 /* Crossfade related state */
88 static bool crossfade_enabled;
89 static bool crossfade_enabled_pending;
90 static bool crossfade_mixmode;
91 static bool crossfade_active IDATA_ATTR;
92 static bool crossfade_init IDATA_ATTR;
94 /* Track the current location for processing crossfade */
95 static struct pcmbufdesc *crossfade_chunk IDATA_ATTR;
96 static size_t crossfade_sample IDATA_ATTR;
98 /* Counters for fading in new data */
99 static size_t crossfade_fade_in_total IDATA_ATTR;
100 static size_t crossfade_fade_in_rem IDATA_ATTR;
102 static size_t pcmbuf_descsize;
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;
109 static size_t pcmbuf_unplayed_bytes IDATA_ATTR;
110 static size_t pcmbuf_watermark IDATA_ATTR;
112 static struct pcmbufdesc *pcmbuf_mix_chunk IDATA_ATTR;
113 static size_t pcmbuf_mix_sample IDATA_ATTR;
115 static bool low_latency_mode = false;
116 static bool pcmbuf_flush;
118 #ifdef HAVE_PRIORITY_SCHEDULING
119 static int codec_thread_priority = 0;
120 #endif
122 extern struct thread_entry *codec_thread_p;
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)
131 static bool prepare_insert(size_t length);
132 static void pcmbuf_under_watermark(void);
133 static bool pcmbuf_flush_fillpos(void);
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)
146 struct pcmbufdesc *pcmbuf_current = pcmbuf_read;
147 /* Take the finished buffer out of circulation */
148 pcmbuf_read = pcmbuf_current->link;
150 /* The buffer is finished, call the callback functions */
151 CALL_IF_EXISTS(position_callback, last_chunksize);
152 CALL_IF_EXISTS(pcmbuf_current->callback);
154 /* Put the finished buffer back into circulation */
155 pcmbuf_write_end->link = pcmbuf_current;
156 pcmbuf_write_end = pcmbuf_current;
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;
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)
173 size_t current_size = pcmbuf_new->size;
175 pcmbuf_unplayed_bytes -= current_size;
176 last_chunksize = current_size;
177 *realsize = current_size;
178 *realstart = pcmbuf_new->addr;
180 else
182 /* No more buffers */
183 last_chunksize = 0;
184 *realsize = 0;
185 *realstart = NULL;
186 CALL_IF_EXISTS(pcmbuf_event_handler);
191 void pcmbuf_set_position_callback(void (*callback)(size_t size))
193 position_callback = callback;
196 static void pcmbuf_set_watermark_bytes(void)
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;
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)
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)
223 pcmbuf_write_end->link = pcmbuf_read->link;
224 pcmbuf_read->link = pcmbuf_current;
225 while (pcmbuf_write_end->link)
227 pcmbuf_write_end = pcmbuf_write_end->link;
228 pcmbuf_unplayed_bytes -= pcmbuf_write_end->size;
230 pcmbuf_flush = false;
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;
239 /* This is now the last buffer to read */
240 pcmbuf_read_end = pcmbuf_current;
242 /* Update bytes counters */
243 pcmbuf_unplayed_bytes += size;
245 audiobuffer_pos += size;
246 if (audiobuffer_pos >= pcmbuf_size)
247 audiobuffer_pos -= pcmbuf_size;
249 audiobuffer_fillpos = 0;
252 #ifdef HAVE_PRIORITY_SCHEDULING
253 static void boost_codec_thread(bool boost)
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)
259 if (codec_thread_priority == 0)
261 codec_thread_priority = thread_set_priority(
262 codec_thread_p, PRIORITY_REALTIME);
263 voice_thread_set_priority(PRIORITY_REALTIME);
266 else if (codec_thread_priority != 0)
268 thread_set_priority(codec_thread_p, codec_thread_priority);
269 voice_thread_set_priority(codec_thread_priority);
270 codec_thread_priority = 0;
273 #endif /* HAVE_PRIORITY_SCHEDULING */
275 static void pcmbuf_under_watermark(void)
277 /* Only codec thread initiates boost - voice boosts the cpu when playing
278 a clip */
279 #ifndef SIMULATOR
280 if (thread_get_current() == codec_thread_p)
281 #endif /* SIMULATOR */
283 #ifdef HAVE_PRIORITY_SCHEDULING
284 /* If buffer is critically low, override UI priority, else
285 set back to the original priority. */
286 boost_codec_thread(LOW_DATA(2) && pcm_is_playing());
287 #endif
288 /* Fill audio buffer by boosting cpu */
289 trigger_cpu_boost();
292 /* Disable crossfade if < .5s of audio */
293 if (LOW_DATA(2))
295 crossfade_active = false;
299 void pcmbuf_set_event_handler(void (*event_handler)(void))
301 pcmbuf_event_handler = event_handler;
304 unsigned int pcmbuf_get_latency(void)
306 /* Be careful how this calculation is rearranged, it's easy to overflow */
307 size_t bytes = pcmbuf_unplayed_bytes + pcm_get_bytes_waiting();
308 return bytes / 4 / (NATIVE_FREQUENCY/1000);
311 void pcmbuf_set_low_latency(bool state)
313 low_latency_mode = state;
316 bool pcmbuf_is_lowdata(void)
318 if (!pcm_is_playing() || pcm_is_paused() ||
319 crossfade_init || crossfade_active)
320 return false;
322 /* 1 seconds of buffer is low data */
323 return LOW_DATA(4);
326 /* Amount of bytes left in the buffer. */
327 inline size_t pcmbuf_free(void)
329 if (pcmbuf_read != NULL)
331 void *read = pcmbuf_read->addr;
332 void *write = &audiobuffer[audiobuffer_pos + audiobuffer_fillpos];
333 if (read < write)
334 return (size_t)(read - write) + pcmbuf_size;
335 else
336 return (size_t) (read - write);
338 return pcmbuf_size;
341 bool pcmbuf_crossfade_init(bool manual_skip)
343 /* Can't do two crossfades at once and, no fade if pcm is off now */
344 if (crossfade_init || crossfade_active || !pcm_is_playing())
346 pcmbuf_play_stop();
347 return false;
350 trigger_cpu_boost();
352 /* Not enough data, or crossfade disabled, flush the old data instead */
353 if (LOW_DATA(2) || !pcmbuf_is_crossfade_enabled() || low_latency_mode)
355 pcmbuf_flush_fillpos();
356 pcmbuf_flush = true;
357 return false;
360 /* Don't enable mix mode when skipping tracks manually. */
361 if (manual_skip)
362 crossfade_mixmode = false;
363 else
364 crossfade_mixmode = global_settings.crossfade_fade_out_mixmode;
366 crossfade_init = true;
368 return true;
372 void pcmbuf_play_stop(void)
374 pcm_play_stop();
376 pcmbuf_unplayed_bytes = 0;
377 pcmbuf_mix_chunk = NULL;
378 if (pcmbuf_read) {
379 pcmbuf_write_end->link = pcmbuf_read;
380 pcmbuf_write_end = pcmbuf_read_end;
381 pcmbuf_read = pcmbuf_read_end = NULL;
383 audiobuffer_pos = 0;
384 audiobuffer_fillpos = 0;
385 crossfade_init = false;
386 crossfade_active = false;
387 pcmbuf_flush = false;
389 #ifdef HAVE_PRIORITY_SCHEDULING
390 /* Can unboost the codec thread here no matter who's calling */
391 boost_codec_thread(false);
392 #endif
395 int pcmbuf_used_descs(void) {
396 struct pcmbufdesc *pcmbuf_temp = pcmbuf_read;
397 unsigned int i = 0;
398 while (pcmbuf_temp) {
399 pcmbuf_temp = pcmbuf_temp->link;
400 i++;
402 return i;
405 int pcmbuf_descs(void) {
406 return PCMBUF_DESCS(pcmbuf_size);
409 size_t get_pcmbuf_descsize(void) {
410 return pcmbuf_descsize;
413 static void pcmbuf_init_pcmbuffers(void) {
414 struct pcmbufdesc *next = pcmbuf_write;
415 next++;
416 pcmbuf_write_end = pcmbuf_write;
417 while ((void *)next < (void *)pcmbuf_bufend) {
418 pcmbuf_write_end->link=next;
419 pcmbuf_write_end=next;
420 next++;
424 static size_t pcmbuf_get_next_required_pcmbuf_size(void)
426 #if MEM > 1
427 size_t seconds = 1;
429 if (crossfade_enabled_pending)
430 seconds += global_settings.crossfade_fade_out_delay
431 + global_settings.crossfade_fade_out_duration;
433 /* Buffer has to be at least 2s long. */
434 seconds += 2;
435 logf("pcmbuf len: %ld", seconds);
436 return seconds * (NATIVE_FREQUENCY*4);
437 #else
438 return NATIVE_FREQUENCY*2;
439 #endif
442 static char *pcmbuf_calc_audiobuffer_ptr(size_t bufsize)
444 return pcmbuf_bufend - (bufsize + PCMBUF_MIX_CHUNK * 2 +
445 PCMBUF_DESCS_SIZE(bufsize));
448 bool pcmbuf_is_same_size(void)
450 if (audiobuffer == NULL)
451 return true; /* Not set up yet even once so always */
453 size_t bufsize = pcmbuf_get_next_required_pcmbuf_size();
454 return pcmbuf_calc_audiobuffer_ptr(bufsize) == audiobuffer;
457 /* Initialize the pcmbuffer the structure looks like this:
458 * ...|---------PCMBUF---------|FADEBUF|VOICEBUF|DESCS|... */
459 size_t pcmbuf_init(unsigned char *bufend)
461 pcmbuf_bufend = bufend;
462 pcmbuf_size = pcmbuf_get_next_required_pcmbuf_size();
463 audiobuffer = pcmbuf_calc_audiobuffer_ptr(pcmbuf_size);
464 fadebuf = &audiobuffer[pcmbuf_size];
465 voicebuf = &fadebuf[PCMBUF_MIX_CHUNK];
466 pcmbuf_write = (struct pcmbufdesc *)&voicebuf[PCMBUF_MIX_CHUNK];
468 pcmbuf_descsize = PCMBUF_DESCS_SIZE(pcmbuf_size);
469 pcmbuf_init_pcmbuffers();
471 position_callback = NULL;
472 pcmbuf_event_handler = NULL;
474 pcmbuf_crossfade_enable_finished();
476 pcmbuf_play_stop();
478 return pcmbuf_bufend - audiobuffer;
481 size_t pcmbuf_get_bufsize(void)
483 return pcmbuf_size;
486 #ifdef ROCKBOX_HAS_LOGF
487 unsigned char * pcmbuf_get_meminfo(size_t *length)
489 *length = pcmbuf_bufend - audiobuffer;
490 return audiobuffer;
492 #endif
494 void pcmbuf_pause(bool pause)
496 #ifdef PCMBUF_MUTING
497 if (pause)
498 pcm_mute(true);
499 #endif
501 if (pcm_is_playing())
502 pcm_play_pause(!pause);
503 else if (!pause)
504 pcmbuf_play_start();
506 #ifdef PCMBUF_MUTING
507 if (!pause)
508 pcm_mute(false);
509 #endif
510 trigger_cpu_boost();
513 /* Force playback. */
514 void pcmbuf_play_start(void)
516 if (!pcm_is_playing() && pcmbuf_unplayed_bytes && pcmbuf_read != NULL)
518 last_chunksize = pcmbuf_read->size;
519 pcmbuf_unplayed_bytes -= last_chunksize;
520 pcm_play_data(pcmbuf_callback,
521 (unsigned char *)pcmbuf_read->addr, last_chunksize);
526 * Commit samples waiting to the pcm buffer.
528 static bool pcmbuf_flush_fillpos(void)
530 if (audiobuffer_fillpos) {
531 /* Never use the last buffer descriptor */
532 while (pcmbuf_write == pcmbuf_write_end) {
533 /* If this happens, something is being stupid */
534 if (!pcm_is_playing()) {
535 logf("pcmbuf_flush_fillpos error");
536 pcmbuf_play_start();
538 /* Let approximately one chunk of data playback */
539 sleep(HZ*PCMBUF_TARGET_CHUNK/(NATIVE_FREQUENCY*4));
541 pcmbuf_add_chunk();
542 return true;
544 return false;
548 * Completely process the crossfade fade out effect with current pcm buffer.
550 static void crossfade_process_buffer(size_t fade_in_delay,
551 size_t fade_out_delay, size_t fade_out_rem)
553 if (!crossfade_mixmode)
555 /* Fade out the specified amount of the already processed audio */
556 size_t total_fade_out = fade_out_rem;
557 size_t fade_out_sample;
558 struct pcmbufdesc *fade_out_chunk = crossfade_chunk;
560 /* Find the right chunk to start fading out */
561 fade_out_delay += crossfade_sample * 2;
562 while (fade_out_delay != 0 && fade_out_delay >= fade_out_chunk->size)
564 fade_out_delay -= fade_out_chunk->size;
565 fade_out_chunk = fade_out_chunk->link;
567 /* The start sample within the chunk */
568 fade_out_sample = fade_out_delay / 2;
570 while (fade_out_rem > 0)
572 /* Each 1/10 second of audio will have the same fade applied */
573 size_t block_rem = MIN(NATIVE_FREQUENCY * 4 / 10, fade_out_rem);
574 int factor = (fade_out_rem << 8) / total_fade_out;
576 fade_out_rem -= block_rem;
578 /* Fade this block */
579 while (block_rem > 0 && fade_out_chunk != NULL)
581 /* Fade one sample */
582 int16_t *buf = (int16_t *)fade_out_chunk->addr;
583 int32_t sample = buf[fade_out_sample];
584 buf[fade_out_sample++] = (sample * factor) >> 8;
586 block_rem -= 2;
587 /* Move to the next chunk as needed */
588 if (fade_out_sample * 2 >= fade_out_chunk->size)
590 fade_out_chunk = fade_out_chunk->link;
591 fade_out_sample = 0;
597 /* Find the right chunk and sample to start fading in */
598 fade_in_delay += crossfade_sample * 2;
599 while (fade_in_delay != 0 && fade_in_delay >= crossfade_chunk->size)
601 fade_in_delay -= crossfade_chunk->size;
602 crossfade_chunk = crossfade_chunk->link;
604 crossfade_sample = fade_in_delay / 2;
605 logf("process done!");
608 /* Initializes crossfader, calculates all necessary parameters and
609 * performs fade-out with the pcm buffer. */
610 static void crossfade_start(void)
612 size_t crossfade_rem;
613 size_t crossfade_need;
614 size_t fade_out_rem;
615 size_t fade_out_delay;
616 size_t fade_in_delay;
618 crossfade_init = false;
619 /* Reject crossfade if less than .5s of data */
620 if (LOW_DATA(2)) {
621 logf("crossfade rejected");
622 pcmbuf_play_stop();
623 return ;
626 logf("crossfade_start");
627 pcmbuf_flush_fillpos();
628 crossfade_active = true;
630 /* Initialize the crossfade buffer size to all of the buffered data that
631 * has not yet been sent to the DMA */
632 crossfade_rem = pcmbuf_unplayed_bytes;
633 crossfade_chunk = pcmbuf_read->link;
634 crossfade_sample = 0;
636 /* Get fade out delay from settings. */
637 fade_out_delay =
638 NATIVE_FREQUENCY * global_settings.crossfade_fade_out_delay * 4;
640 /* Get fade out duration from settings. */
641 fade_out_rem =
642 NATIVE_FREQUENCY * global_settings.crossfade_fade_out_duration * 4;
644 crossfade_need = fade_out_delay + fade_out_rem;
645 /* We want only to modify the last part of the buffer. */
646 if (crossfade_rem > crossfade_need)
648 size_t crossfade_extra = crossfade_rem - crossfade_need;
649 while (crossfade_extra > crossfade_chunk->size)
651 crossfade_extra -= crossfade_chunk->size;
652 crossfade_chunk = crossfade_chunk->link;
654 crossfade_sample = crossfade_extra / 2;
656 /* Truncate fade out duration if necessary. */
657 else if (crossfade_rem < crossfade_need)
659 size_t crossfade_short = crossfade_need - crossfade_rem;
660 if (fade_out_rem >= crossfade_short)
661 fade_out_rem -= crossfade_short;
662 else
664 fade_out_delay -= crossfade_short - fade_out_rem;
665 fade_out_rem = 0;
669 /* Get also fade in duration and delays from settings. */
670 crossfade_fade_in_total =
671 NATIVE_FREQUENCY * global_settings.crossfade_fade_in_duration * 4;
672 crossfade_fade_in_rem = crossfade_fade_in_total;
674 fade_in_delay =
675 NATIVE_FREQUENCY * global_settings.crossfade_fade_in_delay * 4;
677 crossfade_process_buffer(fade_in_delay, fade_out_delay, fade_out_rem);
680 /* Returns the number of bytes _NOT_ mixed */
681 static size_t crossfade_fade_mix(int factor, const char *buf, size_t fade_rem)
683 const int16_t *input_buf = (const int16_t *)buf;
684 int16_t *output_buf = (int16_t *)(crossfade_chunk->addr);
685 int16_t *chunk_end = SKIPBYTES(output_buf, crossfade_chunk->size);
686 output_buf = &output_buf[crossfade_sample];
688 while (fade_rem)
690 int32_t sample = *input_buf++;
691 sample = ((sample * factor) >> 8) + *output_buf;
692 *output_buf++ = clip_sample_16(sample);
693 fade_rem -= 2;
695 if (output_buf >= chunk_end)
697 crossfade_chunk = crossfade_chunk->link;
698 if (!crossfade_chunk)
699 return fade_rem;
700 output_buf = (int16_t *)crossfade_chunk->addr;
701 chunk_end = SKIPBYTES(output_buf, crossfade_chunk->size);
704 crossfade_sample = output_buf - (int16_t *)crossfade_chunk->addr;
705 return 0;
708 /* Returns the number of bytes _NOT_ mixed */
709 static size_t crossfade_mix(const char *buf, size_t length)
711 const int16_t *input_buf = (const int16_t *)buf;
712 int16_t *output_buf = (int16_t *)crossfade_chunk->addr;
713 int16_t *chunk_end = SKIPBYTES(output_buf, crossfade_chunk->size);
714 output_buf = &output_buf[crossfade_sample];
716 while (length)
718 int32_t sample = *input_buf++ + *output_buf;
719 *output_buf++ = clip_sample_16(sample);
720 length -= 2;
722 if (output_buf >= chunk_end)
724 crossfade_chunk = crossfade_chunk->link;
725 if (!crossfade_chunk)
726 return length;
728 output_buf = (int16_t *)crossfade_chunk->addr;
729 chunk_end = SKIPBYTES(output_buf, crossfade_chunk->size);
732 crossfade_sample = output_buf - (int16_t *)crossfade_chunk->addr;
733 return 0;
736 static void pcmbuf_flush_buffer(const char *buf, size_t length)
738 size_t copy_n;
739 while (length > 0) {
740 size_t audiobuffer_index = audiobuffer_pos + audiobuffer_fillpos;
741 if (NEED_FLUSH(audiobuffer_index))
743 pcmbuf_flush_fillpos();
744 audiobuffer_index = audiobuffer_pos + audiobuffer_fillpos;
746 copy_n = MIN(length, pcmbuf_size - audiobuffer_index);
747 memcpy(&audiobuffer[audiobuffer_index], buf, copy_n);
748 buf += copy_n;
749 audiobuffer_fillpos += copy_n;
750 length -= copy_n;
754 static void flush_crossfade(char *buf, size_t length)
756 if (length)
758 if (crossfade_fade_in_rem)
760 size_t samples;
761 int16_t *input_buf;
763 /* Fade factor for this packet */
764 int factor =
765 ((crossfade_fade_in_total - crossfade_fade_in_rem) << 8) /
766 crossfade_fade_in_total;
767 /* Bytes to fade */
768 size_t fade_rem = MIN(length, crossfade_fade_in_rem);
770 /* We _will_ fade this many bytes */
771 crossfade_fade_in_rem -= fade_rem;
773 if (crossfade_chunk)
775 /* Mix the data */
776 size_t fade_total = fade_rem;
777 fade_rem = crossfade_fade_mix(factor, buf, fade_rem);
778 length -= fade_total - fade_rem;
779 buf += fade_total - fade_rem;
780 if (!length)
781 return;
782 if (!fade_rem)
783 goto fade_done;
786 samples = fade_rem / 2;
787 input_buf = (int16_t *)buf;
788 /* Fade remaining samples in place */
789 while (samples)
791 int32_t sample = *input_buf;
792 *input_buf++ = (sample * factor) >> 8;
793 samples--;
797 fade_done:
798 if (crossfade_chunk)
800 /* Mix the data */
801 size_t mix_total = length;
802 length = crossfade_mix(buf, length);
803 buf += mix_total - length;
804 if (!length)
805 return;
808 /* Flush samples to the buffer */
809 while (!prepare_insert(length))
810 sleep(1);
811 pcmbuf_flush_buffer(buf, length);
816 static bool prepare_insert(size_t length)
818 if (low_latency_mode)
820 /* 1/4s latency. */
821 if (pcmbuf_unplayed_bytes > NATIVE_FREQUENCY * 4 / 4
822 && pcm_is_playing())
823 return false;
826 /* Need to save PCMBUF_MIN_CHUNK to prevent wrapping overwriting */
827 if (pcmbuf_free() < length + PCMBUF_MIN_CHUNK)
828 return false;
830 if (!pcm_is_playing())
832 trigger_cpu_boost();
834 /* Pre-buffer 1s. */
835 #if MEM <= 1
836 if (!LOW_DATA(1))
837 #else
838 if (!LOW_DATA(4))
839 #endif
841 logf("pcm starting");
842 if (!(audio_status() & AUDIO_STATUS_PAUSE))
843 pcmbuf_play_start();
846 else if (pcmbuf_unplayed_bytes <= pcmbuf_watermark)
847 pcmbuf_under_watermark();
849 return true;
852 void* pcmbuf_request_buffer(int *count)
854 if (crossfade_init)
855 crossfade_start();
857 if (crossfade_active) {
858 *count = MIN(*count, PCMBUF_MIX_CHUNK/4);
859 return fadebuf;
861 else
863 if(prepare_insert(*count << 2))
865 size_t audiobuffer_index = audiobuffer_pos + audiobuffer_fillpos;
866 if (pcmbuf_size - audiobuffer_index >= PCMBUF_MIN_CHUNK)
868 /* Usual case, there's space here */
869 return &audiobuffer[audiobuffer_index];
871 else
873 /* Flush and wrap the buffer */
874 pcmbuf_flush_fillpos();
875 audiobuffer_pos = 0;
876 return &audiobuffer[0];
879 else
881 return NULL;
886 void * pcmbuf_request_voice_buffer(int *count)
888 /* A get-it-to-work-for-now hack (audio status could change by
889 completion) */
890 if (audio_status() & AUDIO_STATUS_PLAY)
892 if (pcmbuf_read == NULL)
894 return NULL;
896 else if (pcmbuf_usage() >= 10 && pcmbuf_mix_free() >= 30 &&
897 (pcmbuf_mix_chunk || pcmbuf_read->link))
899 *count = MIN(*count, PCMBUF_MIX_CHUNK/4);
900 return voicebuf;
902 else
904 return NULL;
907 else
909 return pcmbuf_request_buffer(count);
913 bool pcmbuf_is_crossfade_active(void)
915 return crossfade_active || crossfade_init;
918 void pcmbuf_write_complete(int count)
920 size_t length = (size_t)(unsigned int)count << 2;
922 if (crossfade_active)
924 flush_crossfade(fadebuf, length);
925 if (!(crossfade_fade_in_rem || crossfade_chunk))
926 crossfade_active = false;
928 else
930 audiobuffer_fillpos += length;
932 if (NEED_FLUSH(audiobuffer_pos + audiobuffer_fillpos))
933 pcmbuf_flush_fillpos();
937 #if 0
938 bool pcmbuf_insert_buffer(char *buf, int count)
940 size_t length = (size_t)(unsigned int)count << 2;
942 if (crossfade_active)
944 flush_crossfade(buf, length);
945 if (!(crossfade_fade_in_rem || crossfade_chunk))
946 crossfade_active = false;
948 else
950 if (!prepare_insert(length))
951 return false;
952 pcmbuf_flush_buffer(buf, length);
954 return true;
956 #endif
958 /* Generates a constant square wave sound with a given frequency
959 in Hertz for a duration in milliseconds. */
960 void pcmbuf_beep(unsigned int frequency, size_t duration, int amplitude)
962 unsigned int count = 0, i = 0;
963 unsigned int interval = NATIVE_FREQUENCY / frequency;
964 int32_t sample;
965 int16_t *buf;
966 int16_t *pcmbuf_end = (int16_t *)fadebuf;
967 size_t samples = NATIVE_FREQUENCY / 1000 * duration;
969 if (pcm_is_playing() && pcmbuf_read != NULL)
971 if (pcmbuf_read->link)
973 /* Get the next chunk */
974 char *pcmbuf_mix_buf = pcmbuf_read->link->addr;
975 /* Give at least 1/8s clearance. */
976 buf = (int16_t *)&pcmbuf_mix_buf[NATIVE_FREQUENCY * 4 / 8];
978 else
980 logf("No place to beep");
981 return;
984 while (i++ < samples)
986 sample = *buf;
987 *buf++ = clip_sample_16(sample + amplitude);
988 if (buf > pcmbuf_end)
989 buf = (int16_t *)audiobuffer;
990 sample = *buf;
991 *buf++ = clip_sample_16(sample + amplitude);
993 /* Toggle square wav side */
994 if (++count >= interval)
996 count = 0;
997 amplitude = -amplitude;
999 if (buf > pcmbuf_end)
1000 buf = (int16_t *)audiobuffer;
1003 else
1005 buf = (int16_t *)audiobuffer;
1006 while (i++ < samples)
1008 *buf++ = amplitude;
1009 if (buf > pcmbuf_end)
1010 buf = (int16_t *)audiobuffer;
1011 *buf++ = amplitude;
1013 /* Toggle square wav side */
1014 if (++count >= interval)
1016 count = 0;
1017 amplitude = -amplitude;
1019 if (buf > pcmbuf_end)
1020 buf = (int16_t *)audiobuffer;
1022 pcm_play_data(NULL, (unsigned char *)audiobuffer, samples * 4);
1026 /* Returns pcm buffer usage in percents (0 to 100). */
1027 int pcmbuf_usage(void)
1029 return pcmbuf_unplayed_bytes * 100 / pcmbuf_size;
1032 int pcmbuf_mix_free(void)
1034 if (pcmbuf_mix_chunk)
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;
1043 return 100;
1046 void pcmbuf_write_voice_complete(int count)
1048 /* A get-it-to-work-for-now hack (audio status could have changed) */
1049 if (!(audio_status() & AUDIO_STATUS_PLAY))
1051 pcmbuf_write_complete(count);
1052 return;
1055 int16_t *ibuf = (int16_t *)voicebuf;
1056 int16_t *obuf;
1057 size_t chunk_samples;
1059 if (pcmbuf_mix_chunk == NULL && pcmbuf_read != NULL)
1061 pcmbuf_mix_chunk = pcmbuf_read->link;
1062 /* Start 1/8s into the next chunk */
1063 pcmbuf_mix_sample = NATIVE_FREQUENCY * 4 / 16;
1066 if (!pcmbuf_mix_chunk)
1067 return;
1069 obuf = (int16_t *)pcmbuf_mix_chunk->addr;
1070 chunk_samples = pcmbuf_mix_chunk->size / sizeof (int16_t);
1072 count <<= 1;
1074 while (count-- > 0)
1076 int32_t sample = *ibuf++;
1078 if (pcmbuf_mix_sample >= chunk_samples)
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;
1087 sample += obuf[pcmbuf_mix_sample] >> 2;
1088 obuf[pcmbuf_mix_sample++] = clip_sample_16(sample);
1092 void pcmbuf_crossfade_enable(bool on_off)
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;
1101 void pcmbuf_crossfade_enable_finished(void)
1103 /* Copy the pending setting over now */
1104 crossfade_enabled = crossfade_enabled_pending;
1105 pcmbuf_set_watermark_bytes();
1108 bool pcmbuf_is_crossfade_enabled(void)
1110 if (global_settings.crossfade == CROSSFADE_ENABLE_SHUFFLE)
1111 return global_settings.playlist_shuffle;
1113 return crossfade_enabled;