?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix yellow
[Rockbox.git] / apps / playback.c
blob4d00eda013e32e60a7ff37cfee5da3f3a6bbe018
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2005 Miika Pekkarinen
11 *
12 * All files in this archive are subject to the GNU General Public License.
13 * See the file COPYING in the source tree root for full license agreement.
14 *
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
17 *
18 ****************************************************************************/
19
20 /* TODO: Pause should be handled in here, rather than PCMBUF so that voice can
21 * play whilst audio is paused */
22
23 #include <stdio.h>
24 #include <string.h>
25 #include <stdlib.h>
26 #include <ctype.h>
27
28 #include "system.h"
29 #include "thread.h"
30 #include "file.h"
31 #include "panic.h"
32 #include "memory.h"
33 #include "lcd.h"
34 #include "font.h"
35 #include "button.h"
36 #include "kernel.h"
37 #include "tree.h"
38 #include "debug.h"
39 #include "sprintf.h"
40 #include "settings.h"
41 #include "codecs.h"
42 #include "audio.h"
43 #include "buffering.h"
44 #include "events.h"
45 #include "voice_thread.h"
46 #include "mp3_playback.h"
47 #include "usb.h"
48 #include "status.h"
49 #include "ata.h"
50 #include "screens.h"
51 #include "playlist.h"
52 #include "playback.h"
53 #include "pcmbuf.h"
54 #include "buffer.h"
55 #include "dsp.h"
56 #include "abrepeat.h"
57 #include "cuesheet.h"
58 #ifdef HAVE_TAGCACHE
59 #include "tagcache.h"
60 #endif
61 #ifdef HAVE_LCD_BITMAP
62 #include "icons.h"
63 #include "peakmeter.h"
64 #include "action.h"
65 #include "albumart.h"
66 #endif
67 #include "lang.h"
68 #include "bookmark.h"
69 #include "misc.h"
70 #include "sound.h"
71 #include "metadata.h"
72 #include "splash.h"
73 #include "talk.h"
74 #include "ata_idle_notify.h"
75
76 #ifdef HAVE_RECORDING
77 #include "recording.h"
78 #include "talk.h"
79 #endif
80
81 #define PLAYBACK_VOICE
82
83 /* default point to start buffer refill */
84 #define AUDIO_DEFAULT_WATERMARK (1024*512)
85 /* amount of guess-space to allow for codecs that must hunt and peck
86 * for their correct seeek target, 32k seems a good size */
87 #define AUDIO_REBUFFER_GUESS_SIZE (1024*32)
88
89 /* Define LOGF_ENABLE to enable logf output in this file */
90 /*#define LOGF_ENABLE*/
91 #include "logf.h"
92
93 /* macros to enable logf for queues
94 logging on SYS_TIMEOUT can be disabled */
95 #ifdef SIMULATOR
96 /* Define this for logf output of all queuing except SYS_TIMEOUT */
97 #define PLAYBACK_LOGQUEUES
98 /* Define this to logf SYS_TIMEOUT messages */
99 /*#define PLAYBACK_LOGQUEUES_SYS_TIMEOUT*/
100 #endif
101
102 #ifdef PLAYBACK_LOGQUEUES
103 #define LOGFQUEUE logf
104 #else
105 #define LOGFQUEUE(...)
106 #endif
107
108 #ifdef PLAYBACK_LOGQUEUES_SYS_TIMEOUT
109 #define LOGFQUEUE_SYS_TIMEOUT logf
110 #else
111 #define LOGFQUEUE_SYS_TIMEOUT(...)
112 #endif
113
114
115 /* Define one constant that includes recording related functionality */
116 #if defined(HAVE_RECORDING) && !defined(SIMULATOR)
117 #define AUDIO_HAVE_RECORDING
118 #endif
119
120 enum {
121 Q_NULL = 0,
122 Q_AUDIO_PLAY = 1,
123 Q_AUDIO_STOP,
124 Q_AUDIO_PAUSE,
125 Q_AUDIO_SKIP,
126 Q_AUDIO_PRE_FF_REWIND,
127 Q_AUDIO_FF_REWIND,
128 Q_AUDIO_CHECK_NEW_TRACK,
129 Q_AUDIO_FLUSH,
130 Q_AUDIO_TRACK_CHANGED,
131 Q_AUDIO_DIR_SKIP,
132 Q_AUDIO_POSTINIT,
133 Q_AUDIO_FILL_BUFFER,
134 Q_CODEC_REQUEST_COMPLETE,
135 Q_CODEC_REQUEST_FAILED,
136
137 Q_CODEC_LOAD,
138 Q_CODEC_LOAD_DISK,
139
140 #ifdef AUDIO_HAVE_RECORDING
141 Q_ENCODER_LOAD_DISK,
142 Q_ENCODER_RECORD,
143 #endif
144 };
145
146 enum filling_state {
147 STATE_IDLE, /* audio is stopped: nothing to do */
148 STATE_FILLING, /* adding tracks to the buffer */
149 STATE_FULL, /* can't add any more tracks */
150 STATE_FINISHED, /* all remaining tracks have been added */
151 };
152
153 /* As defined in plugins/lib/xxx2wav.h */
154 #if MEM > 1
155 #define MALLOC_BUFSIZE (512*1024)
156 #define GUARD_BUFSIZE (32*1024)
157 #else
158 #define MALLOC_BUFSIZE (100*1024)
159 #define GUARD_BUFSIZE (8*1024)
160 #endif
161
162 /* As defined in plugin.lds */
163 #if defined(CPU_PP)
164 #define CODEC_IRAM_ORIGIN ((unsigned char *)0x4000c000)
165 #define CODEC_IRAM_SIZE ((size_t)0xc000)
166 #elif defined(IAUDIO_X5) || defined(IAUDIO_M5)
167 #define CODEC_IRAM_ORIGIN ((unsigned char *)0x10010000)
168 #define CODEC_IRAM_SIZE ((size_t)0x10000)
169 #else
170 #define CODEC_IRAM_ORIGIN ((unsigned char *)0x1000c000)
171 #define CODEC_IRAM_SIZE ((size_t)0xc000)
172 #endif
173
174 bool audio_is_initialized = false;
175 static bool audio_thread_ready SHAREDBSS_ATTR = false;
176
177 /* Variables are commented with the threads that use them: *
178 * A=audio, C=codec, V=voice. A suffix of - indicates that *
179 * the variable is read but not updated on that thread. */
180 /* TBD: Split out "audio" and "playback" (ie. calling) threads */
181
182 /* Main state control */
183 static volatile bool audio_codec_loaded SHAREDBSS_ATTR = false; /* Codec loaded? (C/A-) */
184 static volatile bool playing SHAREDBSS_ATTR = false; /* Is audio playing? (A) */
185 static volatile bool paused SHAREDBSS_ATTR = false; /* Is audio paused? (A/C-) */
186
187 /* Ring buffer where compressed audio and codecs are loaded */
188 static unsigned char *filebuf = NULL; /* Start of buffer (A/C-) */
189 static unsigned char *malloc_buf = NULL; /* Start of malloc buffer (A/C-) */
190 /* FIXME: make filebuflen static */
191 size_t filebuflen = 0; /* Size of buffer (A/C-) */
192 /* FIXME: make buf_ridx (C/A-) */
193
194 /* Possible arrangements of the buffer */
195 #define BUFFER_STATE_TRASHED -1 /* trashed; must be reset */
196 #define BUFFER_STATE_INITIALIZED 0 /* voice+audio OR audio-only */
197 #define BUFFER_STATE_VOICED_ONLY 1 /* voice-only */
198 static int buffer_state = BUFFER_STATE_TRASHED; /* Buffer state */
199
200 /* Used to keep the WPS up-to-date during track transtition */
201 static struct mp3entry prevtrack_id3;
202
203 /* Used to provide the codec with a pointer */
204 static struct mp3entry curtrack_id3;
205
206 /* Used to make next track info available while playing last track on buffer */
207 static struct mp3entry lasttrack_id3;
208
209 /* Track info structure about songs in the file buffer (A/C-) */
210 struct track_info {
211 int audio_hid; /* The ID for the track's buffer handle */
212 int id3_hid; /* The ID for the track's metadata handle */
213 int codec_hid; /* The ID for the track's codec handle */
214 #ifdef HAVE_ALBUMART
215 int aa_hid; /* The ID for the track's album art handle */
216 #endif
217
218 size_t filesize; /* File total length */
219
220 bool taginfo_ready; /* Is metadata read */
221 };
222
223 static struct track_info tracks[MAX_TRACK];
224 static volatile int track_ridx = 0; /* Track being decoded (A/C-) */
225 static int track_widx = 0; /* Track being buffered (A) */
226
227 #define CUR_TI (&tracks[track_ridx]) /* Playing track info pointer (A/C-) */
228 static struct track_info *prev_ti = NULL; /* Pointer to the previously played
229 track */
230
231 /* Set by the audio thread when the current track information has updated
232 * and the WPS may need to update its cached information */
233 static bool track_changed = false;
234
235 /* Information used only for filling the buffer */
236 /* Playlist steps from playing track to next track to be buffered (A) */
237 static int last_peek_offset = 0;
238
239 /* Scrobbler support */
240 static unsigned long prev_track_elapsed = 0; /* Previous track elapsed time (C/A-)*/
241
242 static enum filling_state filling;
243
244 /* Track change controls */
245 static bool automatic_skip = false; /* Who initiated in-progress skip? (C/A-) */
246 static bool playlist_end = false; /* Has the current playlist ended? (A) */
247 static bool dir_skip = false; /* Is a directory skip pending? (A) */
248 static bool new_playlist = false; /* Are we starting a new playlist? (A) */
249 static int wps_offset = 0; /* Pending track change offset, to keep WPS responsive (A) */
250 static bool skipped_during_pause = false; /* Do we need to clear the PCM buffer when playback resumes (A) */
251
252 /* Set to true if the codec thread should send an audio stop request
253 * (typically because the end of the playlist has been reached).
254 */
255 static bool codec_requested_stop = false;
256
257 static size_t buffer_margin = 0; /* Buffer margin aka anti-skip buffer (A/C-) */
258
259 /* Multiple threads */
260 /* Set the watermark to trigger buffer fill (A/C) FIXME */
261 static void set_filebuf_watermark(int seconds, size_t max);
262
263 /* Audio thread */
264 static struct event_queue audio_queue SHAREDBSS_ATTR;
265 static struct queue_sender_list audio_queue_sender_list SHAREDBSS_ATTR;
266 static long audio_stack[(DEFAULT_STACK_SIZE + 0x1000)/sizeof(long)];
267 static const char audio_thread_name[] = "audio";
268
269 static void audio_thread(void);
270 static void audio_initiate_track_change(long direction);
271 static bool audio_have_tracks(void);
272 static void audio_reset_buffer(void);
273
274 /* Codec thread */
275 extern struct codec_api ci;
276 static struct event_queue codec_queue SHAREDBSS_ATTR;
277 static struct queue_sender_list codec_queue_sender_list;
278 static long codec_stack[(DEFAULT_STACK_SIZE + 0x2000)/sizeof(long)]
279 IBSS_ATTR;
280 static const char codec_thread_name[] = "codec";
281 struct thread_entry *codec_thread_p; /* For modifying thread priority later. */
282
283 /* PCM buffer messaging */
284 static struct event_queue pcmbuf_queue SHAREDBSS_ATTR;
285
286 /* Function to be called by pcm buffer callbacks.
287 * Permissible Context(s): Audio interrupt
288 */
289 static void pcmbuf_callback_queue_post(long id, intptr_t data)
290 {
291 /* No lock since we're already in audio interrupt context */
292 queue_post(&pcmbuf_queue, id, data);
293 }
294
295 /* Scan the pcmbuf queue and return true if a message pulled.
296 * Permissible Context(s): Thread
297 */
298 static bool pcmbuf_queue_scan(struct queue_event *ev)
299 {
300 if (!queue_empty(&pcmbuf_queue))
301 {
302 /* Transfer message to audio queue */
303 pcm_play_lock();
304 /* Pull message - never, ever any blocking call! */
305 queue_wait_w_tmo(&pcmbuf_queue, ev, 0);
306 pcm_play_unlock();
307 return true;
308 }
309
310 return false;
311 }
312
313 /* Clear the pcmbuf queue of messages
314 * Permissible Context(s): Thread
315 */
316 static void pcmbuf_queue_clear(void)
317 {
318 pcm_play_lock();
319 queue_clear(&pcmbuf_queue);
320 pcm_play_unlock();
321 }
322
323 /* --- Helper functions --- */
324
325 static struct mp3entry *bufgetid3(int handle_id)
326 {
327 if (handle_id < 0)
328 return NULL;
329
330 struct mp3entry *id3;
331 ssize_t ret = bufgetdata(handle_id, 0, (void *)&id3);
332
333 if (ret < 0 || ret != sizeof(struct mp3entry))
334 return NULL;
335
336 return id3;
337 }
338
339 static bool clear_track_info(struct track_info *track)
340 {
341 /* bufclose returns true if the handle is not found, or if it is closed
342 * successfully, so these checks are safe on non-existant handles */
343 if (!track)
344 return false;
345
346 if (track->codec_hid >= 0) {
347 if (bufclose(track->codec_hid))
348 track->codec_hid = -1;
349 else
350 return false;
351 }
352
353 if (track->id3_hid >= 0) {
354 if (bufclose(track->id3_hid))
355 track->id3_hid = -1;
356 else
357 return false;
358 }
359
360 if (track->audio_hid >= 0) {
361 if (bufclose(track->audio_hid))
362 track->audio_hid = -1;
363 else
364 return false;
365 }
366
367 #ifdef HAVE_ALBUMART
368 if (track->aa_hid >= 0) {
369 if (bufclose(track->aa_hid))
370 track->aa_hid = -1;
371 else
372 return false;
373 }
374 #endif
375
376 track->filesize = 0;
377 track->taginfo_ready = false;
378
379 return true;
380 }
381
382 /* --- External interfaces --- */
383
384 /* This sends a stop message and the audio thread will dump all it's
385 subsequenct messages */
386 void audio_hard_stop(void)
387 {
388 /* Stop playback */
389 LOGFQUEUE("audio >| audio Q_AUDIO_STOP: 1");
390 queue_send(&audio_queue, Q_AUDIO_STOP, 1);
391 #ifdef PLAYBACK_VOICE
392 voice_stop();
393 #endif
394 }
395
396 bool audio_restore_playback(int type)
397 {
398 switch (type)
399 {
400 case AUDIO_WANT_PLAYBACK:
401 if (buffer_state != BUFFER_STATE_INITIALIZED)
402 audio_reset_buffer();
403 return true;
404 case AUDIO_WANT_VOICE:
405 if (buffer_state == BUFFER_STATE_TRASHED)
406 audio_reset_buffer();
407 return true;
408 default:
409 return false;
410 }
411 }
412
413 unsigned char *audio_get_buffer(bool talk_buf, size_t *buffer_size)
414 {
415 unsigned char *buf, *end;
416
417 if (audio_is_initialized)
418 {
419 audio_hard_stop();
420 }
421 /* else buffer_state will be BUFFER_STATE_TRASHED at this point */
422
423 if (buffer_size == NULL)
424 {
425 /* Special case for talk_init to use since it already knows it's
426 trashed */
427 buffer_state = BUFFER_STATE_TRASHED;
428 return NULL;
429 }
430
431 if (talk_buf || buffer_state == BUFFER_STATE_TRASHED
432 || !talk_voice_required())
433 {
434 logf("get buffer: talk, audio");
435 /* Ok to use everything from audiobuf to audiobufend - voice is loaded,
436 the talk buffer is not needed because voice isn't being used, or
437 could be BUFFER_STATE_TRASHED already. If state is
438 BUFFER_STATE_VOICED_ONLY, no problem as long as memory isn't written
439 without the caller knowing what's going on. Changing certain settings
440 may move it to a worse condition but the memory in use by something
441 else will remain undisturbed.
442 */
443 if (buffer_state != BUFFER_STATE_TRASHED)
444 {
445 talk_buffer_steal();
446 buffer_state = BUFFER_STATE_TRASHED;
447 }
448
449 buf = audiobuf;
450 end = audiobufend;
451 }
452 else
453 {
454 /* Safe to just return this if already BUFFER_STATE_VOICED_ONLY or
455 still BUFFER_STATE_INITIALIZED */
456 /* Skip talk buffer and move pcm buffer to end to maximize available
457 contiguous memory - no audio running means voice will not need the
458 swap space */
459 logf("get buffer: audio");
460 buf = audiobuf + talk_get_bufsize();
461 end = audiobufend - pcmbuf_init(audiobufend);
462 buffer_state = BUFFER_STATE_VOICED_ONLY;
463 }
464
465 *buffer_size = end - buf;
466
467 return buf;
468 }
469
470 #ifdef HAVE_RECORDING
471 unsigned char *audio_get_recording_buffer(size_t *buffer_size)
472 {
473 /* Stop audio, voice and obtain all available buffer space */
474 audio_hard_stop();
475 talk_buffer_steal();
476
477 unsigned char *end = audiobufend;
478 buffer_state = BUFFER_STATE_TRASHED;
479 *buffer_size = end - audiobuf;
480
481 return (unsigned char *)audiobuf;
482 }
483
484 bool audio_load_encoder(int afmt)
485 {
486 #ifndef SIMULATOR
487 const char *enc_fn = get_codec_filename(afmt | CODEC_TYPE_ENCODER);
488 if (!enc_fn)
489 return false;
490
491 audio_remove_encoder();
492 ci.enc_codec_loaded = 0; /* clear any previous error condition */
493
494 LOGFQUEUE("codec > Q_ENCODER_LOAD_DISK");
495 queue_post(&codec_queue, Q_ENCODER_LOAD_DISK, (intptr_t)enc_fn);
496
497 while (ci.enc_codec_loaded == 0)
498 yield();
499
500 logf("codec loaded: %d", ci.enc_codec_loaded);
501
502 return ci.enc_codec_loaded > 0;
503 #else
504 (void)afmt;
505 return true;
506 #endif
507 } /* audio_load_encoder */
508
509 void audio_remove_encoder(void)
510 {
511 #ifndef SIMULATOR
512 /* force encoder codec unload (if currently loaded) */
513 if (ci.enc_codec_loaded <= 0)
514 return;
515
516 ci.stop_encoder = true;
517 while (ci.enc_codec_loaded > 0)
518 yield();
519 #endif
520 } /* audio_remove_encoder */
521
522 #endif /* HAVE_RECORDING */
523
524 #ifdef HAVE_ALBUMART
525 int audio_current_aa_hid(void)
526 {
527 int cur_idx;
528 int offset = ci.new_track + wps_offset;
529
530 cur_idx = track_ridx + offset;
531 cur_idx &= MAX_TRACK_MASK;
532
533 return tracks[cur_idx].aa_hid;
534 }
535 #endif
536
537 struct mp3entry* audio_current_track(void)
538 {
539 const char *filename;
540 const char *p;
541 static struct mp3entry temp_id3;
542 int cur_idx;
543 int offset = ci.new_track + wps_offset;
544
545 cur_idx = (track_ridx + offset) & MAX_TRACK_MASK;
546
547 if (cur_idx == track_ridx && *curtrack_id3.path)
548 {
549 /* The usual case */
550 return &curtrack_id3;
551 }
552 else if (offset == -1 && *prevtrack_id3.path)
553 {
554 /* We're in a track transition. The codec has moved on to the nex track,
555 but the audio being played is still the same (now previous) track.
556 prevtrack_id3.elapsed is being updated in an ISR by
557 codec_pcmbuf_position_callback */
558 return &prevtrack_id3;
559 }
560 else if (tracks[cur_idx].id3_hid >= 0)
561 {
562 /* Get the ID3 metadata from the main buffer */
563 return bufgetid3(tracks[cur_idx].id3_hid);
564 }
565
566 /* We didn't find the ID3 metadata, so we fill temp_id3 with the little info
567 we have and return that. */
568
569 memset(&temp_id3, 0, sizeof(struct mp3entry));
570
571 filename = playlist_peek(0);
572 if (!filename)
573 filename = "No file!";
574
575 #if defined(HAVE_TC_RAMCACHE) && defined(HAVE_DIRCACHE)
576 if (tagcache_fill_tags(&temp_id3, filename))
577 return &temp_id3;
578 #endif
579
580 p = strrchr(filename, '/');
581 if (!p)
582 p = filename;
583 else
584 p++;
585
586 strncpy(temp_id3.path, p, sizeof(temp_id3.path)-1);
587 temp_id3.title = &temp_id3.path[0];
588 temp_id3.index = playlist_get_display_index() - 1 + wps_offset;
589
590 return &temp_id3;
591 }
592
593 struct mp3entry* audio_next_track(void)
594 {
595 int next_idx;
596 int offset = ci.new_track + wps_offset;
597
598 if (!audio_have_tracks())
599 return NULL;
600
601 if (wps_offset == -1 && *prevtrack_id3.path)
602 {
603 /* We're in a track transition. The next track for the WPS is the one
604 currently being decoded. */
605 return &curtrack_id3;
606 }
607
608 next_idx = (track_ridx + offset + 1) & MAX_TRACK_MASK;
609
610 if (next_idx == track_widx)
611 {
612 /* The next track hasn't been buffered yet, so we return the static
613 version of its metadata. */
614 return &lasttrack_id3;
615 }
616
617 if (tracks[next_idx].id3_hid < 0)
618 return NULL;
619 else
620 return bufgetid3(tracks[next_idx].id3_hid);
621 }
622
623 bool audio_has_changed_track(void)
624 {
625 if (track_changed)
626 {
627 track_changed = false;
628 return true;
629 }
630
631 return false;
632 }
633
634 void audio_play(long offset)
635 {
636 logf("audio_play");
637
638 #ifdef PLAYBACK_VOICE
639 /* Truncate any existing voice output so we don't have spelling
640 * etc. over the first part of the played track */
641 talk_force_shutup();
642 #endif
643
644 /* Start playback */
645 LOGFQUEUE("audio >| audio Q_AUDIO_PLAY: %ld", offset);
646 /* Don't return until playback has actually started */
647 queue_send(&audio_queue, Q_AUDIO_PLAY, offset);
648 }
649
650 void audio_stop(void)
651 {
652 /* Stop playback */
653 LOGFQUEUE("audio >| audio Q_AUDIO_STOP");
654 /* Don't return until playback has actually stopped */
655 queue_send(&audio_queue, Q_AUDIO_STOP, 0);
656 }
657
658 void audio_pause(void)
659 {
660 LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE");
661 /* Don't return until playback has actually paused */
662 queue_send(&audio_queue, Q_AUDIO_PAUSE, true);
663 }
664
665 void audio_resume(void)
666 {
667 LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE resume");
668 /* Don't return until playback has actually resumed */
669 queue_send(&audio_queue, Q_AUDIO_PAUSE, false);
670 }
671
672 static void audio_skip(int direction)
673 {
674 if (playlist_check(ci.new_track + wps_offset + direction))
675 {
676 if (global_settings.beep)
677 pcmbuf_beep(5000, 100, 2500*global_settings.beep);
678
679 LOGFQUEUE("audio > audio Q_AUDIO_SKIP %d", direction);
680 queue_post(&audio_queue, Q_AUDIO_SKIP, direction);
681 /* Update wps while our message travels inside deep playback queues. */
682 wps_offset += direction;
683 track_changed = true;
684 }
685 else
686 {
687 /* No more tracks. */
688 if (global_settings.beep)
689 pcmbuf_beep(1000, 100, 1000*global_settings.beep);
690 }
691 }
692
693 void audio_next(void)
694 {
695 audio_skip(1);
696 }
697
698 void audio_prev(void)
699 {
700 audio_skip(-1);
701 }
702
703 void audio_next_dir(void)
704 {
705 LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP 1");
706 queue_post(&audio_queue, Q_AUDIO_DIR_SKIP, 1);
707 }
708
709 void audio_prev_dir(void)
710 {
711 LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP -1");
712 queue_post(&audio_queue, Q_AUDIO_DIR_SKIP, -1);
713 }
714
715 void audio_pre_ff_rewind(void)
716 {
717 LOGFQUEUE("audio > audio Q_AUDIO_PRE_FF_REWIND");
718 queue_post(&audio_queue, Q_AUDIO_PRE_FF_REWIND, 0);
719 }
720
721 void audio_ff_rewind(long newpos)
722 {
723 LOGFQUEUE("audio > audio Q_AUDIO_FF_REWIND");
724 queue_post(&audio_queue, Q_AUDIO_FF_REWIND, newpos);
725 }
726
727 void audio_flush_and_reload_tracks(void)
728 {
729 LOGFQUEUE("audio > audio Q_AUDIO_FLUSH");
730 queue_post(&audio_queue, Q_AUDIO_FLUSH, 0);
731 }
732
733 void audio_error_clear(void)
734 {
735 #ifdef AUDIO_HAVE_RECORDING
736 pcm_rec_error_clear();
737 #endif
738 }
739
740 int audio_status(void)
741 {
742 int ret = 0;
743
744 if (playing)
745 ret |= AUDIO_STATUS_PLAY;
746
747 if (paused)
748 ret |= AUDIO_STATUS_PAUSE;
749
750 #ifdef HAVE_RECORDING
751 /* Do this here for constitency with mpeg.c version */
752 ret |= pcm_rec_status();
753 #endif
754
755 return ret;
756 }
757
758 int audio_get_file_pos(void)
759 {
760 return 0;
761 }
762
763 #ifndef HAVE_FLASH_STORAGE
764 void audio_set_buffer_margin(int setting)
765 {
766 static const int lookup[] = {5, 15, 30, 60, 120, 180, 300, 600};
767 buffer_margin = lookup[setting];
768 logf("buffer margin: %ld", (long)buffer_margin);
769 set_filebuf_watermark(buffer_margin, 0);
770 }
771 #endif
772
773 /* Take necessary steps to enable or disable the crossfade setting */
774 void audio_set_crossfade(int enable)
775 {
776 size_t offset;
777 bool was_playing;
778 size_t size;
779
780 /* Tell it the next setting to use */
781 pcmbuf_crossfade_enable(enable);
782
783 /* Return if size hasn't changed or this is too early to determine
784 which in the second case there's no way we could be playing
785 anything at all */
786 if (pcmbuf_is_same_size())
787 {
788 /* This function is a copout and just syncs some variables -
789 to be removed at a later date */
790 pcmbuf_crossfade_enable_finished();
791 return;
792 }
793
794 offset = 0;
795 was_playing = playing;
796
797 /* Playback has to be stopped before changing the buffer size */
798 if (was_playing)
799 {
800 /* Store the track resume position */
801 offset = curtrack_id3.offset;
802 gui_syncsplash(0, str(LANG_RESTARTING_PLAYBACK));
803 }
804
805 /* Blast it - audio buffer will have to be setup again next time
806 something plays */
807 audio_get_buffer(true, &size);
808
809 /* Restart playback if audio was running previously */
810 if (was_playing)
811 audio_play(offset);
812 }
813
814 /* --- Routines called from multiple threads --- */
815
816 static void set_filebuf_watermark(int seconds, size_t max)
817 {
818 size_t bytes;
819
820 if (!filebuf)
821 return; /* Audio buffers not yet set up */
822
823 bytes = seconds?MAX(curtrack_id3.bitrate * seconds * (1000/8), max):max;
824 bytes = MIN(bytes, filebuflen / 2);
825 buf_set_watermark(bytes);
826 }
827
828 const char *get_codec_filename(int cod_spec)
829 {
830 const char *fname;
831
832 #ifdef HAVE_RECORDING
833 /* Can choose decoder or encoder if one available */
834 int type = cod_spec & CODEC_TYPE_MASK;
835 int afmt = cod_spec & CODEC_AFMT_MASK;
836
837 if ((unsigned)afmt >= AFMT_NUM_CODECS)
838 type = AFMT_UNKNOWN | (type & CODEC_TYPE_MASK);
839
840 fname = (type == CODEC_TYPE_ENCODER) ?
841 audio_formats[afmt].codec_enc_root_fn :
842 audio_formats[afmt].codec_root_fn;
843
844 logf("%s: %d - %s",
845 (type == CODEC_TYPE_ENCODER) ? "Encoder" : "Decoder",
846 afmt, fname ? fname : "<unknown>");
847 #else /* !HAVE_RECORDING */
848 /* Always decoder */
849 if ((unsigned)cod_spec >= AFMT_NUM_CODECS)
850 cod_spec = AFMT_UNKNOWN;
851 fname = audio_formats[cod_spec].codec_root_fn;
852 logf("Codec: %d - %s", cod_spec, fname ? fname : "<unknown>");
853 #endif /* HAVE_RECORDING */
854
855 return fname;
856 } /* get_codec_filename */
857
858 /* --- Codec thread --- */
859 static bool codec_pcmbuf_insert_callback(
860 const void *ch1, const void *ch2, int count)
861 {
862 const char *src[2] = { ch1, ch2 };
863
864 while (count > 0)
865 {
866 int out_count = dsp_output_count(ci.dsp, count);
867 int inp_count;
868 char *dest;
869
870 /* Prevent audio from a previous track from playing */
871 if (ci.new_track || ci.stop_codec)
872 return true;
873
874 while ((dest = pcmbuf_request_buffer(&out_count)) == NULL)
875 {
876 cancel_cpu_boost();
877 sleep(1);
878 if (ci.seek_time || ci.new_track || ci.stop_codec)
879 return true;
880 }
881
882 /* Get the real input_size for output_size bytes, guarding
883 * against resampling buffer overflows. */
884 inp_count = dsp_input_count(ci.dsp, out_count);
885
886 if (inp_count <= 0)
887 return true;
888
889 /* Input size has grown, no error, just don't write more than length */
890 if (inp_count > count)
891 inp_count = count;
892
893 out_count = dsp_process(ci.dsp, dest, src, inp_count);
894
895 if (out_count <= 0)
896 return true;
897
898 pcmbuf_write_complete(out_count);
899
900 count -= inp_count;
901 }
902
903 return true;
904 } /* codec_pcmbuf_insert_callback */
905
906 static void* codec_get_memory_callback(size_t *size)
907 {
908 *size = MALLOC_BUFSIZE;
909 return malloc_buf;
910 }
911
912 /* Between the codec and PCM track change, we need to keep updating the
913 "elapsed" value of the previous (to the codec, but current to the
914 user/PCM/WPS) track, so that the progressbar reaches the end.
915 During that transition, the WPS will display prevtrack_id3. */
916 static void codec_pcmbuf_position_callback(size_t size) ICODE_ATTR;
917 static void codec_pcmbuf_position_callback(size_t size)
918 {
919 /* This is called from an ISR, so be quick */
920 unsigned int time = size * 1000 / 4 / NATIVE_FREQUENCY +
921 prevtrack_id3.elapsed;
922
923 if (time >= prevtrack_id3.length)
924 {
925 pcmbuf_set_position_callback(NULL);
926 prevtrack_id3.elapsed = prevtrack_id3.length;
927 }
928 else
929 prevtrack_id3.elapsed = time;
930 }
931
932 static void codec_set_elapsed_callback(unsigned int value)
933 {
934 unsigned int latency;
935 if (ci.seek_time)
936 return;
937
938 #ifdef AB_REPEAT_ENABLE
939 ab_position_report(value);
940 #endif
941
942 latency = pcmbuf_get_latency();
943 if (value < latency)
944 curtrack_id3.elapsed = 0;
945 else if (value - latency > curtrack_id3.elapsed ||
946 value - latency < curtrack_id3.elapsed - 2)
947 {
948 curtrack_id3.elapsed = value - latency;
949 }
950 }
951
952 static void codec_set_offset_callback(size_t value)
953 {
954 unsigned int latency;
955
956 if (ci.seek_time)
957 return;
958
959 latency = pcmbuf_get_latency() * curtrack_id3.bitrate / 8;
960 if (value < latency)
961 curtrack_id3.offset = 0;
962 else
963 curtrack_id3.offset = value - latency;
964 }
965
966 static void codec_advance_buffer_counters(size_t amount)
967 {
968 bufadvance(CUR_TI->audio_hid, amount);
969 ci.curpos += amount;
970 }
971
972 /* copy up-to size bytes into ptr and return the actual size copied */
973 static size_t codec_filebuf_callback(void *ptr, size_t size)
974 {
975 ssize_t copy_n;
976
977 if (ci.stop_codec || !playing)
978 return 0;
979
980 copy_n = bufread(CUR_TI->audio_hid, size, ptr);
981
982 /* Nothing requested OR nothing left */
983 if (copy_n == 0)
984 return 0;
985
986 /* Update read and other position pointers */
987 codec_advance_buffer_counters(copy_n);
988
989 /* Return the actual amount of data copied to the buffer */
990 return copy_n;
991 } /* codec_filebuf_callback */
992
993 static void* codec_request_buffer_callback(size_t *realsize, size_t reqsize)
994 {
995 size_t copy_n = reqsize;
996 ssize_t ret;
997 void *ptr;
998
999 if (!playing)
1000 {
1001 *realsize = 0;
1002 return NULL;
1003 }
1004
1005 ret = bufgetdata(CUR_TI->audio_hid, reqsize, &ptr);
1006 if (ret >= 0)
1007 copy_n = MIN((size_t)ret, reqsize);
1008
1009 if (copy_n == 0)
1010 {
1011 *realsize = 0;
1012 return NULL;
1013 }
1014
1015 *realsize = copy_n;
1016
1017 return ptr;
1018 } /* codec_request_buffer_callback */
1019
1020 static int get_codec_base_type(int type)
1021 {
1022 switch (type) {
1023 case AFMT_MPA_L1:
1024 case AFMT_MPA_L2:
1025 case AFMT_MPA_L3:
1026 return AFMT_MPA_L3;
1027 }
1028
1029 return type;
1030 }
1031
1032 static void codec_advance_buffer_callback(size_t amount)
1033 {
1034 codec_advance_buffer_counters(amount);
1035 codec_set_offset_callback(ci.curpos);
1036 }
1037
1038 static void codec_advance_buffer_loc_callback(void *ptr)
1039 {
1040 size_t amount = buf_get_offset(CUR_TI->audio_hid, ptr);
1041 codec_advance_buffer_callback(amount);
1042 }
1043
1044 static void codec_seek_complete_callback(void)
1045 {
1046 logf("seek_complete");
1047 if (pcm_is_paused())
1048 {
1049 /* If this is not a seamless seek, clear the buffer */
1050 pcmbuf_play_stop();
1051 dsp_configure(ci.dsp, DSP_FLUSH, 0);
1052
1053 /* If playback was not 'deliberately' paused, unpause now */
1054 if (!paused)
1055 pcmbuf_pause(false);
1056 }
1057 ci.seek_time = 0;
1058 }
1059
1060 static bool codec_seek_buffer_callback(size_t newpos)
1061 {
1062 logf("codec_seek_buffer_callback");
1063
1064 int ret = bufseek(CUR_TI->audio_hid, newpos);
1065 if (ret == 0) {
1066 ci.curpos = newpos;
1067 return true;
1068 }
1069 else {
1070 return false;
1071 }
1072 }
1073
1074 static void codec_configure_callback(int setting, intptr_t value)
1075 {
1076 switch (setting) {
1077 case CODEC_SET_FILEBUF_WATERMARK:
1078 set_filebuf_watermark(buffer_margin, value);
1079 break;
1080
1081 default:
1082 if (!dsp_configure(ci.dsp, setting, value))
1083 { logf("Illegal key:%d", setting); }
1084 }
1085 }
1086
1087 static void codec_track_changed(void)
1088 {
1089 LOGFQUEUE("codec > audio Q_AUDIO_TRACK_CHANGED");
1090 queue_post(&audio_queue, Q_AUDIO_TRACK_CHANGED, 0);
1091 }
1092
1093 static void codec_pcmbuf_track_changed_callback(void)
1094 {
1095 pcmbuf_set_position_callback(NULL);
1096 pcmbuf_callback_queue_post(Q_AUDIO_TRACK_CHANGED, 0);
1097 }
1098
1099 static void codec_discard_codec_callback(void)
1100 {
1101 if (CUR_TI->codec_hid >= 0)
1102 {
1103 bufclose(CUR_TI->codec_hid);
1104 CUR_TI->codec_hid = -1;
1105 }
1106 }
1107
1108 static inline void codec_gapless_track_change(void)
1109 {
1110 /* callback keeps the progress bar moving while the pcmbuf empties */
1111 pcmbuf_set_position_callback(codec_pcmbuf_position_callback);
1112 /* set the pcmbuf callback for when the track really changes */
1113 pcmbuf_set_event_handler(codec_pcmbuf_track_changed_callback);
1114 }
1115
1116 static inline void codec_crossfade_track_change(void)
1117 {
1118 /* Initiate automatic crossfade mode */
1119 pcmbuf_crossfade_init(false);
1120 /* Notify the wps that the track change starts now */
1121 codec_track_changed();
1122 }
1123
1124 static void codec_track_skip_done(bool was_manual)
1125 {
1126 /* Manual track change (always crossfade or flush audio). */
1127 if (was_manual)
1128 {
1129 pcmbuf_crossfade_init(true);
1130 LOGFQUEUE("codec > audio Q_AUDIO_TRACK_CHANGED");
1131 queue_post(&audio_queue, Q_AUDIO_TRACK_CHANGED, 0);
1132 }
1133 /* Automatic track change w/crossfade, if not in "Track Skip Only" mode. */
1134 else if (pcmbuf_is_crossfade_enabled() && !pcmbuf_is_crossfade_active()
1135 && global_settings.crossfade != CROSSFADE_ENABLE_TRACKSKIP)
1136 {
1137 if (global_settings.crossfade == CROSSFADE_ENABLE_SHUFFLE_AND_TRACKSKIP)
1138 {
1139 if (global_settings.playlist_shuffle)
1140 /* shuffle mode is on, so crossfade: */
1141 codec_crossfade_track_change();
1142 else
1143 /* shuffle mode is off, so do a gapless track change */
1144 codec_gapless_track_change();
1145 }
1146 else
1147 /* normal crossfade: */
1148 codec_crossfade_track_change();
1149 }
1150 else
1151 /* normal gapless playback. */
1152 codec_gapless_track_change();
1153 }
1154
1155 static bool codec_load_next_track(void)
1156 {
1157 intptr_t result = Q_CODEC_REQUEST_FAILED;
1158
1159 prev_track_elapsed = curtrack_id3.elapsed;
1160
1161 #ifdef AB_REPEAT_ENABLE
1162 ab_end_of_track_report();
1163 #endif
1164
1165 logf("Request new track");
1166
1167 if (ci.new_track == 0)
1168 {
1169 ci.new_track++;
1170 automatic_skip = true;
1171 }
1172
1173 if (!ci.stop_codec)
1174 {
1175 trigger_cpu_boost();
1176 LOGFQUEUE("codec >| audio Q_AUDIO_CHECK_NEW_TRACK");
1177 result = queue_send(&audio_queue, Q_AUDIO_CHECK_NEW_TRACK, 0);
1178 }
1179
1180 switch (result)
1181 {
1182 case Q_CODEC_REQUEST_COMPLETE:
1183 LOGFQUEUE("codec |< Q_CODEC_REQUEST_COMPLETE");
1184 codec_track_skip_done(!automatic_skip);
1185 return true;
1186
1187 case Q_CODEC_REQUEST_FAILED:
1188 LOGFQUEUE("codec |< Q_CODEC_REQUEST_FAILED");
1189 ci.new_track = 0;
1190 ci.stop_codec = true;
1191 codec_requested_stop = true;
1192 return false;
1193
1194 default:
1195 LOGFQUEUE("codec |< default");
1196 ci.stop_codec = true;
1197 codec_requested_stop = true;
1198 return false;
1199 }
1200 }
1201
1202 static bool codec_request_next_track_callback(void)
1203 {
1204 int prev_codectype;
1205
1206 if (ci.stop_codec || !playing)
1207 return false;
1208
1209 prev_codectype = get_codec_base_type(curtrack_id3.codectype);
1210
1211 if (!codec_load_next_track())
1212 return false;
1213
1214 /* Check if the next codec is the same file. */
1215 if (prev_codectype == get_codec_base_type(curtrack_id3.codectype))
1216 {
1217 logf("New track loaded");
1218 codec_discard_codec_callback();
1219 return true;
1220 }
1221 else
1222 {
1223 logf("New codec:%d/%d", curtrack_id3.codectype, prev_codectype);
1224 return false;
1225 }
1226 }
1227
1228 static void codec_thread(void)
1229 {
1230 struct queue_event ev;
1231 int status;
1232
1233 while (1) {
1234 status = 0;
1235
1236 if (!pcmbuf_is_crossfade_active()) {
1237 cancel_cpu_boost();
1238 }
1239
1240 queue_wait(&codec_queue, &ev);
1241 codec_requested_stop = false;
1242
1243 switch (ev.id) {
1244 case Q_CODEC_LOAD_DISK:
1245 LOGFQUEUE("codec < Q_CODEC_LOAD_DISK");
1246 queue_reply(&codec_queue, 1);
1247 audio_codec_loaded = true;
1248 ci.stop_codec = false;
1249 status = codec_load_file((const char *)ev.data, &ci);
1250 break;
1251
1252 case Q_CODEC_LOAD:
1253 LOGFQUEUE("codec < Q_CODEC_LOAD");
1254 if (CUR_TI->codec_hid < 0) {
1255 logf("Codec slot is empty!");
1256 /* Wait for the pcm buffer to go empty */
1257 while (pcm_is_playing())
1258 yield();
1259 /* This must be set to prevent an infinite loop */
1260 ci.stop_codec = true;
1261 LOGFQUEUE("codec > codec Q_AUDIO_PLAY");
1262 queue_post(&codec_queue, Q_AUDIO_PLAY, 0);
1263 break;
1264 }
1265
1266 audio_codec_loaded = true;
1267 ci.stop_codec = false;
1268 status = codec_load_buf(CUR_TI->codec_hid, &ci);
1269 break;
1270
1271 #ifdef AUDIO_HAVE_RECORDING
1272 case Q_ENCODER_LOAD_DISK:
1273 LOGFQUEUE("codec < Q_ENCODER_LOAD_DISK");
1274 audio_codec_loaded = false; /* Not audio codec! */
1275 logf("loading encoder");
1276 ci.stop_encoder = false;
1277 status = codec_load_file((const char *)ev.data, &ci);
1278 logf("encoder stopped");
1279 break;
1280 #endif /* AUDIO_HAVE_RECORDING */
1281
1282 default:
1283 LOGFQUEUE("codec < default");
1284 }
1285
1286 if (audio_codec_loaded)
1287 {
1288 if (ci.stop_codec)
1289 {
1290 status = CODEC_OK;
1291 if (!playing)
1292 pcmbuf_play_stop();
1293
1294 }
1295 audio_codec_loaded = false;
1296 }
1297
1298 switch (ev.id) {
1299 case Q_CODEC_LOAD_DISK:
1300 case Q_CODEC_LOAD:
1301 LOGFQUEUE("codec < Q_CODEC_LOAD");
1302 if (playing)
1303 {
1304 if (ci.new_track || status != CODEC_OK)
1305 {
1306 if (!ci.new_track)
1307 {
1308 logf("Codec failure");
1309 gui_syncsplash(HZ*2, "Codec failure");
1310 }
1311
1312 if (!codec_load_next_track())
1313 {
1314 LOGFQUEUE("codec > audio Q_AUDIO_STOP");
1315 /* End of playlist */
1316 queue_post(&audio_queue, Q_AUDIO_STOP, 0);
1317 break;
1318 }
1319 }
1320 else
1321 {
1322 logf("Codec finished");
1323 if (ci.stop_codec)
1324 {
1325 /* Wait for the audio to stop playing before
1326 * triggering the WPS exit */
1327 while(pcm_is_playing())
1328 {
1329 curtrack_id3.elapsed =
1330 curtrack_id3.length - pcmbuf_get_latency();
1331 sleep(1);
1332 }
1333
1334 if (codec_requested_stop)
1335 {
1336 LOGFQUEUE("codec > audio Q_AUDIO_STOP");
1337 queue_post(&audio_queue, Q_AUDIO_STOP, 0);
1338 }
1339 break;
1340 }
1341 }
1342
1343 if (CUR_TI->codec_hid >= 0)
1344 {
1345 LOGFQUEUE("codec > codec Q_CODEC_LOAD");
1346 queue_post(&codec_queue, Q_CODEC_LOAD, 0);
1347 }
1348 else
1349 {
1350 const char *codec_fn =
1351 get_codec_filename(curtrack_id3.codectype);
1352 if (codec_fn)
1353 {
1354 LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK");
1355 queue_post(&codec_queue, Q_CODEC_LOAD_DISK,
1356 (intptr_t)codec_fn);
1357 }
1358 }
1359 }
1360 break;
1361
1362 #ifdef AUDIO_HAVE_RECORDING
1363 case Q_ENCODER_LOAD_DISK:
1364 LOGFQUEUE("codec < Q_ENCODER_LOAD_DISK");
1365
1366 if (status == CODEC_OK)
1367 break;
1368
1369 logf("Encoder failure");
1370 gui_syncsplash(HZ*2, "Encoder failure");
1371
1372 if (ci.enc_codec_loaded < 0)
1373 break;
1374
1375 logf("Encoder failed to load");
1376 ci.enc_codec_loaded = -1;
1377 break;
1378 #endif /* AUDIO_HAVE_RECORDING */
1379
1380 default:
1381 LOGFQUEUE("codec < default");
1382
1383 } /* end switch */
1384 }
1385 }
1386
1387
1388 /* --- Buffering callbacks --- */
1389
1390 static void buffering_low_buffer_callback(void *data)
1391 {
1392 (void)data;
1393 logf("low buffer callback");
1394
1395 if (filling == STATE_FULL) {
1396 /* force a refill */
1397 LOGFQUEUE("buffering > audio Q_AUDIO_FILL_BUFFER");
1398 queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, 0);
1399 }
1400 }
1401
1402 static void buffering_handle_rebuffer_callback(void *data)
1403 {
1404 (void)data;
1405 LOGFQUEUE("audio >| audio Q_AUDIO_FLUSH");
1406 queue_post(&audio_queue, Q_AUDIO_FLUSH, 0);
1407 }
1408
1409 static void buffering_handle_finished_callback(int *data)
1410 {
1411 logf("handle %d finished buffering", *data);
1412 strip_tags(*data);
1413 }
1414
1415
1416 /* --- Audio thread --- */
1417
1418 static bool audio_have_tracks(void)
1419 {
1420 return (audio_track_count() != 0);
1421 }
1422
1423 static int audio_free_track_count(void)
1424 {
1425 /* Used tracks + free tracks adds up to MAX_TRACK - 1 */
1426 return MAX_TRACK - 1 - audio_track_count();
1427 }
1428
1429 int audio_track_count(void)
1430 {
1431 /* Calculate difference from track_ridx to track_widx
1432 * taking into account a possible wrap-around. */
1433 return (MAX_TRACK + track_widx - track_ridx) & MAX_TRACK_MASK;
1434 }
1435
1436 long audio_filebufused(void)
1437 {
1438 return (long) buf_used();
1439 }
1440
1441 /* Update track info after successful a codec track change */
1442 static void audio_update_trackinfo(void)
1443 {
1444 /* Load the curent track's metadata into curtrack_id3 */
1445 CUR_TI->taginfo_ready = (CUR_TI->id3_hid >= 0);
1446 if (CUR_TI->id3_hid >= 0)
1447 copy_mp3entry(&curtrack_id3, bufgetid3(CUR_TI->id3_hid));
1448
1449 int next_idx = (track_ridx + 1) & MAX_TRACK_MASK;
1450 tracks[next_idx].taginfo_ready = (tracks[next_idx].id3_hid >= 0);
1451
1452 /* Reset current position */
1453 curtrack_id3.elapsed = 0;
1454 curtrack_id3.offset = 0;
1455
1456 /* Update the codec API */
1457 ci.filesize = CUR_TI->filesize;
1458 ci.id3 = &curtrack_id3;
1459 ci.curpos = 0;
1460 ci.taginfo_ready = &CUR_TI->taginfo_ready;
1461 }
1462
1463 /* Clear tracks between write and read, non inclusive */
1464 static void audio_clear_track_entries(void)
1465 {
1466 int cur_idx = track_widx;
1467
1468 logf("Clearing tracks:%d/%d", track_ridx, track_widx);
1469
1470 /* Loop over all tracks from write-to-read */
1471 while (1)
1472 {
1473 cur_idx = (cur_idx + 1) & MAX_TRACK_MASK;
1474
1475 if (cur_idx == track_ridx)
1476 break;
1477
1478 clear_track_info(&tracks[cur_idx]);
1479 }
1480 }
1481
1482 /* Clear all tracks */
1483 static bool audio_release_tracks(void)
1484 {
1485 int i, cur_idx;
1486
1487 logf("releasing all tracks");
1488
1489 for(i = 0; i < MAX_TRACK; i++)
1490 {
1491 cur_idx = (track_ridx + i) & MAX_TRACK_MASK;
1492 if (!clear_track_info(&tracks[cur_idx]))
1493 return false;
1494 }
1495
1496 return true;
1497 }
1498
1499 static bool audio_loadcodec(bool start_play)
1500 {
1501 int prev_track;
1502 char codec_path[MAX_PATH]; /* Full path to codec */
1503
1504 if (tracks[track_widx].id3_hid < 0) {
1505 return false;
1506 }
1507
1508 const char * codec_fn =
1509 get_codec_filename(bufgetid3(tracks[track_widx].id3_hid)->codectype);
1510 if (codec_fn == NULL)
1511 return false;
1512
1513 tracks[track_widx].codec_hid = -1;
1514
1515 if (start_play)
1516 {
1517 /* Load the codec directly from disk and save some memory. */
1518 track_ridx = track_widx;
1519 ci.filesize = CUR_TI->filesize;
1520 ci.id3 = &curtrack_id3;
1521 ci.taginfo_ready = &CUR_TI->taginfo_ready;
1522 ci.curpos = 0;
1523 LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK");
1524 queue_post(&codec_queue, Q_CODEC_LOAD_DISK, (intptr_t)codec_fn);
1525 return true;
1526 }
1527 else
1528 {
1529 /* If we already have another track than this one buffered */
1530 if (track_widx != track_ridx)
1531 {
1532 prev_track = (track_widx - 1) & MAX_TRACK_MASK;
1533
1534 /* If the previous codec is the same as this one, there is no need
1535 * to put another copy of it on the file buffer */
1536 if (get_codec_base_type(
1537 bufgetid3(tracks[track_widx].id3_hid)->codectype) ==
1538 get_codec_base_type(
1539 bufgetid3(tracks[prev_track].id3_hid)->codectype)
1540 && audio_codec_loaded)
1541 {
1542 logf("Reusing prev. codec");
1543 return true;
1544 }
1545 }
1546 }
1547
1548 codec_get_full_path(codec_path, codec_fn);
1549
1550 tracks[track_widx].codec_hid = bufopen(codec_path, 0, TYPE_CODEC);
1551 if (tracks[track_widx].codec_hid < 0)
1552 return false;
1553
1554 logf("Loaded codec");
1555
1556 return true;
1557 }
1558
1559 /* Load one track by making the appropriate bufopen calls. Return true if
1560 everything required was loaded correctly, false if not. */
1561 static bool audio_load_track(int offset, bool start_play)
1562 {
1563 const char *trackname;
1564 char msgbuf[80];
1565 int fd = -1;
1566 int file_offset = 0;
1567 struct mp3entry id3;
1568
1569 /* Stop buffer filling if there is no free track entries.
1570 Don't fill up the last track entry (we wan't to store next track
1571 metadata there). */
1572 if (!audio_free_track_count())
1573 {
1574 logf("No free tracks");
1575 return false;
1576 }
1577
1578 last_peek_offset++;
1579 tracks[track_widx].taginfo_ready = false;
1580
1581 peek_again:
1582 logf("Buffering track:%d/%d", track_widx, track_ridx);
1583 /* Get track name from current playlist read position. */
1584 while ((trackname = playlist_peek(last_peek_offset)) != NULL)
1585 {
1586 /* Handle broken playlists. */
1587 fd = open(trackname, O_RDONLY);
1588 if (fd < 0)
1589 {
1590 logf("Open failed");
1591 /* Skip invalid entry from playlist. */
1592 playlist_skip_entry(NULL, last_peek_offset);
1593 }
1594 else
1595 break;
1596 }
1597
1598 if (!trackname)
1599 {
1600 logf("End-of-playlist");
1601 playlist_end = true;
1602 memset(&lasttrack_id3, 0, sizeof(struct mp3entry));
1603 filling = STATE_FINISHED;
1604 return false;
1605 }
1606
1607 tracks[track_widx].filesize = filesize(fd);
1608
1609 if ((unsigned)offset > tracks[track_widx].filesize)
1610 offset = 0;
1611
1612 /* Set default values */
1613 if (start_play)
1614 {
1615 buf_set_watermark(AUDIO_DEFAULT_WATERMARK);
1616 dsp_configure(ci.dsp, DSP_RESET, 0);
1617 track_changed = true;
1618 playlist_update_resume_info(audio_current_track());
1619 }
1620
1621 /* Get track metadata if we don't already have it. */
1622 if (tracks[track_widx].id3_hid < 0)
1623 {
1624 if (get_metadata(&id3, fd, trackname))
1625 {
1626 id3.index = playlist_get_display_index() + last_peek_offset - 1;
1627
1628 send_event(PLAYBACK_EVENT_TRACK_BUFFER, &id3);
1629
1630 tracks[track_widx].id3_hid =
1631 bufalloc(&id3, sizeof(struct mp3entry), TYPE_ID3);
1632
1633 if (tracks[track_widx].id3_hid < 0)
1634 {
1635 last_peek_offset--;
1636 close(fd);
1637 copy_mp3entry(&lasttrack_id3, &id3);
1638 goto buffer_full;
1639 }
1640
1641 if (track_widx == track_ridx)
1642 copy_mp3entry(&curtrack_id3, &id3);
1643
1644 if (start_play)
1645 {
1646 track_changed = true;
1647 playlist_update_resume_info(audio_current_track());
1648 }
1649 }
1650 else
1651 {
1652 logf("mde:%s!",trackname);
1653
1654 /* Skip invalid entry from playlist. */
1655 playlist_skip_entry(NULL, last_peek_offset);
1656 close(fd);
1657 goto peek_again;
1658 }
1659
1660 }
1661
1662 close(fd);
1663
1664 #if 0
1665 if (cuesheet_is_enabled() && tracks[track_widx].id3.cuesheet_type == 1)
1666 {
1667 char cuepath[MAX_PATH];
1668
1669 struct cuesheet *cue = start_play ? curr_cue : temp_cue;
1670
1671 if (look_for_cuesheet_file(trackname, cuepath) &&
1672 parse_cuesheet(cuepath, cue))
1673 {
1674 strcpy((cue)->audio_filename, trackname);
1675 if (start_play)
1676 cue_spoof_id3(curr_cue, &tracks[track_widx].id3);
1677 }
1678 }
1679 #endif
1680
1681 struct mp3entry *track_id3;
1682
1683 if (track_widx == track_ridx)
1684 track_id3 = &curtrack_id3;
1685 else
1686 track_id3 = bufgetid3(tracks[track_widx].id3_hid);
1687
1688 #ifdef HAVE_ALBUMART
1689 if (tracks[track_widx].aa_hid < 0 && gui_sync_wps_uses_albumart())
1690 {
1691 char aa_path[MAX_PATH];
1692 if (find_albumart(track_id3, aa_path, sizeof(aa_path)))
1693 tracks[track_widx].aa_hid = bufopen(aa_path, 0, TYPE_BITMAP);
1694 }
1695 #endif
1696
1697 /* Load the codec. */
1698 if (!audio_loadcodec(start_play))
1699 {
1700 if (tracks[track_widx].codec_hid == ERR_BUFFER_FULL)
1701 {
1702 /* No space for codec on buffer, not an error */
1703 goto buffer_full;
1704 }
1705
1706 /* This is an error condition, either no codec was found, or reading
1707 * the codec file failed part way through, either way, skip the track */
1708 snprintf(msgbuf, sizeof(msgbuf)-1, "No codec for: %s", trackname);
1709 /* We should not use gui_syncplash from audio thread! */
1710 gui_syncsplash(HZ*2, msgbuf);
1711 /* Skip invalid entry from playlist. */
1712 playlist_skip_entry(NULL, last_peek_offset);
1713 goto peek_again;
1714 }
1715
1716 track_id3->elapsed = 0;
1717
1718 enum data_type type = TYPE_PACKET_AUDIO;
1719
1720 switch (track_id3->codectype) {
1721 case AFMT_MPA_L1:
1722 case AFMT_MPA_L2:
1723 case AFMT_MPA_L3:
1724 if (offset > 0) {
1725 file_offset = offset;
1726 track_id3->offset = offset;
1727 }
1728 break;
1729
1730 case AFMT_WAVPACK:
1731 if (offset > 0) {
1732 file_offset = offset;
1733 track_id3->offset = offset;
1734 track_id3->elapsed = track_id3->length / 2;
1735 }
1736 break;
1737
1738 case AFMT_OGG_VORBIS:
1739 case AFMT_SPEEX:
1740 case AFMT_FLAC:
1741 case AFMT_PCM_WAV:
1742 case AFMT_A52:
1743 case AFMT_AAC:
1744 case AFMT_MPC:
1745 case AFMT_APE:
1746 if (offset > 0)
1747 track_id3->offset = offset;
1748 break;
1749
1750 case AFMT_NSF:
1751 case AFMT_SPC:
1752 case AFMT_SID:
1753 logf("Loading atomic %d",track_id3->codectype);
1754 type = TYPE_ATOMIC_AUDIO;
1755 break;
1756 }
1757
1758 logf("alt:%s", trackname);
1759
1760 if (file_offset > AUDIO_REBUFFER_GUESS_SIZE)
1761 file_offset -= AUDIO_REBUFFER_GUESS_SIZE;
1762 else if (track_id3->first_frame_offset)
1763 file_offset = track_id3->first_frame_offset;
1764 else
1765 file_offset = 0;
1766
1767 tracks[track_widx].audio_hid = bufopen(trackname, file_offset, type);
1768
1769 if (tracks[track_widx].audio_hid < 0)
1770 goto buffer_full;
1771
1772 /* All required data is now available for the codec. */
1773 tracks[track_widx].taginfo_ready = true;
1774
1775 if (start_play)
1776 {
1777 ci.curpos=file_offset;
1778 buf_request_buffer_handle(tracks[track_widx].audio_hid);
1779 }
1780
1781 track_widx = (track_widx + 1) & MAX_TRACK_MASK;
1782
1783 return true;
1784
1785 buffer_full:
1786 logf("buffer is full for now");
1787 filling = STATE_FULL;
1788 return false;
1789 }
1790
1791 static void audio_fill_file_buffer(bool start_play, size_t offset)
1792 {
1793 bool had_next_track = audio_next_track() != NULL;
1794 bool continue_buffering;
1795
1796 filling = STATE_FILLING;
1797 trigger_cpu_boost();
1798
1799 /* No need to rebuffer if there are track skips pending. */
1800 if (ci.new_track != 0)
1801 return;
1802
1803 /* Must reset the buffer before use if trashed or voice only - voice
1804 file size shouldn't have changed so we can go straight from
1805 BUFFER_STATE_VOICED_ONLY to BUFFER_STATE_INITIALIZED */
1806 if (buffer_state != BUFFER_STATE_INITIALIZED)
1807 audio_reset_buffer();
1808
1809 logf("Starting buffer fill");
1810
1811 if (!start_play)
1812 audio_clear_track_entries();
1813
1814 /* Save the current resume position once. */
1815 playlist_update_resume_info(audio_current_track());
1816
1817 continue_buffering = audio_load_track(offset, start_play);
1818 do {
1819 sleep(1);
1820 if (!queue_empty(&audio_queue))
1821 /* There's a message in the queue. break the loop to treat it */
1822 break;
1823 continue_buffering = audio_load_track(0, false);
1824 } while (continue_buffering);
1825
1826 if (!had_next_track && audio_next_track())
1827 track_changed = true;
1828
1829 }
1830
1831 static void audio_rebuffer(void)
1832 {
1833 logf("Forcing rebuffer");
1834
1835 clear_track_info(CUR_TI);
1836
1837 /* Reset track pointers */
1838 track_widx = track_ridx;
1839 audio_clear_track_entries();
1840
1841 /* Fill the buffer */
1842 last_peek_offset = -1;
1843 ci.curpos = 0;
1844
1845 if (!CUR_TI->taginfo_ready)
1846 memset(&curtrack_id3, 0, sizeof(struct mp3entry));
1847
1848 audio_fill_file_buffer(false, 0);
1849 }
1850
1851 /* Called on request from the codec to get a new track. This is the codec part
1852 of the track transition. */
1853 static int audio_check_new_track(void)
1854 {
1855 int track_count = audio_track_count();
1856 int old_track_ridx = track_ridx;
1857 int i, idx;
1858 bool forward;
1859
1860 /* Now it's good time to send track finish events. */
1861 send_event(PLAYBACK_EVENT_TRACK_FINISH, &curtrack_id3);
1862 if (dir_skip)
1863 {
1864 dir_skip = false;
1865 if (playlist_next_dir(ci.new_track))
1866 {
1867 ci.new_track = 0;
1868 audio_rebuffer();
1869 goto skip_done;
1870 }
1871 else
1872 {
1873 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1874 return Q_CODEC_REQUEST_FAILED;
1875 }
1876 }
1877
1878 if (new_playlist)
1879 ci.new_track = 0;
1880
1881 /* If the playlist isn't that big */
1882 if (automatic_skip)
1883 {
1884 while (!playlist_check(ci.new_track))
1885 {
1886 if (ci.new_track >= 0)
1887 {
1888 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1889 return Q_CODEC_REQUEST_FAILED;
1890 }
1891 ci.new_track++;
1892 }
1893 }
1894
1895 /* Update the playlist */
1896 last_peek_offset -= ci.new_track;
1897
1898 if (playlist_next(ci.new_track) < 0)
1899 {
1900 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1901 return Q_CODEC_REQUEST_FAILED;
1902 }
1903
1904 if (new_playlist)
1905 {
1906 ci.new_track = 1;
1907 new_playlist = false;
1908 }
1909
1910 /* Save the track metadata to allow the WPS to display it
1911 while PCM finishes playing that track */
1912 copy_mp3entry(&prevtrack_id3, &curtrack_id3);
1913
1914 /* Update the main buffer copy of the track metadata with the one
1915 the codec has been using (for the unbuffer callbacks) */
1916 if (CUR_TI->id3_hid >= 0)
1917 copy_mp3entry(bufgetid3(CUR_TI->id3_hid), &curtrack_id3);
1918
1919 /* Save a pointer to the old track to allow later clearing */
1920 prev_ti = CUR_TI;
1921
1922 for (i = 0; i < ci.new_track; i++)
1923 {
1924 idx = (track_ridx + i) & MAX_TRACK_MASK;
1925 struct mp3entry *id3 = bufgetid3(tracks[idx].id3_hid);
1926 ssize_t offset = buf_handle_offset(tracks[idx].audio_hid);
1927 if (!id3 || offset < 0 || (unsigned)offset > id3->first_frame_offset)
1928 {
1929 /* We don't have all the audio data for that track, so clear it,
1930 but keep the metadata. */
1931 if (tracks[idx].audio_hid >= 0 && bufclose(tracks[idx].audio_hid))
1932 {
1933 tracks[idx].audio_hid = -1;
1934 tracks[idx].filesize = 0;
1935 }
1936 }
1937 }
1938
1939 /* Move to the new track */
1940 track_ridx = (track_ridx + ci.new_track) & MAX_TRACK_MASK;
1941
1942 buf_set_base_handle(CUR_TI->audio_hid);
1943
1944 if (automatic_skip)
1945 {
1946 playlist_end = false;
1947 wps_offset = -ci.new_track;
1948 track_changed = true;
1949 }
1950
1951 /* If it is not safe to even skip this many track entries */
1952 if (ci.new_track >= track_count || ci.new_track <= track_count - MAX_TRACK)
1953 {
1954 ci.new_track = 0;
1955 audio_rebuffer();
1956 goto skip_done;
1957 }
1958
1959 forward = ci.new_track > 0;
1960 ci.new_track = 0;
1961
1962 /* If the target track is clearly not in memory */
1963 if (CUR_TI->filesize == 0 || !CUR_TI->taginfo_ready)
1964 {
1965 audio_rebuffer();
1966 goto skip_done;
1967 }
1968
1969 /* When skipping backwards, it is possible that we've found a track that's
1970 * buffered, but which is around the track-wrap and therefore not the track
1971 * we are looking for */
1972 if (!forward)
1973 {
1974 int cur_idx = track_ridx;
1975 bool taginfo_ready = true;
1976 /* We've wrapped the buffer backwards if new > old */
1977 bool wrap = track_ridx > old_track_ridx;
1978
1979 while (1)
1980 {
1981 cur_idx = (cur_idx + 1) & MAX_TRACK_MASK;
1982
1983 /* if we've advanced past the wrap when cur_idx is zeroed */
1984 if (!cur_idx)
1985 wrap = false;
1986
1987 /* if we aren't still on the wrap and we've caught the old track */
1988 if (!(wrap || cur_idx < old_track_ridx))
1989 break;
1990
1991 /* If we hit a track in between without valid tag info, bail */
1992 if (!tracks[cur_idx].taginfo_ready)
1993 {
1994 taginfo_ready = false;
1995 break;
1996 }
1997 }
1998 if (!taginfo_ready)
1999 {
2000 audio_rebuffer();
2001 }
2002 }
2003
2004 skip_done:
2005 audio_update_trackinfo();
2006 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_COMPLETE");
2007 return Q_CODEC_REQUEST_COMPLETE;
2008 }
2009
2010 unsigned long audio_prev_elapsed(void)
2011 {
2012 return prev_track_elapsed;
2013 }
2014
2015 static void audio_stop_codec_flush(void)
2016 {
2017 ci.stop_codec = true;
2018 pcmbuf_pause(true);
2019
2020 while (audio_codec_loaded)
2021 yield();
2022
2023 /* If the audio codec is not loaded any more, and the audio is still
2024 * playing, it is now and _only_ now safe to call this function from the
2025 * audio thread */
2026 if (pcm_is_playing())
2027 {
2028 pcmbuf_play_stop();
2029 pcmbuf_queue_clear();
2030 }
2031 pcmbuf_pause(paused);
2032 }
2033
2034 static void audio_stop_playback(void)
2035 {
2036 /* If we were playing, save resume information */
2037 if (playing)
2038 {
2039 struct mp3entry *id3 = NULL;
2040
2041 if (!playlist_end || !ci.stop_codec)
2042 {
2043 /* Set this early, the outside code yields and may allow the codec
2044 to try to wait for a reply on a buffer wait */
2045 ci.stop_codec = true;
2046 id3 = audio_current_track();
2047 }
2048
2049 /* Save the current playing spot, or NULL if the playlist has ended */
2050 playlist_update_resume_info(id3);
2051
2052 /* TODO: Create auto bookmark too? */
2053
2054 prev_track_elapsed = curtrack_id3.elapsed;
2055
2056 remove_event(EVENT_BUFFER_LOW, buffering_low_buffer_callback);
2057 }
2058
2059 paused = false;
2060 audio_stop_codec_flush();
2061 playing = false;
2062
2063 filling = STATE_IDLE;
2064
2065 /* Mark all entries null. */
2066 audio_clear_track_entries();
2067
2068 /* Close all tracks */
2069 audio_release_tracks();
2070
2071 memset(&curtrack_id3, 0, sizeof(struct mp3entry));
2072 }
2073
2074 static void audio_play_start(size_t offset)
2075 {
2076 int i;
2077
2078 #if INPUT_SRC_CAPS != 0
2079 audio_set_input_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK);
2080 audio_set_output_source(AUDIO_SRC_PLAYBACK);
2081 #endif
2082
2083 /* Wait for any previously playing audio to flush - TODO: Not necessary? */
2084 paused = false;
2085 audio_stop_codec_flush();
2086
2087 track_changed = true;
2088 playlist_end = false;
2089
2090 playing = true;
2091
2092 ci.new_track = 0;
2093 ci.seek_time = 0;
2094 wps_offset = 0;
2095
2096 sound_set_volume(global_settings.volume);
2097 track_widx = track_ridx = 0;
2098
2099 /* Clear all track entries. */
2100 for (i = 0; i < MAX_TRACK; i++) {
2101 clear_track_info(&tracks[i]);
2102 }
2103
2104 last_peek_offset = -1;
2105
2106 /* Officially playing */
2107 queue_reply(&audio_queue, 1);
2108
2109 #ifndef HAVE_FLASH_STORAGE
2110 set_filebuf_watermark(buffer_margin, 0);
2111 #endif
2112
2113 audio_fill_file_buffer(true, offset);
2114
2115 add_event(EVENT_BUFFER_LOW, false, buffering_low_buffer_callback);
2116
2117 LOGFQUEUE("audio > audio Q_AUDIO_TRACK_CHANGED");
2118 queue_post(&audio_queue, Q_AUDIO_TRACK_CHANGED, 0);
2119 }
2120
2121
2122 /* Invalidates all but currently playing track. */
2123 static void audio_invalidate_tracks(void)
2124 {
2125 if (audio_have_tracks())
2126 {
2127 last_peek_offset = 0;
2128 playlist_end = false;
2129 track_widx = track_ridx;
2130
2131 /* Mark all other entries null (also buffered wrong metadata). */
2132 audio_clear_track_entries();
2133
2134 track_widx = (track_widx + 1) & MAX_TRACK_MASK;
2135
2136 audio_fill_file_buffer(false, 0);
2137 }
2138 }
2139
2140 static void audio_new_playlist(void)
2141 {
2142 /* Prepare to start a new fill from the beginning of the playlist */
2143 last_peek_offset = -1;
2144 if (audio_have_tracks())
2145 {
2146 if (paused)
2147 skipped_during_pause = true;
2148 playlist_end = false;
2149 track_widx = track_ridx;
2150 audio_clear_track_entries();
2151
2152 track_widx = (track_widx + 1) & MAX_TRACK_MASK;
2153
2154 /* Mark the current track as invalid to prevent skipping back to it */
2155 CUR_TI->taginfo_ready = false;
2156 }
2157
2158 /* Signal the codec to initiate a track change forward */
2159 new_playlist = true;
2160 ci.new_track = 1;
2161
2162 /* Officially playing */
2163 queue_reply(&audio_queue, 1);
2164
2165 audio_fill_file_buffer(false, 0);
2166 }
2167
2168 /* Called on manual track skip */
2169 static void audio_initiate_track_change(long direction)
2170 {
2171 logf("audio_initiate_track_change(%ld)", direction);
2172
2173 playlist_end = false;
2174 ci.new_track += direction;
2175 wps_offset -= direction;
2176 if (paused)
2177 skipped_during_pause = true;
2178 }
2179
2180 /* Called on manual dir skip */
2181 static void audio_initiate_dir_change(long direction)
2182 {
2183 playlist_end = false;
2184 dir_skip = true;
2185 ci.new_track = direction;
2186 if (paused)
2187 skipped_during_pause = true;
2188 }
2189
2190 /* Called when PCM track change is complete */
2191 static void audio_finalise_track_change(void)
2192 {
2193 logf("audio_finalise_track_change");
2194
2195 if (automatic_skip)
2196 {
2197 wps_offset = 0;
2198 automatic_skip = false;
2199 }
2200
2201 /* Invalidate prevtrack_id3 */
2202 prevtrack_id3.path[0] = 0;
2203
2204 if (prev_ti && prev_ti->audio_hid < 0)
2205 {
2206 /* No audio left so we clear all the track info. */
2207 clear_track_info(prev_ti);
2208 }
2209
2210 if (prev_ti && prev_ti->id3_hid >= 0)
2211 {
2212 /* Reset the elapsed time to force the progressbar to be empty if
2213 the user skips back to this track */
2214 bufgetid3(prev_ti->id3_hid)->elapsed = 0;
2215 }
2216
2217 send_event(PLAYBACK_EVENT_TRACK_CHANGE, &curtrack_id3);
2218
2219 track_changed = true;
2220 playlist_update_resume_info(audio_current_track());
2221 }
2222
2223 /*
2224 * Layout audio buffer as follows - iram buffer depends on target:
2225 * [|SWAP:iram][|TALK]|MALLOC|FILE|GUARD|PCM|[SWAP:dram[|iram]|]
2226 */
2227 static void audio_reset_buffer(void)
2228 {
2229 /* see audio_get_recording_buffer if this is modified */
2230 logf("audio_reset_buffer");
2231
2232 /* If the setup of anything allocated before the file buffer is
2233 changed, do check the adjustments after the buffer_alloc call
2234 as it will likely be affected and need sliding over */
2235
2236 /* Initially set up file buffer as all space available */
2237 malloc_buf = audiobuf + talk_get_bufsize();
2238 /* Align the malloc buf to line size. Especially important to cf
2239 targets that do line reads/writes. */
2240 malloc_buf = (unsigned char *)(((uintptr_t)malloc_buf + 15) & ~15);
2241 filebuf = malloc_buf + MALLOC_BUFSIZE; /* filebuf line align implied */
2242 filebuflen = audiobufend - filebuf;
2243
2244 filebuflen &= ~15;
2245
2246 /* Subtract whatever the pcm buffer says it used plus the guard buffer */
2247 filebuflen -= pcmbuf_init(filebuf + filebuflen) + GUARD_BUFSIZE;
2248
2249 /* Make sure filebuflen is a longword multiple after adjustment - filebuf
2250 will already be line aligned */
2251 filebuflen &= ~3;
2252
2253 buffering_reset(filebuf, filebuflen);
2254
2255 /* Clear any references to the file buffer */
2256 buffer_state = BUFFER_STATE_INITIALIZED;
2257
2258 #if defined(ROCKBOX_HAS_LOGF) && defined(LOGF_ENABLE)
2259 /* Make sure everything adds up - yes, some info is a bit redundant but
2260 aids viewing and the sumation of certain variables should add up to
2261 the location of others. */
2262 {
2263 size_t pcmbufsize;
2264 const unsigned char *pcmbuf = pcmbuf_get_meminfo(&pcmbufsize);
2265 logf("mabuf: %08X", (unsigned)malloc_buf);
2266 logf("mabufe: %08X", (unsigned)(malloc_buf + MALLOC_BUFSIZE));
2267 logf("fbuf: %08X", (unsigned)filebuf);
2268 logf("fbufe: %08X", (unsigned)(filebuf + filebuflen));
2269 logf("gbuf: %08X", (unsigned)(filebuf + filebuflen));
2270 logf("gbufe: %08X", (unsigned)(filebuf + filebuflen + GUARD_BUFSIZE));
2271 logf("pcmb: %08X", (unsigned)pcmbuf);
2272 logf("pcmbe: %08X", (unsigned)(pcmbuf + pcmbufsize));
2273 }
2274 #endif
2275 }
2276
2277 static void audio_thread(void)
2278 {
2279 struct queue_event ev;
2280
2281 pcm_postinit();
2282
2283 audio_thread_ready = true;
2284
2285 while (1)
2286 {
2287 if (filling != STATE_FILLING) {
2288 cancel_cpu_boost();
2289 }
2290
2291 if (!pcmbuf_queue_scan(&ev))
2292 queue_wait_w_tmo(&audio_queue, &ev, HZ/2);
2293
2294 switch (ev.id) {
2295
2296 case Q_AUDIO_FILL_BUFFER:
2297 LOGFQUEUE("audio < Q_AUDIO_FILL_BUFFER");
2298 audio_fill_file_buffer(false, 0);
2299 break;
2300
2301 case Q_AUDIO_PLAY:
2302 LOGFQUEUE("audio < Q_AUDIO_PLAY");
2303 if (playing && ev.data <= 0)
2304 audio_new_playlist();
2305 else
2306 {
2307 audio_stop_playback();
2308 audio_play_start((size_t)ev.data);
2309 }
2310 break;
2311
2312 case Q_AUDIO_STOP:
2313 LOGFQUEUE("audio < Q_AUDIO_STOP");
2314 if (playing)
2315 audio_stop_playback();
2316 if (ev.data != 0)
2317 queue_clear(&audio_queue);
2318 break;
2319
2320 case Q_AUDIO_PAUSE:
2321 LOGFQUEUE("audio < Q_AUDIO_PAUSE");
2322 if (!(bool) ev.data && skipped_during_pause && !pcmbuf_is_crossfade_active())
2323 pcmbuf_play_stop(); /* Flush old track on resume after skip */
2324 skipped_during_pause = false;
2325 if (!playing)
2326 break;
2327 pcmbuf_pause((bool)ev.data);
2328 paused = (bool)ev.data;
2329 break;
2330
2331 case Q_AUDIO_SKIP:
2332 LOGFQUEUE("audio < Q_AUDIO_SKIP");
2333 audio_initiate_track_change((long)ev.data);
2334 break;
2335
2336 case Q_AUDIO_PRE_FF_REWIND:
2337 LOGFQUEUE("audio < Q_AUDIO_PRE_FF_REWIND");
2338 if (!playing)
2339 break;
2340 pcmbuf_pause(true);
2341 break;
2342
2343 case Q_AUDIO_FF_REWIND:
2344 LOGFQUEUE("audio < Q_AUDIO_FF_REWIND");
2345 if (!playing)
2346 break;
2347 if (automatic_skip)
2348 {
2349 /* An automatic track skip is in progress. Finalize it,
2350 then go back to the previous track */
2351 audio_finalise_track_change();
2352 ci.new_track = -1;
2353 }
2354 ci.seek_time = (long)ev.data+1;
2355 break;
2356
2357 case Q_AUDIO_CHECK_NEW_TRACK:
2358 LOGFQUEUE("audio < Q_AUDIO_CHECK_NEW_TRACK");
2359 queue_reply(&audio_queue, audio_check_new_track());
2360 break;
2361
2362 case Q_AUDIO_DIR_SKIP:
2363 LOGFQUEUE("audio < Q_AUDIO_DIR_SKIP");
2364 playlist_end = false;
2365 audio_initiate_dir_change(ev.data);
2366 break;
2367
2368 case Q_AUDIO_FLUSH:
2369 LOGFQUEUE("audio < Q_AUDIO_FLUSH");
2370 audio_invalidate_tracks();
2371 break;
2372
2373 case Q_AUDIO_TRACK_CHANGED:
2374 /* PCM track change done */
2375 LOGFQUEUE("audio < Q_AUDIO_TRACK_CHANGED");
2376 audio_finalise_track_change();
2377 break;
2378
2379 #ifndef SIMULATOR
2380 case SYS_USB_CONNECTED:
2381 LOGFQUEUE("audio < SYS_USB_CONNECTED");
2382 if (playing)
2383 audio_stop_playback();
2384 #ifdef PLAYBACK_VOICE
2385 voice_stop();
2386 #endif
2387 usb_acknowledge(SYS_USB_CONNECTED_ACK);
2388 usb_wait_for_disconnect(&audio_queue);
2389
2390 /* Mark all entries null. */
2391 audio_clear_track_entries();
2392
2393 /* release tracks to make sure all handles are closed */
2394 audio_release_tracks();
2395 break;
2396 #endif
2397
2398 case SYS_TIMEOUT:
2399 LOGFQUEUE_SYS_TIMEOUT("audio < SYS_TIMEOUT");
2400 if (filling == STATE_FILLING)
2401 audio_fill_file_buffer(false, 0);
2402 break;
2403
2404 default:
2405 LOGFQUEUE("audio < default");
2406 break;
2407 } /* end switch */
2408 } /* end while */
2409 }
2410
2411 /* Initialize the audio system - called from init() in main.c.
2412 * Last function because of all the references to internal symbols
2413 */
2414 void audio_init(void)
2415 {
2416 struct thread_entry *audio_thread_p;
2417
2418 /* Can never do this twice */
2419 if (audio_is_initialized)
2420 {
2421 logf("audio: already initialized");
2422 return;
2423 }
2424
2425 logf("audio: initializing");
2426
2427 /* Initialize queues before giving control elsewhere in case it likes
2428 to send messages. Thread creation will be delayed however so nothing
2429 starts running until ready if something yields such as talk_init. */
2430 queue_init(&audio_queue, true);
2431 queue_init(&codec_queue, false);
2432 queue_init(&pcmbuf_queue, false);
2433
2434 pcm_init();
2435
2436 /* Initialize codec api. */
2437 ci.read_filebuf = codec_filebuf_callback;
2438 ci.pcmbuf_insert = codec_pcmbuf_insert_callback;
2439 ci.get_codec_memory = codec_get_memory_callback;
2440 ci.request_buffer = codec_request_buffer_callback;
2441 ci.advance_buffer = codec_advance_buffer_callback;
2442 ci.advance_buffer_loc = codec_advance_buffer_loc_callback;
2443 ci.request_next_track = codec_request_next_track_callback;
2444 ci.seek_buffer = codec_seek_buffer_callback;
2445 ci.seek_complete = codec_seek_complete_callback;
2446 ci.set_elapsed = codec_set_elapsed_callback;
2447 ci.set_offset = codec_set_offset_callback;
2448 ci.configure = codec_configure_callback;
2449 ci.discard_codec = codec_discard_codec_callback;
2450 ci.dsp = (struct dsp_config *)dsp_configure(NULL, DSP_MYDSP,
2451 CODEC_IDX_AUDIO);
2452
2453 /* initialize the buffer */
2454 filebuf = audiobuf;
2455
2456 /* audio_reset_buffer must to know the size of voice buffer so init
2457 talk first */
2458 talk_init();
2459
2460 codec_thread_p = create_thread(
2461 codec_thread, codec_stack, sizeof(codec_stack),
2462 CREATE_THREAD_FROZEN,
2463 codec_thread_name IF_PRIO(, PRIORITY_PLAYBACK)
2464 IF_COP(, CPU));
2465
2466 queue_enable_queue_send(&codec_queue, &codec_queue_sender_list,
2467 codec_thread_p);
2468
2469 audio_thread_p = create_thread(audio_thread, audio_stack,
2470 sizeof(audio_stack), CREATE_THREAD_FROZEN,
2471 audio_thread_name IF_PRIO(, PRIORITY_USER_INTERFACE)
2472 IF_COP(, CPU));
2473
2474 queue_enable_queue_send(&audio_queue, &audio_queue_sender_list,
2475 audio_thread_p);
2476
2477 #ifdef PLAYBACK_VOICE
2478 voice_thread_init();
2479 #endif
2480
2481 /* Set crossfade setting for next buffer init which should be about... */
2482 pcmbuf_crossfade_enable(global_settings.crossfade);
2483
2484 /* initialize the buffering system */
2485
2486 buffering_init();
2487 /* ...now! Set up the buffers */
2488 audio_reset_buffer();
2489
2490 int i;
2491 for(i = 0; i < MAX_TRACK; i++)
2492 {
2493 tracks[i].audio_hid = -1;
2494 tracks[i].id3_hid = -1;
2495 tracks[i].codec_hid = -1;
2496 #ifdef HAVE_ALBUMART
2497 tracks[i].aa_hid = -1;
2498 #endif
2499 }
2500
2501 add_event(EVENT_HANDLE_REBUFFER, false, buffering_handle_rebuffer_callback);
2502 add_event(EVENT_HANDLE_FINISHED, false, buffering_handle_finished_callback);
2503
2504 /* Probably safe to say */
2505 audio_is_initialized = true;
2506
2507 sound_settings_apply();
2508 #ifndef HAVE_FLASH_STORAGE
2509 audio_set_buffer_margin(global_settings.buffer_margin);
2510 #endif
2511
2512 /* it's safe to let the threads run now */
2513 #ifdef PLAYBACK_VOICE
2514 voice_thread_resume();
2515 #endif
2516 thread_thaw(codec_thread_p);
2517 thread_thaw(audio_thread_p);
2518
2519 } /* audio_init */
2520
2521 void audio_wait_for_init(void)
2522 {
2523 /* audio thread will only set this once after it finished the final
2524 * audio hardware init so this little construct is safe - even
2525 * cross-core. */
2526 while (!audio_thread_ready)
2527 {
2528 sleep(0);
2529 }
2530 }
Open Source Jukebox Firmware