1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
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 ****************************************************************************/
37 #include "voice_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 && !defined(HAVE_WM8978)
47 /* Clip sample to signed 16 bit range */
48 static inline int32_t clip_sample_16(int32_t sample
)
50 if ((int16_t)sample
!= sample
)
51 sample
= 0x7fff ^ (sample
>> 31);
55 /* Keep watermark high for iPods at least (2s) */
56 #define PCMBUF_WATERMARK (NATIVE_FREQUENCY * 4 * 2)
58 /* Structure we can use to queue pcm chunks in memory to be played
59 * by the driver code. */
64 struct pcmbufdesc
* link
;
65 /* Call this when the buffer has been played */
66 void (*callback
)(void);
69 #define PCMBUF_DESCS(bufsize) \
70 ((bufsize) / PCMBUF_MINAVG_CHUNK)
71 #define PCMBUF_DESCS_SIZE(bufsize) \
72 (PCMBUF_DESCS(bufsize)*sizeof(struct pcmbufdesc))
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
;
85 static void (*pcmbuf_event_handler
)(void) IDATA_ATTR
;
86 static void (*position_callback
)(size_t size
) IDATA_ATTR
;
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
;
95 /* Track the current location for processing crossfade */
96 static struct pcmbufdesc
*crossfade_chunk IDATA_ATTR
;
97 static size_t crossfade_sample IDATA_ATTR
;
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
;
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
= PRIORITY_PLAYBACK
;
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
;
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
;
182 /* No more buffers */
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 */
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
) {
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 */
234 pcmbuf_read_end
->link
= pcmbuf_current
;
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. */
259 int priority
= (PRIORITY_PLAYBACK
- PRIORITY_PLAYBACK_MAX
)*pcmbuf_unplayed_bytes
260 / (2*NATIVE_FREQUENCY
) + PRIORITY_PLAYBACK_MAX
;
262 if (priority
!= codec_thread_priority
)
264 codec_thread_priority
= priority
;
265 thread_set_priority(codec_thread_p
, priority
);
266 voice_thread_set_priority(priority
);
269 else if (codec_thread_priority
!= PRIORITY_PLAYBACK
)
271 thread_set_priority(codec_thread_p
, PRIORITY_PLAYBACK
);
272 voice_thread_set_priority(PRIORITY_PLAYBACK
);
273 codec_thread_priority
= PRIORITY_PLAYBACK
;
276 #endif /* HAVE_PRIORITY_SCHEDULING */
278 static void pcmbuf_under_watermark(void)
280 /* Only codec thread initiates boost - voice boosts the cpu when playing
283 if (thread_get_current() == codec_thread_p
)
284 #endif /* SIMULATOR */
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());
291 /* Fill audio buffer by boosting cpu */
295 /* Disable crossfade if < .5s of audio */
298 crossfade_active
= false;
302 void pcmbuf_set_event_handler(void (*event_handler
)(void))
304 pcmbuf_event_handler
= event_handler
;
307 unsigned int pcmbuf_get_latency(void)
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);
314 void pcmbuf_set_low_latency(bool state
)
316 low_latency_mode
= state
;
319 bool pcmbuf_is_lowdata(void)
321 if (!pcm_is_playing() || pcm_is_paused() ||
322 crossfade_init
|| crossfade_active
)
325 /* 1 seconds of buffer is low data */
329 /* Amount of bytes left in the buffer. */
330 inline size_t pcmbuf_free(void)
332 if (pcmbuf_read
!= NULL
)
334 void *read
= pcmbuf_read
->addr
;
335 void *write
= &audiobuffer
[audiobuffer_pos
+ audiobuffer_fillpos
];
337 return (size_t)(read
- write
) + pcmbuf_size
;
339 return (size_t) (read
- write
);
344 bool pcmbuf_crossfade_init(bool manual_skip
)
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())
355 /* Not enough data, or crossfade disabled, flush the old data instead */
356 if (LOW_DATA(2) || !pcmbuf_is_crossfade_enabled() || low_latency_mode
)
358 pcmbuf_flush_fillpos();
363 /* Don't enable mix mode when skipping tracks manually. */
365 crossfade_mixmode
= false;
367 crossfade_mixmode
= global_settings
.crossfade_fade_out_mixmode
;
369 crossfade_init
= true;
375 void pcmbuf_play_stop(void)
379 pcmbuf_unplayed_bytes
= 0;
380 pcmbuf_mix_chunk
= NULL
;
382 pcmbuf_write_end
->link
= pcmbuf_read
;
383 pcmbuf_write_end
= pcmbuf_read_end
;
384 pcmbuf_read
= pcmbuf_read_end
= NULL
;
387 audiobuffer_fillpos
= 0;
388 crossfade_init
= false;
389 crossfade_active
= false;
390 pcmbuf_flush
= false;
392 #ifdef HAVE_PRIORITY_SCHEDULING
393 /* Can unboost the codec thread here no matter who's calling */
394 boost_codec_thread(false);
398 int pcmbuf_used_descs(void) {
399 struct pcmbufdesc
*pcmbuf_temp
= pcmbuf_read
;
401 while (pcmbuf_temp
) {
402 pcmbuf_temp
= pcmbuf_temp
->link
;
408 int pcmbuf_descs(void) {
409 return PCMBUF_DESCS(pcmbuf_size
);
412 static void pcmbuf_init_pcmbuffers(void) {
413 struct pcmbufdesc
*next
= pcmbuf_write
;
415 pcmbuf_write_end
= pcmbuf_write
;
416 while ((void *)next
< (void *)pcmbuf_bufend
) {
417 pcmbuf_write_end
->link
=next
;
418 pcmbuf_write_end
=next
;
423 static size_t pcmbuf_get_next_required_pcmbuf_size(void)
428 if (crossfade_enabled_pending
)
429 seconds
+= global_settings
.crossfade_fade_out_delay
430 + global_settings
.crossfade_fade_out_duration
;
432 /* Buffer has to be at least 2s long. */
434 logf("pcmbuf len: %ld", seconds
);
435 return seconds
* (NATIVE_FREQUENCY
*4);
437 return NATIVE_FREQUENCY
*2;
441 static char *pcmbuf_calc_audiobuffer_ptr(size_t bufsize
)
443 return pcmbuf_bufend
- (bufsize
+ PCMBUF_MIX_CHUNK
* 2 +
444 PCMBUF_DESCS_SIZE(bufsize
));
447 bool pcmbuf_is_same_size(void)
449 if (audiobuffer
== NULL
)
450 return true; /* Not set up yet even once so always */
452 size_t bufsize
= pcmbuf_get_next_required_pcmbuf_size();
453 return pcmbuf_calc_audiobuffer_ptr(bufsize
) == audiobuffer
;
456 /* Initialize the pcmbuffer the structure looks like this:
457 * ...|---------PCMBUF---------|FADEBUF|VOICEBUF|DESCS|... */
458 size_t pcmbuf_init(unsigned char *bufend
)
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
];
467 pcmbuf_init_pcmbuffers();
469 position_callback
= NULL
;
470 pcmbuf_event_handler
= NULL
;
472 pcmbuf_crossfade_enable_finished();
476 return pcmbuf_bufend
- audiobuffer
;
479 size_t pcmbuf_get_bufsize(void)
484 #ifdef ROCKBOX_HAS_LOGF
485 unsigned char * pcmbuf_get_meminfo(size_t *length
)
487 *length
= pcmbuf_bufend
- audiobuffer
;
492 void pcmbuf_pause(bool pause
)
499 if (pcm_is_playing())
500 pcm_play_pause(!pause
);
511 /* Force playback. */
512 void pcmbuf_play_start(void)
514 if (!pcm_is_playing() && pcmbuf_unplayed_bytes
&& pcmbuf_read
!= NULL
)
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
);
524 * Commit samples waiting to the pcm buffer.
526 static bool pcmbuf_flush_fillpos(void)
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");
536 /* Let approximately one chunk of data playback */
537 sleep(HZ
*PCMBUF_TARGET_CHUNK
/(NATIVE_FREQUENCY
*4));
546 * Completely process the crossfade fade out effect with current pcm buffer.
548 static void crossfade_process_buffer(size_t fade_in_delay
,
549 size_t fade_out_delay
, size_t fade_out_rem
)
551 if (!crossfade_mixmode
)
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
;
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
)
562 fade_out_delay
-= fade_out_chunk
->size
;
563 fade_out_chunk
= fade_out_chunk
->link
;
565 /* The start sample within the chunk */
566 fade_out_sample
= fade_out_delay
/ 2;
568 while (fade_out_rem
> 0)
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
;
574 fade_out_rem
-= block_rem
;
576 /* Fade this block */
577 while (block_rem
> 0 && fade_out_chunk
!= NULL
)
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;
585 /* Move to the next chunk as needed */
586 if (fade_out_sample
* 2 >= fade_out_chunk
->size
)
588 fade_out_chunk
= fade_out_chunk
->link
;
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
)
599 fade_in_delay
-= crossfade_chunk
->size
;
600 crossfade_chunk
= crossfade_chunk
->link
;
602 crossfade_sample
= fade_in_delay
/ 2;
603 logf("process done!");
606 /* Initializes crossfader, calculates all necessary parameters and
607 * performs fade-out with the pcm buffer. */
608 static void crossfade_start(void)
610 size_t crossfade_rem
;
611 size_t crossfade_need
;
613 size_t fade_out_delay
;
614 size_t fade_in_delay
;
616 crossfade_init
= false;
617 /* Reject crossfade if less than .5s of data */
619 logf("crossfade rejected");
624 logf("crossfade_start");
625 pcmbuf_flush_fillpos();
626 crossfade_active
= true;
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;
634 /* Get fade out delay from settings. */
636 NATIVE_FREQUENCY
* global_settings
.crossfade_fade_out_delay
* 4;
638 /* Get fade out duration from settings. */
640 NATIVE_FREQUENCY
* global_settings
.crossfade_fade_out_duration
* 4;
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
)
646 size_t crossfade_extra
= crossfade_rem
- crossfade_need
;
647 while (crossfade_extra
> crossfade_chunk
->size
)
649 crossfade_extra
-= crossfade_chunk
->size
;
650 crossfade_chunk
= crossfade_chunk
->link
;
652 crossfade_sample
= crossfade_extra
/ 2;
654 /* Truncate fade out duration if necessary. */
655 else if (crossfade_rem
< crossfade_need
)
657 size_t crossfade_short
= crossfade_need
- crossfade_rem
;
658 if (fade_out_rem
>= crossfade_short
)
659 fade_out_rem
-= crossfade_short
;
662 fade_out_delay
-= crossfade_short
- fade_out_rem
;
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
;
673 NATIVE_FREQUENCY
* global_settings
.crossfade_fade_in_delay
* 4;
675 crossfade_process_buffer(fade_in_delay
, fade_out_delay
, fade_out_rem
);
678 /* Returns the number of bytes _NOT_ mixed */
679 static size_t crossfade_fade_mix(int factor
, const char *buf
, size_t fade_rem
)
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
];
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
);
694 sample
= *input_buf
++;
695 sample
= ((sample
* factor
) >> 8) + *output_buf
;
696 *output_buf
++ = clip_sample_16(sample
);
698 fade_rem
-= 4; /* 2 samples, each 16 bit -> 4 bytes */
700 if (output_buf
>= chunk_end
)
702 crossfade_chunk
= crossfade_chunk
->link
;
703 if (!crossfade_chunk
)
705 output_buf
= (int16_t *)crossfade_chunk
->addr
;
706 chunk_end
= SKIPBYTES(output_buf
, crossfade_chunk
->size
);
709 crossfade_sample
= output_buf
- (int16_t *)crossfade_chunk
->addr
;
713 /* Returns the number of bytes _NOT_ mixed */
714 static size_t crossfade_mix(const char *buf
, size_t length
)
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
];
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
);
728 sample
= *input_buf
++ + *output_buf
;
729 *output_buf
++ = clip_sample_16(sample
);
731 length
-= 4; /* 2 samples, each 16 bit -> 4 bytes */
733 if (output_buf
>= chunk_end
)
735 crossfade_chunk
= crossfade_chunk
->link
;
736 if (!crossfade_chunk
)
739 output_buf
= (int16_t *)crossfade_chunk
->addr
;
740 chunk_end
= SKIPBYTES(output_buf
, crossfade_chunk
->size
);
743 crossfade_sample
= output_buf
- (int16_t *)crossfade_chunk
->addr
;
747 static void pcmbuf_flush_buffer(const char *buf
, size_t length
)
751 size_t audiobuffer_index
= audiobuffer_pos
+ audiobuffer_fillpos
;
752 if (NEED_FLUSH(audiobuffer_index
))
754 pcmbuf_flush_fillpos();
755 audiobuffer_index
= audiobuffer_pos
+ audiobuffer_fillpos
;
757 copy_n
= MIN(length
, pcmbuf_size
- audiobuffer_index
);
758 memcpy(&audiobuffer
[audiobuffer_index
], buf
, copy_n
);
760 audiobuffer_fillpos
+= copy_n
;
765 static void flush_crossfade(char *buf
, size_t length
)
769 if (crossfade_fade_in_rem
)
774 /* Fade factor for this packet */
776 ((crossfade_fade_in_total
- crossfade_fade_in_rem
) << 8) /
777 crossfade_fade_in_total
;
779 size_t fade_rem
= MIN(length
, crossfade_fade_in_rem
);
781 /* We _will_ fade this many bytes */
782 crossfade_fade_in_rem
-= fade_rem
;
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
;
797 samples
= fade_rem
/ 2;
798 input_buf
= (int16_t *)buf
;
799 /* Fade remaining samples in place */
802 int32_t sample
= *input_buf
;
803 *input_buf
++ = (sample
* factor
) >> 8;
812 size_t mix_total
= length
;
813 length
= crossfade_mix(buf
, length
);
814 buf
+= mix_total
- length
;
819 /* Flush samples to the buffer */
820 while (!prepare_insert(length
))
822 pcmbuf_flush_buffer(buf
, length
);
827 static bool prepare_insert(size_t length
)
829 if (low_latency_mode
)
832 if (pcmbuf_unplayed_bytes
> NATIVE_FREQUENCY
* 4 / 2
837 /* Need to save PCMBUF_MIN_CHUNK to prevent wrapping overwriting */
838 if (pcmbuf_free() < length
+ PCMBUF_MIN_CHUNK
)
841 if (!pcm_is_playing())
852 logf("pcm starting");
853 if (!(audio_status() & AUDIO_STATUS_PAUSE
))
857 else if (pcmbuf_unplayed_bytes
<= pcmbuf_watermark
)
858 pcmbuf_under_watermark();
863 void* pcmbuf_request_buffer(int *count
)
868 if (crossfade_active
) {
869 *count
= MIN(*count
, PCMBUF_MIX_CHUNK
/4);
874 if(prepare_insert(*count
<< 2))
876 size_t audiobuffer_index
= audiobuffer_pos
+ audiobuffer_fillpos
;
877 if (pcmbuf_size
- audiobuffer_index
>= PCMBUF_MIN_CHUNK
)
879 /* Usual case, there's space here */
880 return &audiobuffer
[audiobuffer_index
];
884 /* Flush and wrap the buffer */
885 pcmbuf_flush_fillpos();
887 return &audiobuffer
[0];
897 void * pcmbuf_request_voice_buffer(int *count
)
899 /* A get-it-to-work-for-now hack (audio status could change by
901 if (audio_status() & AUDIO_STATUS_PLAY
)
903 if (pcmbuf_read
== NULL
)
907 else if (pcmbuf_usage() >= 10 && pcmbuf_mix_free() >= 30 &&
908 (pcmbuf_mix_chunk
|| pcmbuf_read
->link
))
910 *count
= MIN(*count
, PCMBUF_MIX_CHUNK
/4);
920 return pcmbuf_request_buffer(count
);
924 bool pcmbuf_is_crossfade_active(void)
926 return crossfade_active
|| crossfade_init
;
929 void pcmbuf_write_complete(int count
)
931 size_t length
= (size_t)(unsigned int)count
<< 2;
933 if (crossfade_active
)
935 flush_crossfade(fadebuf
, length
);
936 if (!(crossfade_fade_in_rem
|| crossfade_chunk
))
937 crossfade_active
= false;
941 audiobuffer_fillpos
+= length
;
943 if (NEED_FLUSH(audiobuffer_pos
+ audiobuffer_fillpos
))
944 pcmbuf_flush_fillpos();
949 bool pcmbuf_insert_buffer(char *buf
, int count
)
951 size_t length
= (size_t)(unsigned int)count
<< 2;
953 if (crossfade_active
)
955 flush_crossfade(buf
, length
);
956 if (!(crossfade_fade_in_rem
|| crossfade_chunk
))
957 crossfade_active
= false;
961 if (!prepare_insert(length
))
963 pcmbuf_flush_buffer(buf
, length
);
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
)
973 unsigned int count
= 0;
975 unsigned int interval
= NATIVE_FREQUENCY
/ frequency
;
976 unsigned int samples
= NATIVE_FREQUENCY
/ 1000 * duration
;
980 int16_t *pcmbuf_end
= (int16_t *)fadebuf
;
981 bool mix
= pcmbuf_read
!= NULL
&& pcmbuf_read
->link
!= NULL
;
983 /* Find the insertion point and set bufstart to the start of it */
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];
993 /* Use audiobuffer */
994 bufstart
= (int16_t *)audiobuffer
;
997 /* Mix square wave into buffer */
999 for (i
= 0; i
< samples
; ++i
)
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
;
1010 /* Toggle square wave edge */
1011 if (++count
>= interval
)
1014 amplitude
= -amplitude
;
1018 /* Kick off playback if required */
1019 if (!pcm_is_playing())
1021 pcm_play_data(NULL
, (unsigned char *)bufstart
, 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
)
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
;
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
);
1055 int16_t *ibuf
= (int16_t *)voicebuf
;
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
)
1069 obuf
= (int16_t *)pcmbuf_mix_chunk
->addr
;
1070 chunk_samples
= pcmbuf_mix_chunk
->size
/ sizeof (int16_t);
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
)
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
)
1095 /* Next setting to be used, not applied now */
1096 crossfade_enabled_pending
= 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
;