flac: remove ARM assembly
[kugel-rb.git] / apps / playback.c
blobebe4932ae005c87d9e75b5d0603859d0fd15aa10
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
10 * Copyright (C) 2005-2007 Miika Pekkarinen
11 * Copyright (C) 2007-2008 Nicolas Pennequin
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License
15 * as published by the Free Software Foundation; either version 2
16 * of the License, or (at your option) any later version.
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
21 ****************************************************************************/
23 /* TODO: Pause should be handled in here, rather than PCMBUF so that voice can
24 * play whilst audio is paused */
26 #include <string.h>
27 #include "playback.h"
28 #include "codec_thread.h"
29 #include "kernel.h"
30 #include "codecs.h"
31 #include "buffering.h"
32 #include "voice_thread.h"
33 #include "usb.h"
34 #include "ata.h"
35 #include "playlist.h"
36 #include "pcmbuf.h"
37 #include "buffer.h"
38 #include "cuesheet.h"
39 #ifdef HAVE_TAGCACHE
40 #include "tagcache.h"
41 #endif
42 #ifdef HAVE_LCD_BITMAP
43 #ifdef HAVE_ALBUMART
44 #include "albumart.h"
45 #endif
46 #endif
47 #include "sound.h"
48 #include "metadata.h"
49 #include "splash.h"
50 #include "talk.h"
52 #ifdef HAVE_RECORDING
53 #include "pcm_record.h"
54 #endif
56 #define PLAYBACK_VOICE
58 /* amount of guess-space to allow for codecs that must hunt and peck
59 * for their correct seeek target, 32k seems a good size */
60 #define AUDIO_REBUFFER_GUESS_SIZE (1024*32)
62 /* Define LOGF_ENABLE to enable logf output in this file */
63 /*#define LOGF_ENABLE*/
64 #include "logf.h"
66 /* macros to enable logf for queues
67 logging on SYS_TIMEOUT can be disabled */
68 #ifdef SIMULATOR
69 /* Define this for logf output of all queuing except SYS_TIMEOUT */
70 #define PLAYBACK_LOGQUEUES
71 /* Define this to logf SYS_TIMEOUT messages */
72 /*#define PLAYBACK_LOGQUEUES_SYS_TIMEOUT*/
73 #endif
75 #ifdef PLAYBACK_LOGQUEUES
76 #define LOGFQUEUE logf
77 #else
78 #define LOGFQUEUE(...)
79 #endif
81 #ifdef PLAYBACK_LOGQUEUES_SYS_TIMEOUT
82 #define LOGFQUEUE_SYS_TIMEOUT logf
83 #else
84 #define LOGFQUEUE_SYS_TIMEOUT(...)
85 #endif
88 static enum filling_state {
89 STATE_IDLE, /* audio is stopped: nothing to do */
90 STATE_FILLING, /* adding tracks to the buffer */
91 STATE_FULL, /* can't add any more tracks */
92 STATE_END_OF_PLAYLIST, /* all remaining tracks have been added */
93 STATE_FINISHED, /* all remaining tracks are fully buffered */
94 } filling;
96 /* As defined in plugins/lib/xxx2wav.h */
97 #define GUARD_BUFSIZE (32*1024)
99 bool audio_is_initialized = false;
100 static bool audio_thread_ready SHAREDBSS_ATTR = false;
102 /* Variables are commented with the threads that use them: *
103 * A=audio, C=codec, V=voice. A suffix of - indicates that *
104 * the variable is read but not updated on that thread. */
105 /* TBD: Split out "audio" and "playback" (ie. calling) threads */
107 /* Main state control */
108 static volatile bool playing SHAREDBSS_ATTR = false;/* Is audio playing? (A) */
109 static volatile bool paused SHAREDBSS_ATTR = false; /* Is audio paused? (A/C-) */
110 extern volatile bool audio_codec_loaded; /* Codec loaded? (C/A-) */
112 /* Ring buffer where compressed audio and codecs are loaded */
113 static unsigned char *filebuf = NULL; /* Start of buffer (A/C-) */
114 static unsigned char *malloc_buf = NULL; /* Start of malloc buffer (A/C-) */
115 static size_t filebuflen = 0; /* Size of buffer (A/C-) */
116 /* FIXME: make buf_ridx (C/A-) */
118 /* Possible arrangements of the buffer */
119 enum audio_buffer_state
121 AUDIOBUF_STATE_TRASHED = -1, /* trashed; must be reset */
122 AUDIOBUF_STATE_INITIALIZED = 0, /* voice+audio OR audio-only */
123 AUDIOBUF_STATE_VOICED_ONLY = 1, /* voice-only */
125 static int buffer_state = AUDIOBUF_STATE_TRASHED; /* Buffer state */
127 /* These are used to store the current and next (or prev if the current is the last)
128 * mp3entry's in a round-robin system. This guarentees that the pointer returned
129 * by audio_current/next_track will be valid for the full duration of the
130 * currently playing track */
131 static struct mp3entry mp3entry_buf[2];
132 struct mp3entry *thistrack_id3, /* the currently playing track */
133 *othertrack_id3; /* prev track during track-change-transition, or end of playlist,
134 * next track otherwise */
135 static struct mp3entry unbuffered_id3; /* the id3 for the first unbuffered track */
137 /* for cuesheet support */
138 static struct cuesheet *curr_cue = NULL;
141 #define MAX_MULTIPLE_AA 2
143 #ifdef HAVE_ALBUMART
144 static struct albumart_slot {
145 struct dim dim; /* holds width, height of the albumart */
146 int used; /* counter, increments if something uses it */
147 } albumart_slots[MAX_MULTIPLE_AA];
149 #define FOREACH_ALBUMART(i) for(i = 0;i < MAX_MULTIPLE_AA; i++)
150 #endif
153 #define MAX_TRACK 128
154 #define MAX_TRACK_MASK (MAX_TRACK-1)
156 /* Track info structure about songs in the file buffer (A/C-) */
157 static struct track_info {
158 int audio_hid; /* The ID for the track's buffer handle */
159 int id3_hid; /* The ID for the track's metadata handle */
160 int codec_hid; /* The ID for the track's codec handle */
161 #ifdef HAVE_ALBUMART
162 int aa_hid[MAX_MULTIPLE_AA];/* The ID for the track's album art handle */
163 #endif
164 int cuesheet_hid; /* The ID for the track's parsed cueesheet handle */
166 size_t filesize; /* File total length */
168 bool taginfo_ready; /* Is metadata read */
170 } tracks[MAX_TRACK];
172 static volatile int track_ridx = 0; /* Track being decoded (A/C-) */
173 static int track_widx = 0; /* Track being buffered (A) */
174 #define CUR_TI (&tracks[track_ridx]) /* Playing track info pointer (A/C-) */
176 static struct track_info *prev_ti = NULL; /* Pointer to the previously played
177 track */
179 /* Information used only for filling the buffer */
180 /* Playlist steps from playing track to next track to be buffered (A) */
181 static int last_peek_offset = 0;
183 /* Scrobbler support */
184 static unsigned long prev_track_elapsed = 0; /* Previous track elapsed time (C/A-)*/
186 /* Track change controls */
187 bool automatic_skip = false; /* Who initiated in-progress skip? (C/A-) */
188 extern bool track_transition; /* Are we in a track transition? */
189 static bool dir_skip = false; /* Is a directory skip pending? (A) */
190 static bool new_playlist = false; /* Are we starting a new playlist? (A) */
191 static int wps_offset = 0; /* Pending track change offset, to keep WPS responsive (A) */
192 static bool skipped_during_pause = false; /* Do we need to clear the PCM buffer when playback resumes (A) */
194 static bool start_play_g = false; /* Used by audio_load_track to notify
195 audio_finish_load_track about start_play */
197 /* True when a track load is in progress, i.e. audio_load_track() has returned
198 * but audio_finish_load_track() hasn't been called yet. Used to avoid allowing
199 * audio_load_track() to get called twice in a row, which would cause problems.
201 static bool track_load_started = false;
203 #ifdef HAVE_DISK_STORAGE
204 static size_t buffer_margin = 5; /* Buffer margin aka anti-skip buffer (A/C-) */
205 #endif
207 /* Event queues */
208 struct event_queue audio_queue SHAREDBSS_ATTR;
209 struct event_queue codec_queue SHAREDBSS_ATTR;
210 static struct event_queue pcmbuf_queue SHAREDBSS_ATTR;
212 extern struct codec_api ci;
213 extern unsigned int codec_thread_id;
215 /* Multiple threads */
216 /* Set the watermark to trigger buffer fill (A/C) */
217 static void set_filebuf_watermark(void);
219 /* Audio thread */
220 static struct queue_sender_list audio_queue_sender_list SHAREDBSS_ATTR;
221 static long audio_stack[(DEFAULT_STACK_SIZE + 0x1000)/sizeof(long)];
222 static const char audio_thread_name[] = "audio";
224 static void audio_thread(void);
225 static void audio_initiate_track_change(long direction);
226 static bool audio_have_tracks(void);
227 static void audio_reset_buffer(void);
228 static void audio_stop_playback(void);
231 /**************************************/
234 /** Pcmbuf callbacks */
236 /* Between the codec and PCM track change, we need to keep updating the
237 * "elapsed" value of the previous (to the codec, but current to the
238 * user/PCM/WPS) track, so that the progressbar reaches the end.
239 * During that transition, the WPS will display othertrack_id3. */
240 void audio_pcmbuf_position_callback(unsigned int time)
242 time += othertrack_id3->elapsed;
244 if (time >= othertrack_id3->length)
246 /* we just played the end of the track, so stop this callback */
247 track_transition = false;
248 othertrack_id3->elapsed = othertrack_id3->length;
250 else
251 othertrack_id3->elapsed = time;
254 /* Post message from pcmbuf that the end of the previous track
255 * has just been played. */
256 void audio_post_track_change(bool pcmbuf)
258 if (pcmbuf)
260 LOGFQUEUE("pcmbuf > pcmbuf Q_AUDIO_TRACK_CHANGED");
261 queue_post(&pcmbuf_queue, Q_AUDIO_TRACK_CHANGED, 0);
263 else
265 LOGFQUEUE("pcmbuf > audio Q_AUDIO_TRACK_CHANGED");
266 queue_post(&audio_queue, Q_AUDIO_TRACK_CHANGED, 0);
270 /* Scan the pcmbuf queue and return true if a message pulled */
271 static bool pcmbuf_queue_scan(struct queue_event *ev)
273 if (!queue_empty(&pcmbuf_queue))
275 /* Transfer message to audio queue */
276 pcm_play_lock();
277 /* Pull message - never, ever any blocking call! */
278 queue_wait_w_tmo(&pcmbuf_queue, ev, 0);
279 pcm_play_unlock();
280 return true;
283 return false;
287 /** Helper functions */
289 static struct mp3entry *bufgetid3(int handle_id)
291 if (handle_id < 0)
292 return NULL;
294 struct mp3entry *id3;
295 ssize_t ret = bufgetdata(handle_id, 0, (void *)&id3);
297 if (ret < 0 || ret != sizeof(struct mp3entry))
298 return NULL;
300 return id3;
303 static bool clear_track_info(struct track_info *track)
305 /* bufclose returns true if the handle is not found, or if it is closed
306 * successfully, so these checks are safe on non-existant handles */
307 if (!track)
308 return false;
310 if (track->codec_hid >= 0) {
311 if (bufclose(track->codec_hid))
312 track->codec_hid = -1;
313 else
314 return false;
317 if (track->id3_hid >= 0) {
318 if (bufclose(track->id3_hid))
319 track->id3_hid = -1;
320 else
321 return false;
324 if (track->audio_hid >= 0) {
325 if (bufclose(track->audio_hid))
326 track->audio_hid = -1;
327 else
328 return false;
331 #ifdef HAVE_ALBUMART
333 int i;
334 FOREACH_ALBUMART(i)
336 if (track->aa_hid[i] >= 0) {
337 if (bufclose(track->aa_hid[i]))
338 track->aa_hid[i] = -1;
339 else
340 return false;
344 #endif
346 if (track->cuesheet_hid >= 0) {
347 if (bufclose(track->cuesheet_hid))
348 track->cuesheet_hid = -1;
349 else
350 return false;
353 track->filesize = 0;
354 track->taginfo_ready = false;
356 return true;
359 /* --- External interfaces --- */
361 /* This sends a stop message and the audio thread will dump all it's
362 subsequenct messages */
363 void audio_hard_stop(void)
365 /* Stop playback */
366 LOGFQUEUE("audio >| audio Q_AUDIO_STOP: 1");
367 queue_send(&audio_queue, Q_AUDIO_STOP, 1);
368 #ifdef PLAYBACK_VOICE
369 voice_stop();
370 #endif
373 bool audio_restore_playback(int type)
375 switch (type)
377 case AUDIO_WANT_PLAYBACK:
378 if (buffer_state != AUDIOBUF_STATE_INITIALIZED)
379 audio_reset_buffer();
380 return true;
381 case AUDIO_WANT_VOICE:
382 if (buffer_state == AUDIOBUF_STATE_TRASHED)
383 audio_reset_buffer();
384 return true;
385 default:
386 return false;
390 unsigned char *audio_get_buffer(bool talk_buf, size_t *buffer_size)
392 unsigned char *buf, *end;
394 if (audio_is_initialized)
396 audio_hard_stop();
398 /* else buffer_state will be AUDIOBUF_STATE_TRASHED at this point */
400 /* Reset the buffering thread so that it doesn't try to use the data */
401 buffering_reset(filebuf, filebuflen);
403 if (buffer_size == NULL)
405 /* Special case for talk_init to use since it already knows it's
406 trashed */
407 buffer_state = AUDIOBUF_STATE_TRASHED;
408 return NULL;
411 if (talk_buf || buffer_state == AUDIOBUF_STATE_TRASHED
412 || !talk_voice_required())
414 logf("get buffer: talk, audio");
415 /* Ok to use everything from audiobuf to audiobufend - voice is loaded,
416 the talk buffer is not needed because voice isn't being used, or
417 could be AUDIOBUF_STATE_TRASHED already. If state is
418 AUDIOBUF_STATE_VOICED_ONLY, no problem as long as memory isn't written
419 without the caller knowing what's going on. Changing certain settings
420 may move it to a worse condition but the memory in use by something
421 else will remain undisturbed.
423 if (buffer_state != AUDIOBUF_STATE_TRASHED)
425 talk_buffer_steal();
426 buffer_state = AUDIOBUF_STATE_TRASHED;
429 buf = audiobuf;
430 end = audiobufend;
432 else
434 /* Safe to just return this if already AUDIOBUF_STATE_VOICED_ONLY or
435 still AUDIOBUF_STATE_INITIALIZED */
436 /* Skip talk buffer and move pcm buffer to end to maximize available
437 contiguous memory - no audio running means voice will not need the
438 swap space */
439 logf("get buffer: audio");
440 buf = audiobuf + talk_get_bufsize();
441 end = audiobufend - pcmbuf_init(audiobufend);
442 buffer_state = AUDIOBUF_STATE_VOICED_ONLY;
445 *buffer_size = end - buf;
447 return buf;
450 bool audio_buffer_state_trashed(void)
452 return buffer_state == AUDIOBUF_STATE_TRASHED;
455 #ifdef HAVE_RECORDING
456 unsigned char *audio_get_recording_buffer(size_t *buffer_size)
458 /* Stop audio, voice and obtain all available buffer space */
459 audio_hard_stop();
460 talk_buffer_steal();
462 unsigned char *end = audiobufend;
463 buffer_state = AUDIOBUF_STATE_TRASHED;
464 *buffer_size = end - audiobuf;
466 return (unsigned char *)audiobuf;
469 bool audio_load_encoder(int afmt)
471 #ifndef SIMULATOR
472 const char *enc_fn = get_codec_filename(afmt | CODEC_TYPE_ENCODER);
473 if (!enc_fn)
474 return false;
476 audio_remove_encoder();
477 ci.enc_codec_loaded = 0; /* clear any previous error condition */
479 LOGFQUEUE("codec > Q_ENCODER_LOAD_DISK");
480 queue_post(&codec_queue, Q_ENCODER_LOAD_DISK, (intptr_t)enc_fn);
482 while (ci.enc_codec_loaded == 0)
483 yield();
485 logf("codec loaded: %d", ci.enc_codec_loaded);
487 return ci.enc_codec_loaded > 0;
488 #else
489 (void)afmt;
490 return true;
491 #endif
492 } /* audio_load_encoder */
494 void audio_remove_encoder(void)
496 #ifndef SIMULATOR
497 /* force encoder codec unload (if currently loaded) */
498 if (ci.enc_codec_loaded <= 0)
499 return;
501 ci.stop_encoder = true;
502 while (ci.enc_codec_loaded > 0)
503 yield();
504 #endif
505 } /* audio_remove_encoder */
507 #endif /* HAVE_RECORDING */
510 struct mp3entry* audio_current_track(void)
512 const char *filename;
513 struct playlist_track_info trackinfo;
514 int cur_idx;
515 int offset = ci.new_track + wps_offset;
516 struct mp3entry *write_id3;
518 cur_idx = (track_ridx + offset) & MAX_TRACK_MASK;
520 if (cur_idx == track_ridx && *thistrack_id3->path)
522 /* The usual case */
523 if (tracks[cur_idx].cuesheet_hid >= 0 && !thistrack_id3->cuesheet)
525 bufread(tracks[cur_idx].cuesheet_hid, sizeof(struct cuesheet), curr_cue);
526 thistrack_id3->cuesheet = curr_cue;
527 cue_spoof_id3(thistrack_id3->cuesheet, thistrack_id3);
529 return thistrack_id3;
531 else if (automatic_skip && offset == -1 && *othertrack_id3->path)
533 /* We're in a track transition. The codec has moved on to the next track,
534 but the audio being played is still the same (now previous) track.
535 othertrack_id3.elapsed is being updated in an ISR by
536 codec_pcmbuf_position_callback */
537 if (tracks[cur_idx].cuesheet_hid >= 0 && !thistrack_id3->cuesheet)
539 bufread(tracks[cur_idx].cuesheet_hid, sizeof(struct cuesheet), curr_cue);
540 othertrack_id3->cuesheet = curr_cue;
541 cue_spoof_id3(othertrack_id3->cuesheet, othertrack_id3);
543 return othertrack_id3;
546 if (offset != 0)
548 /* Codec may be using thistrack_id3, so it must not be overwritten.
549 If this is a manual skip, othertrack_id3 will become
550 thistrack_id3 in audio_check_new_track().
551 FIXME: If this is an automatic skip, it probably means multiple
552 short tracks fit in the PCM buffer. Overwriting othertrack_id3
553 can lead to an incorrect value later.
554 Note that othertrack_id3 may also be used for next track.
556 write_id3 = othertrack_id3;
558 else
560 write_id3 = thistrack_id3;
563 if (tracks[cur_idx].id3_hid >= 0)
565 /* The current track's info has been buffered but not read yet, so get it */
566 if (bufread(tracks[cur_idx].id3_hid, sizeof(struct mp3entry), write_id3)
567 == sizeof(struct mp3entry))
568 return write_id3;
571 /* We didn't find the ID3 metadata, so we fill temp_id3 with the little info
572 we have and return that. */
574 memset(write_id3, 0, sizeof(struct mp3entry));
576 playlist_get_track_info(NULL, playlist_next(0)+wps_offset, &trackinfo);
577 filename = trackinfo.filename;
578 if (!filename)
579 filename = "No file!";
581 #if defined(HAVE_TC_RAMCACHE) && defined(HAVE_DIRCACHE)
582 if (tagcache_fill_tags(write_id3, filename))
583 return write_id3;
584 #endif
586 strlcpy(write_id3->path, filename, sizeof(write_id3->path));
587 write_id3->title = strrchr(write_id3->path, '/');
588 if (!write_id3->title)
589 write_id3->title = &write_id3->path[0];
590 else
591 write_id3->title++;
593 return write_id3;
596 struct mp3entry* audio_next_track(void)
598 int next_idx;
599 int offset = ci.new_track + wps_offset;
601 if (!audio_have_tracks())
602 return NULL;
604 if (wps_offset == -1 && *thistrack_id3->path)
606 /* We're in a track transition. The next track for the WPS is the one
607 currently being decoded. */
608 return thistrack_id3;
611 next_idx = (track_ridx + offset + 1) & MAX_TRACK_MASK;
613 if (tracks[next_idx].id3_hid >= 0)
615 if (bufread(tracks[next_idx].id3_hid, sizeof(struct mp3entry), othertrack_id3)
616 == sizeof(struct mp3entry))
617 return othertrack_id3;
618 else
619 return NULL;
622 if (next_idx == track_widx)
624 /* The next track hasn't been buffered yet, so we return the static
625 version of its metadata. */
626 return &unbuffered_id3;
629 return NULL;
632 /* gets a pointer to the id3 data, Not thread safe!, DON'T yield()/sleep() */
633 bool audio_peek_track(struct mp3entry** id3, int offset)
635 int next_idx;
636 int new_offset = ci.new_track + wps_offset + offset;
638 if (!audio_have_tracks())
639 return false;
640 next_idx = (track_ridx + new_offset) & MAX_TRACK_MASK;
642 if (tracks[next_idx].id3_hid >= 0)
644 return bufgetdata(tracks[next_idx].id3_hid, 0, (void**)id3)
645 == sizeof(struct mp3entry);
647 return false;
650 #ifdef HAVE_ALBUMART
651 int playback_current_aa_hid(int slot)
653 if (slot < 0)
654 return -1;
655 int cur_idx;
656 int offset = ci.new_track + wps_offset;
658 cur_idx = track_ridx + offset;
659 cur_idx &= MAX_TRACK_MASK;
661 return tracks[cur_idx].aa_hid[slot];
664 int playback_claim_aa_slot(struct dim *dim)
666 int i;
667 /* first try to find a slot already having the size to reuse it
668 * since we don't want albumart of the same size buffered multiple times */
669 FOREACH_ALBUMART(i)
671 struct albumart_slot *slot = &albumart_slots[i];
672 if (slot->dim.width == dim->width
673 && slot->dim.height == dim->height)
675 slot->used++;
676 return i;
679 /* size is new, find a free slot */
680 FOREACH_ALBUMART(i)
682 if (!albumart_slots[i].used)
684 albumart_slots[i].used++;
685 albumart_slots[i].dim = *dim;
686 return i;
689 /* sorry, no free slot */
690 return -1;
693 void playback_release_aa_slot(int slot)
695 /* invalidate the albumart_slot */
696 struct albumart_slot *aa_slot = &albumart_slots[slot];
697 if (aa_slot->used > 0)
698 aa_slot->used--;
701 #endif
702 void audio_play(long offset)
704 logf("audio_play");
706 #ifdef PLAYBACK_VOICE
707 /* Truncate any existing voice output so we don't have spelling
708 * etc. over the first part of the played track */
709 talk_force_shutup();
710 #endif
712 /* Start playback */
713 LOGFQUEUE("audio >| audio Q_AUDIO_PLAY: %ld", offset);
714 /* Don't return until playback has actually started */
715 queue_send(&audio_queue, Q_AUDIO_PLAY, offset);
718 void audio_stop(void)
720 /* Stop playback */
721 LOGFQUEUE("audio >| audio Q_AUDIO_STOP");
722 /* Don't return until playback has actually stopped */
723 queue_send(&audio_queue, Q_AUDIO_STOP, 0);
726 void audio_pause(void)
728 LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE");
729 /* Don't return until playback has actually paused */
730 queue_send(&audio_queue, Q_AUDIO_PAUSE, true);
733 void audio_resume(void)
735 LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE resume");
736 /* Don't return until playback has actually resumed */
737 queue_send(&audio_queue, Q_AUDIO_PAUSE, false);
740 void audio_skip(int direction)
742 if (playlist_check(ci.new_track + wps_offset + direction))
744 if (global_settings.beep)
745 pcmbuf_beep(2000, 100, 2500*global_settings.beep);
747 LOGFQUEUE("audio > audio Q_AUDIO_SKIP %d", direction);
748 queue_post(&audio_queue, Q_AUDIO_SKIP, direction);
749 /* Update wps while our message travels inside deep playback queues. */
750 wps_offset += direction;
752 else
754 /* No more tracks. */
755 if (global_settings.beep)
756 pcmbuf_beep(1000, 100, 1500*global_settings.beep);
760 void audio_next(void)
762 audio_skip(1);
765 void audio_prev(void)
767 audio_skip(-1);
770 void audio_next_dir(void)
772 LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP 1");
773 queue_post(&audio_queue, Q_AUDIO_DIR_SKIP, 1);
776 void audio_prev_dir(void)
778 LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP -1");
779 queue_post(&audio_queue, Q_AUDIO_DIR_SKIP, -1);
782 void audio_pre_ff_rewind(void)
784 LOGFQUEUE("audio > audio Q_AUDIO_PRE_FF_REWIND");
785 queue_post(&audio_queue, Q_AUDIO_PRE_FF_REWIND, 0);
788 void audio_ff_rewind(long newpos)
790 LOGFQUEUE("audio > audio Q_AUDIO_FF_REWIND");
791 queue_post(&audio_queue, Q_AUDIO_FF_REWIND, newpos);
794 void audio_flush_and_reload_tracks(void)
796 LOGFQUEUE("audio > audio Q_AUDIO_FLUSH");
797 queue_post(&audio_queue, Q_AUDIO_FLUSH, 0);
800 void audio_error_clear(void)
802 #ifdef AUDIO_HAVE_RECORDING
803 pcm_rec_error_clear();
804 #endif
807 int audio_status(void)
809 int ret = 0;
811 if (playing)
812 ret |= AUDIO_STATUS_PLAY;
814 if (paused)
815 ret |= AUDIO_STATUS_PAUSE;
817 #ifdef HAVE_RECORDING
818 /* Do this here for constitency with mpeg.c version */
819 /* FIXME: pcm_rec_status() is deprecated */
820 ret |= pcm_rec_status();
821 #endif
823 return ret;
826 int audio_get_file_pos(void)
828 return 0;
831 #ifdef HAVE_DISK_STORAGE
832 void audio_set_buffer_margin(int setting)
834 static const unsigned short lookup[] = {5, 15, 30, 60, 120, 180, 300, 600};
835 buffer_margin = lookup[setting];
836 logf("buffer margin: %ld", (long)buffer_margin);
837 set_filebuf_watermark();
839 #endif
841 #ifdef HAVE_CROSSFADE
842 /* Take necessary steps to enable or disable the crossfade setting */
843 void audio_set_crossfade(int enable)
845 size_t offset;
846 bool was_playing;
847 size_t size;
849 /* Tell it the next setting to use */
850 pcmbuf_request_crossfade_enable(enable);
852 /* Return if size hasn't changed or this is too early to determine
853 which in the second case there's no way we could be playing
854 anything at all */
855 if (pcmbuf_is_same_size()) return;
857 offset = 0;
858 was_playing = playing;
860 /* Playback has to be stopped before changing the buffer size */
861 if (was_playing)
863 /* Store the track resume position */
864 offset = thistrack_id3->offset;
867 /* Blast it - audio buffer will have to be setup again next time
868 something plays */
869 audio_get_buffer(true, &size);
871 /* Restart playback if audio was running previously */
872 if (was_playing)
873 audio_play(offset);
875 #endif
877 /* --- Routines called from multiple threads --- */
879 static void set_filebuf_watermark(void)
881 if (!filebuf)
882 return; /* Audio buffers not yet set up */
884 #ifdef HAVE_DISK_STORAGE
885 int seconds;
886 int spinup = ata_spinup_time();
887 if (spinup)
888 seconds = (spinup / HZ) + 1;
889 else
890 seconds = 5;
892 seconds += buffer_margin;
893 #else
894 /* flash storage */
895 int seconds = 1;
896 #endif
898 /* bitrate of last track in buffer dictates watermark */
899 struct mp3entry* id3 = NULL;
900 if (tracks[track_widx].taginfo_ready)
901 id3 = bufgetid3(tracks[track_widx].id3_hid);
902 else
903 id3 = bufgetid3(tracks[track_widx-1].id3_hid);
904 if (!id3) {
905 logf("fwmark: No id3 for last track (r%d/w%d), aborting!", track_ridx, track_widx);
906 return;
908 size_t bytes = id3->bitrate * (1000/8) * seconds;
909 buf_set_watermark(bytes);
910 logf("fwmark: %d", bytes);
913 /* --- Buffering callbacks --- */
915 static void buffering_low_buffer_callback(void *data)
917 (void)data;
918 logf("low buffer callback");
920 if (filling == STATE_FULL || filling == STATE_END_OF_PLAYLIST) {
921 /* force a refill */
922 LOGFQUEUE("buffering > audio Q_AUDIO_FILL_BUFFER");
923 queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, 0);
927 static void buffering_handle_rebuffer_callback(void *data)
929 (void)data;
930 LOGFQUEUE("audio >| audio Q_AUDIO_FLUSH");
931 queue_post(&audio_queue, Q_AUDIO_FLUSH, 0);
934 static void buffering_handle_finished_callback(void *data)
936 logf("handle %d finished buffering", *(int*)data);
937 int hid = (*(int*)data);
939 if (hid == tracks[track_widx].id3_hid)
941 int offset = ci.new_track + wps_offset;
942 int next_idx = (track_ridx + offset + 1) & MAX_TRACK_MASK;
943 /* The metadata handle for the last loaded track has been buffered.
944 We can ask the audio thread to load the rest of the track's data. */
945 LOGFQUEUE("audio >| audio Q_AUDIO_FINISH_LOAD");
946 queue_post(&audio_queue, Q_AUDIO_FINISH_LOAD, 0);
947 if (tracks[next_idx].id3_hid == hid)
948 send_event(PLAYBACK_EVENT_NEXTTRACKID3_AVAILABLE, NULL);
950 else
952 /* This is most likely an audio handle, so we strip the useless
953 trailing tags that are left. */
954 strip_tags(hid);
956 if (hid == tracks[track_widx-1].audio_hid
957 && filling == STATE_END_OF_PLAYLIST)
959 /* This was the last track in the playlist.
960 We now have all the data we need. */
961 logf("last track finished buffering");
962 filling = STATE_FINISHED;
968 /* --- Audio thread --- */
970 static bool audio_have_tracks(void)
972 return (audio_track_count() != 0);
975 static int audio_free_track_count(void)
977 /* Used tracks + free tracks adds up to MAX_TRACK - 1 */
978 return MAX_TRACK - 1 - audio_track_count();
981 int audio_track_count(void)
983 /* Calculate difference from track_ridx to track_widx
984 * taking into account a possible wrap-around. */
985 return (MAX_TRACK + track_widx - track_ridx) & MAX_TRACK_MASK;
988 long audio_filebufused(void)
990 return (long) buf_used();
993 /* Update track info after successful a codec track change */
994 static void audio_update_trackinfo(void)
996 /* Load the curent track's metadata into curtrack_id3 */
997 if (CUR_TI->id3_hid >= 0)
998 copy_mp3entry(thistrack_id3, bufgetid3(CUR_TI->id3_hid));
1000 /* Reset current position */
1001 thistrack_id3->elapsed = 0;
1002 thistrack_id3->offset = 0;
1004 /* Update the codec API */
1005 ci.filesize = CUR_TI->filesize;
1006 ci.id3 = thistrack_id3;
1007 ci.curpos = 0;
1008 ci.taginfo_ready = &CUR_TI->taginfo_ready;
1011 /* Clear tracks between write and read, non inclusive */
1012 static void audio_clear_track_entries(void)
1014 int cur_idx = track_widx;
1016 logf("Clearing tracks: r%d/w%d", track_ridx, track_widx);
1018 /* Loop over all tracks from write-to-read */
1019 while (1)
1021 cur_idx = (cur_idx + 1) & MAX_TRACK_MASK;
1023 if (cur_idx == track_ridx)
1024 break;
1026 clear_track_info(&tracks[cur_idx]);
1030 /* Clear all tracks */
1031 static bool audio_release_tracks(void)
1033 int i, cur_idx;
1035 logf("releasing all tracks");
1037 for(i = 0; i < MAX_TRACK; i++)
1039 cur_idx = (track_ridx + i) & MAX_TRACK_MASK;
1040 if (!clear_track_info(&tracks[cur_idx]))
1041 return false;
1044 return true;
1047 static bool audio_loadcodec(bool start_play)
1049 int prev_track;
1050 char codec_path[MAX_PATH]; /* Full path to codec */
1051 const struct mp3entry *id3, *prev_id3;
1053 if (tracks[track_widx].id3_hid < 0) {
1054 return false;
1057 id3 = bufgetid3(tracks[track_widx].id3_hid);
1058 if (!id3)
1059 return false;
1061 const char *codec_fn = get_codec_filename(id3->codectype);
1062 if (codec_fn == NULL)
1063 return false;
1065 tracks[track_widx].codec_hid = -1;
1067 if (start_play)
1069 /* Load the codec directly from disk and save some memory. */
1070 track_ridx = track_widx;
1071 ci.filesize = CUR_TI->filesize;
1072 ci.id3 = thistrack_id3;
1073 ci.taginfo_ready = &CUR_TI->taginfo_ready;
1074 ci.curpos = 0;
1075 LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK");
1076 queue_post(&codec_queue, Q_CODEC_LOAD_DISK, (intptr_t)codec_fn);
1077 return true;
1079 else
1081 /* If we already have another track than this one buffered */
1082 if (track_widx != track_ridx)
1084 prev_track = (track_widx - 1) & MAX_TRACK_MASK;
1086 id3 = bufgetid3(tracks[track_widx].id3_hid);
1087 prev_id3 = bufgetid3(tracks[prev_track].id3_hid);
1089 /* If the previous codec is the same as this one, there is no need
1090 * to put another copy of it on the file buffer */
1091 if (id3 && prev_id3 &&
1092 get_codec_base_type(id3->codectype) ==
1093 get_codec_base_type(prev_id3->codectype)
1094 && audio_codec_loaded)
1096 logf("Reusing prev. codec");
1097 return true;
1102 codec_get_full_path(codec_path, codec_fn);
1104 tracks[track_widx].codec_hid = bufopen(codec_path, 0, TYPE_CODEC, NULL);
1105 if (tracks[track_widx].codec_hid < 0)
1106 return false;
1108 logf("Loaded codec");
1110 return true;
1113 /* Load metadata for the next track (with bufopen). The rest of the track
1114 loading will be handled by audio_finish_load_track once the metadata has been
1115 actually loaded by the buffering thread. */
1116 static bool audio_load_track(size_t offset, bool start_play)
1118 const char *trackname;
1119 int fd = -1;
1121 if (track_load_started) {
1122 /* There is already a track load in progress, so track_widx hasn't been
1123 incremented yet. Loading another track would overwrite the one that
1124 hasn't finished loading. */
1125 logf("audio_load_track(): a track load is already in progress");
1126 return false;
1129 start_play_g = start_play; /* will be read by audio_finish_load_track */
1131 /* Stop buffer filling if there is no free track entries.
1132 Don't fill up the last track entry (we wan't to store next track
1133 metadata there). */
1134 if (!audio_free_track_count())
1136 logf("No free tracks");
1137 return false;
1140 last_peek_offset++;
1141 tracks[track_widx].taginfo_ready = false;
1143 logf("Buffering track: r%d/w%d", track_ridx, track_widx);
1144 /* Get track name from current playlist read position. */
1145 while ((trackname = playlist_peek(last_peek_offset)) != NULL)
1147 /* Handle broken playlists. */
1148 fd = open(trackname, O_RDONLY);
1149 if (fd < 0)
1151 logf("Open failed");
1152 /* Skip invalid entry from playlist. */
1153 playlist_skip_entry(NULL, last_peek_offset);
1155 else
1156 break;
1159 if (!trackname)
1161 logf("End-of-playlist");
1162 memset(&unbuffered_id3, 0, sizeof(struct mp3entry));
1163 filling = STATE_END_OF_PLAYLIST;
1165 if (thistrack_id3->length == 0 && thistrack_id3->filesize == 0)
1167 /* Stop playback if no valid track was found. */
1168 audio_stop_playback();
1171 return false;
1174 tracks[track_widx].filesize = filesize(fd);
1176 if (offset > tracks[track_widx].filesize)
1177 offset = 0;
1179 /* Set default values */
1180 if (start_play)
1182 buf_set_watermark(filebuflen/2);
1183 dsp_configure(ci.dsp, DSP_RESET, 0);
1184 playlist_update_resume_info(audio_current_track());
1187 /* Get track metadata if we don't already have it. */
1188 if (tracks[track_widx].id3_hid < 0)
1190 tracks[track_widx].id3_hid = bufopen(trackname, 0, TYPE_ID3, NULL);
1192 if (tracks[track_widx].id3_hid < 0)
1194 /* Buffer is full. */
1195 get_metadata(&unbuffered_id3, fd, trackname);
1196 last_peek_offset--;
1197 close(fd);
1198 logf("buffer is full for now (get metadata)");
1199 filling = STATE_FULL;
1200 return false;
1203 if (track_widx == track_ridx)
1205 /* TODO: Superfluos buffering call? */
1206 buf_request_buffer_handle(tracks[track_widx].id3_hid);
1207 struct mp3entry *id3 = bufgetid3(tracks[track_widx].id3_hid);
1208 if (id3)
1210 copy_mp3entry(thistrack_id3, id3);
1211 thistrack_id3->offset = offset;
1213 else
1214 memset(thistrack_id3, 0, sizeof(struct mp3entry));
1217 if (start_play)
1219 playlist_update_resume_info(audio_current_track());
1223 close(fd);
1224 track_load_started = true; /* Remember that we've started loading a track */
1225 return true;
1228 /* Second part of the track loading: We now have the metadata available, so we
1229 can load the codec, the album art and finally the audio data.
1230 This is called on the audio thread after the buffering thread calls the
1231 buffering_handle_finished_callback callback. */
1232 static void audio_finish_load_track(void)
1234 size_t file_offset = 0;
1235 size_t offset = 0;
1236 bool start_play = start_play_g;
1238 track_load_started = false;
1240 if (tracks[track_widx].id3_hid < 0) {
1241 logf("No metadata");
1242 return;
1245 struct mp3entry *track_id3;
1247 if (track_widx == track_ridx)
1248 track_id3 = thistrack_id3;
1249 else
1250 track_id3 = bufgetid3(tracks[track_widx].id3_hid);
1252 if (track_id3->length == 0 && track_id3->filesize == 0)
1254 logf("audio_finish_load_track: invalid metadata");
1256 /* Invalid metadata */
1257 bufclose(tracks[track_widx].id3_hid);
1258 tracks[track_widx].id3_hid = -1;
1260 /* Skip invalid entry from playlist. */
1261 playlist_skip_entry(NULL, last_peek_offset--);
1263 /* load next track */
1264 LOGFQUEUE("audio > audio Q_AUDIO_FILL_BUFFER %d", (int)start_play);
1265 queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, start_play);
1267 return;
1269 /* Try to load a cuesheet for the track */
1270 if (curr_cue)
1272 char cuepath[MAX_PATH];
1273 if (look_for_cuesheet_file(track_id3->path, cuepath))
1275 void *temp;
1276 tracks[track_widx].cuesheet_hid =
1277 bufalloc(NULL, sizeof(struct cuesheet), TYPE_CUESHEET);
1278 if (tracks[track_widx].cuesheet_hid >= 0)
1280 bufgetdata(tracks[track_widx].cuesheet_hid,
1281 sizeof(struct cuesheet), &temp);
1282 struct cuesheet *cuesheet = (struct cuesheet*)temp;
1283 if (!parse_cuesheet(cuepath, cuesheet))
1285 bufclose(tracks[track_widx].cuesheet_hid);
1286 track_id3->cuesheet = NULL;
1291 #ifdef HAVE_ALBUMART
1293 int i;
1294 char aa_path[MAX_PATH];
1295 FOREACH_ALBUMART(i)
1297 /* albumart_slots may change during a yield of bufopen,
1298 * but that's no problem */
1299 if (tracks[track_widx].aa_hid[i] >= 0 || !albumart_slots[i].used)
1300 continue;
1301 /* find_albumart will error out if the wps doesn't have AA */
1302 if (find_albumart(track_id3, aa_path, sizeof(aa_path),
1303 &(albumart_slots[i].dim)))
1305 int aa_hid = bufopen(aa_path, 0, TYPE_BITMAP,
1306 &(albumart_slots[i].dim));
1308 if(aa_hid == ERR_BUFFER_FULL)
1310 filling = STATE_FULL;
1311 logf("buffer is full for now (get album art)");
1312 return; /* No space for track's album art, not an error */
1314 else if (aa_hid < 0)
1316 /* another error, ignore AlbumArt */
1317 logf("Album art loading failed");
1319 tracks[track_widx].aa_hid[i] = aa_hid;
1324 #endif
1326 /* Load the codec. */
1327 if (!audio_loadcodec(start_play))
1329 if (tracks[track_widx].codec_hid == ERR_BUFFER_FULL)
1331 /* No space for codec on buffer, not an error */
1332 filling = STATE_FULL;
1333 return;
1336 /* This is an error condition, either no codec was found, or reading
1337 * the codec file failed part way through, either way, skip the track */
1338 /* FIXME: We should not use splashf from audio thread! */
1339 splashf(HZ*2, "No codec for: %s", track_id3->path);
1340 /* Skip invalid entry from playlist. */
1341 playlist_skip_entry(NULL, last_peek_offset);
1342 return;
1345 track_id3->elapsed = 0;
1346 offset = track_id3->offset;
1347 size_t resume_rewind = (global_settings.resume_rewind *
1348 track_id3->bitrate * 1000) / 8;
1350 if (offset < resume_rewind)
1352 offset = 0;
1354 else
1356 offset -= resume_rewind;
1359 enum data_type type = TYPE_PACKET_AUDIO;
1361 switch (track_id3->codectype) {
1362 case AFMT_MPA_L1:
1363 case AFMT_MPA_L2:
1364 case AFMT_MPA_L3:
1365 if (offset > 0) {
1366 file_offset = offset;
1368 break;
1370 case AFMT_WAVPACK:
1371 if (offset > 0) {
1372 file_offset = offset;
1373 track_id3->elapsed = track_id3->length / 2;
1375 break;
1377 case AFMT_NSF:
1378 case AFMT_SPC:
1379 case AFMT_SID:
1380 logf("Loading atomic %d",track_id3->codectype);
1381 type = TYPE_ATOMIC_AUDIO;
1382 break;
1384 default:
1385 /* no special treatment needed */
1386 break;
1389 track_id3->offset = offset;
1391 logf("load track: %s", track_id3->path);
1393 if (file_offset > AUDIO_REBUFFER_GUESS_SIZE)
1394 file_offset -= AUDIO_REBUFFER_GUESS_SIZE;
1395 else if (track_id3->first_frame_offset)
1396 file_offset = track_id3->first_frame_offset;
1397 else
1398 file_offset = 0;
1400 tracks[track_widx].audio_hid = bufopen(track_id3->path, file_offset, type,
1401 NULL);
1403 /* No space left, not an error */
1404 if (tracks[track_widx].audio_hid == ERR_BUFFER_FULL)
1406 filling = STATE_FULL;
1407 logf("buffer is full for now (load audio)");
1408 return;
1410 else if (tracks[track_widx].audio_hid < 0)
1412 /* another error, do not continue either */
1413 logf("Could not add audio data handle");
1414 return;
1417 /* All required data is now available for the codec. */
1418 tracks[track_widx].taginfo_ready = true;
1420 if (start_play)
1422 ci.curpos=file_offset;
1423 buf_request_buffer_handle(tracks[track_widx].audio_hid);
1426 track_widx = (track_widx + 1) & MAX_TRACK_MASK;
1428 send_event(PLAYBACK_EVENT_TRACK_BUFFER, track_id3);
1430 /* load next track */
1431 LOGFQUEUE("audio > audio Q_AUDIO_FILL_BUFFER");
1432 queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, 0);
1434 return;
1437 static void audio_fill_file_buffer(bool start_play, size_t offset)
1439 trigger_cpu_boost();
1441 /* No need to rebuffer if there are track skips pending,
1442 * however don't cancel buffering on skipping while filling. */
1443 if (ci.new_track != 0 && filling != STATE_FILLING)
1444 return;
1445 filling = STATE_FILLING;
1447 /* Must reset the buffer before use if trashed or voice only - voice
1448 file size shouldn't have changed so we can go straight from
1449 AUDIOBUF_STATE_VOICED_ONLY to AUDIOBUF_STATE_INITIALIZED */
1450 if (buffer_state != AUDIOBUF_STATE_INITIALIZED)
1451 audio_reset_buffer();
1453 logf("Starting buffer fill");
1455 if (!start_play)
1456 audio_clear_track_entries();
1458 /* Save the current resume position once. */
1459 playlist_update_resume_info(audio_current_track());
1461 audio_load_track(offset, start_play);
1464 static void audio_rebuffer(void)
1466 logf("Forcing rebuffer");
1468 clear_track_info(CUR_TI);
1470 /* Reset track pointers */
1471 track_widx = track_ridx;
1472 audio_clear_track_entries();
1474 /* Reset a possibly interrupted track load */
1475 track_load_started = false;
1477 /* Fill the buffer */
1478 last_peek_offset = -1;
1479 ci.curpos = 0;
1481 if (!CUR_TI->taginfo_ready)
1482 memset(thistrack_id3, 0, sizeof(struct mp3entry));
1484 audio_fill_file_buffer(false, 0);
1487 /* Called on request from the codec to get a new track. This is the codec part
1488 of the track transition. */
1489 static int audio_check_new_track(void)
1491 int track_count = audio_track_count();
1492 int old_track_ridx = track_ridx;
1493 int i, idx;
1494 bool forward;
1495 struct mp3entry *temp = thistrack_id3;
1497 /* Now it's good time to send track finish events. */
1498 send_event(PLAYBACK_EVENT_TRACK_FINISH, thistrack_id3);
1499 /* swap the mp3entry pointers */
1500 thistrack_id3 = othertrack_id3;
1501 othertrack_id3 = temp;
1502 ci.id3 = thistrack_id3;
1503 memset(thistrack_id3, 0, sizeof(struct mp3entry));
1505 if (dir_skip)
1507 dir_skip = false;
1508 /* regardless of the return value we need to rebuffer.
1509 if it fails the old playlist will resume, else the
1510 next dir will start playing */
1511 playlist_next_dir(ci.new_track);
1512 ci.new_track = 0;
1513 audio_rebuffer();
1514 goto skip_done;
1517 if (new_playlist)
1518 ci.new_track = 0;
1520 /* If the playlist isn't that big */
1521 if (automatic_skip)
1523 while (!playlist_check(ci.new_track))
1525 if (ci.new_track >= 0)
1527 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1528 return Q_CODEC_REQUEST_FAILED;
1530 ci.new_track++;
1534 /* Update the playlist */
1535 last_peek_offset -= ci.new_track;
1537 if (playlist_next(ci.new_track) < 0)
1539 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1540 return Q_CODEC_REQUEST_FAILED;
1543 if (new_playlist)
1545 ci.new_track = 1;
1546 new_playlist = false;
1549 /* Save a pointer to the old track to allow later clearing */
1550 prev_ti = CUR_TI;
1552 for (i = 0; i < ci.new_track; i++)
1554 idx = (track_ridx + i) & MAX_TRACK_MASK;
1555 struct mp3entry *id3 = bufgetid3(tracks[idx].id3_hid);
1556 ssize_t offset = buf_handle_offset(tracks[idx].audio_hid);
1557 if (!id3 || offset < 0 || (unsigned)offset > id3->first_frame_offset)
1559 /* We don't have all the audio data for that track, so clear it,
1560 but keep the metadata. */
1561 if (tracks[idx].audio_hid >= 0 && bufclose(tracks[idx].audio_hid))
1563 tracks[idx].audio_hid = -1;
1564 tracks[idx].filesize = 0;
1569 /* Move to the new track */
1570 track_ridx = (track_ridx + ci.new_track) & MAX_TRACK_MASK;
1571 buf_set_base_handle(CUR_TI->audio_hid);
1574 if (automatic_skip)
1576 wps_offset = -ci.new_track;
1579 /* If it is not safe to even skip this many track entries */
1580 if (ci.new_track >= track_count || ci.new_track <= track_count - MAX_TRACK)
1582 ci.new_track = 0;
1583 audio_rebuffer();
1584 goto skip_done;
1587 forward = ci.new_track > 0;
1588 ci.new_track = 0;
1590 /* If the target track is clearly not in memory */
1591 if (CUR_TI->filesize == 0 || !CUR_TI->taginfo_ready)
1593 audio_rebuffer();
1594 goto skip_done;
1597 /* When skipping backwards, it is possible that we've found a track that's
1598 * buffered, but which is around the track-wrap and therefore not the track
1599 * we are looking for */
1600 if (!forward)
1602 int cur_idx = track_ridx;
1603 bool taginfo_ready = true;
1604 /* We've wrapped the buffer backwards if new > old */
1605 bool wrap = track_ridx > old_track_ridx;
1607 while (1)
1609 cur_idx = (cur_idx + 1) & MAX_TRACK_MASK;
1611 /* if we've advanced past the wrap when cur_idx is zeroed */
1612 if (!cur_idx)
1613 wrap = false;
1615 /* if we aren't still on the wrap and we've caught the old track */
1616 if (!(wrap || cur_idx < old_track_ridx))
1617 break;
1619 /* If we hit a track in between without valid tag info, bail */
1620 if (!tracks[cur_idx].taginfo_ready)
1622 taginfo_ready = false;
1623 break;
1626 if (!taginfo_ready)
1628 audio_rebuffer();
1632 skip_done:
1633 audio_update_trackinfo();
1634 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_COMPLETE");
1635 return Q_CODEC_REQUEST_COMPLETE;
1638 unsigned long audio_prev_elapsed(void)
1640 return prev_track_elapsed;
1643 void audio_set_prev_elapsed(unsigned long setting)
1645 prev_track_elapsed = setting;
1648 static void audio_stop_codec_flush(void)
1650 ci.stop_codec = true;
1651 pcmbuf_pause(true);
1653 while (audio_codec_loaded)
1654 yield();
1656 /* If the audio codec is not loaded any more, and the audio is still
1657 * playing, it is now and _only_ now safe to call this function from the
1658 * audio thread */
1659 if (pcm_is_playing())
1661 pcmbuf_play_stop();
1662 pcm_play_lock();
1663 queue_clear(&pcmbuf_queue);
1664 pcm_play_unlock();
1666 pcmbuf_pause(paused);
1669 static void audio_stop_playback(void)
1671 if (playing)
1673 /* If we were playing, save resume information */
1674 struct mp3entry *id3 = NULL;
1676 if (!ci.stop_codec)
1678 /* Set this early, the outside code yields and may allow the codec
1679 to try to wait for a reply on a buffer wait */
1680 ci.stop_codec = true;
1681 id3 = audio_current_track();
1684 /* Save the current playing spot, or NULL if the playlist has ended */
1685 playlist_update_resume_info(id3);
1687 /* TODO: Create auto bookmark too? */
1689 prev_track_elapsed = othertrack_id3->elapsed;
1691 remove_event(BUFFER_EVENT_BUFFER_LOW, buffering_low_buffer_callback);
1694 audio_stop_codec_flush();
1695 paused = false;
1696 playing = false;
1697 track_load_started = false;
1699 filling = STATE_IDLE;
1701 /* Mark all entries null. */
1702 audio_clear_track_entries();
1704 /* Close all tracks */
1705 audio_release_tracks();
1708 static void audio_play_start(size_t offset)
1710 int i;
1712 #if INPUT_SRC_CAPS != 0
1713 audio_set_input_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK);
1714 audio_set_output_source(AUDIO_SRC_PLAYBACK);
1715 #endif
1717 /* Wait for any previously playing audio to flush - TODO: Not necessary? */
1718 paused = false;
1719 audio_stop_codec_flush();
1721 playing = true;
1722 track_load_started = false;
1724 ci.new_track = 0;
1725 ci.seek_time = 0;
1726 wps_offset = 0;
1728 sound_set_volume(global_settings.volume);
1729 track_widx = track_ridx = 0;
1730 buf_set_base_handle(-1);
1732 /* Clear all track entries. */
1733 for (i = 0; i < MAX_TRACK; i++) {
1734 clear_track_info(&tracks[i]);
1737 last_peek_offset = -1;
1739 /* Officially playing */
1740 queue_reply(&audio_queue, 1);
1742 audio_fill_file_buffer(true, offset);
1744 add_event(BUFFER_EVENT_BUFFER_LOW, false, buffering_low_buffer_callback);
1746 LOGFQUEUE("audio > audio Q_AUDIO_TRACK_CHANGED");
1747 queue_post(&audio_queue, Q_AUDIO_TRACK_CHANGED, 0);
1751 /* Invalidates all but currently playing track. */
1752 static void audio_invalidate_tracks(void)
1754 if (audio_have_tracks())
1756 last_peek_offset = 0;
1757 track_widx = track_ridx;
1759 /* Mark all other entries null (also buffered wrong metadata). */
1760 audio_clear_track_entries();
1762 track_widx = (track_widx + 1) & MAX_TRACK_MASK;
1764 audio_fill_file_buffer(false, 0);
1765 send_event(PLAYBACK_EVENT_TRACK_CHANGE, thistrack_id3);
1769 static void audio_new_playlist(void)
1771 /* Prepare to start a new fill from the beginning of the playlist */
1772 last_peek_offset = -1;
1773 if (audio_have_tracks())
1775 if (paused)
1776 skipped_during_pause = true;
1777 track_widx = track_ridx;
1778 audio_clear_track_entries();
1780 track_widx = (track_widx + 1) & MAX_TRACK_MASK;
1782 /* Mark the current track as invalid to prevent skipping back to it */
1783 CUR_TI->taginfo_ready = false;
1786 /* Signal the codec to initiate a track change forward */
1787 new_playlist = true;
1788 ci.new_track = 1;
1790 /* Officially playing */
1791 queue_reply(&audio_queue, 1);
1793 audio_fill_file_buffer(false, 0);
1796 /* Called on manual track skip */
1797 static void audio_initiate_track_change(long direction)
1799 logf("audio_initiate_track_change(%ld)", direction);
1801 ci.new_track += direction;
1802 wps_offset -= direction;
1803 if (paused)
1804 skipped_during_pause = true;
1807 /* Called on manual dir skip */
1808 static void audio_initiate_dir_change(long direction)
1810 dir_skip = true;
1811 ci.new_track = direction;
1812 if (paused)
1813 skipped_during_pause = true;
1816 /* Called when PCM track change is complete */
1817 static void audio_finalise_track_change(void)
1819 logf("audio_finalise_track_change");
1821 if (automatic_skip)
1823 wps_offset = 0;
1824 automatic_skip = false;
1826 /* Invalidate prevtrack_id3 */
1827 memset(othertrack_id3, 0, sizeof(struct mp3entry));
1829 if (prev_ti && prev_ti->audio_hid < 0)
1831 /* No audio left so we clear all the track info. */
1832 clear_track_info(prev_ti);
1835 send_event(PLAYBACK_EVENT_TRACK_CHANGE, thistrack_id3);
1836 playlist_update_resume_info(audio_current_track());
1840 * Layout audio buffer as follows - iram buffer depends on target:
1841 * [|SWAP:iram][|TALK]|FILE|GUARD|PCM|[SWAP:dram[|iram]|]
1843 static void audio_reset_buffer(void)
1845 /* see audio_get_recording_buffer if this is modified */
1846 logf("audio_reset_buffer");
1848 /* If the setup of anything allocated before the file buffer is
1849 changed, do check the adjustments after the buffer_alloc call
1850 as it will likely be affected and need sliding over */
1852 /* Initially set up file buffer as all space available */
1853 malloc_buf = audiobuf + talk_get_bufsize();
1854 /* Align the malloc buf to line size. Especially important to cf
1855 targets that do line reads/writes. */
1856 malloc_buf = (unsigned char *)(((uintptr_t)malloc_buf + 15) & ~15);
1857 filebuf = malloc_buf; /* filebuf line align implied */
1858 filebuflen = audiobufend - filebuf;
1860 filebuflen &= ~15;
1862 /* Subtract whatever the pcm buffer says it used plus the guard buffer */
1863 const size_t pcmbuf_size = pcmbuf_init(filebuf + filebuflen) +GUARD_BUFSIZE;
1865 #ifdef DEBUG
1866 if(pcmbuf_size > filebuflen)
1867 panicf("Not enough memory for pcmbuf_init() : %d > %d",
1868 (int)pcmbuf_size, (int)filebuflen);
1869 #endif
1871 filebuflen -= pcmbuf_size;
1873 /* Make sure filebuflen is a longword multiple after adjustment - filebuf
1874 will already be line aligned */
1875 filebuflen &= ~3;
1877 buffering_reset(filebuf, filebuflen);
1879 /* Clear any references to the file buffer */
1880 buffer_state = AUDIOBUF_STATE_INITIALIZED;
1882 #if defined(ROCKBOX_HAS_LOGF) && defined(LOGF_ENABLE)
1883 /* Make sure everything adds up - yes, some info is a bit redundant but
1884 aids viewing and the sumation of certain variables should add up to
1885 the location of others. */
1887 size_t pcmbufsize;
1888 const unsigned char *pcmbuf = pcmbuf_get_meminfo(&pcmbufsize);
1889 logf("mabuf: %08X", (unsigned)malloc_buf);
1890 logf("fbuf: %08X", (unsigned)filebuf);
1891 logf("fbufe: %08X", (unsigned)(filebuf + filebuflen));
1892 logf("gbuf: %08X", (unsigned)(filebuf + filebuflen));
1893 logf("gbufe: %08X", (unsigned)(filebuf + filebuflen + GUARD_BUFSIZE));
1894 logf("pcmb: %08X", (unsigned)pcmbuf);
1895 logf("pcmbe: %08X", (unsigned)(pcmbuf + pcmbufsize));
1897 #endif
1900 static void audio_thread(void)
1902 struct queue_event ev;
1904 pcm_postinit();
1906 audio_thread_ready = true;
1908 while (1)
1910 if (filling != STATE_FILLING && filling != STATE_IDLE) {
1911 /* End of buffering, let's calculate the watermark and unboost */
1912 set_filebuf_watermark();
1913 cancel_cpu_boost();
1916 if (!pcmbuf_queue_scan(&ev))
1917 queue_wait_w_tmo(&audio_queue, &ev, HZ/2);
1919 switch (ev.id) {
1921 case Q_AUDIO_FILL_BUFFER:
1922 LOGFQUEUE("audio < Q_AUDIO_FILL_BUFFER %d", (int)ev.data);
1923 audio_fill_file_buffer((bool)ev.data, 0);
1924 break;
1926 case Q_AUDIO_FINISH_LOAD:
1927 LOGFQUEUE("audio < Q_AUDIO_FINISH_LOAD");
1928 audio_finish_load_track();
1929 buf_set_base_handle(CUR_TI->audio_hid);
1930 break;
1932 case Q_AUDIO_PLAY:
1933 LOGFQUEUE("audio < Q_AUDIO_PLAY");
1934 if (playing && ev.data <= 0)
1935 audio_new_playlist();
1936 else
1938 audio_stop_playback();
1939 audio_play_start((size_t)ev.data);
1941 break;
1943 case Q_AUDIO_STOP:
1944 LOGFQUEUE("audio < Q_AUDIO_STOP");
1945 if (playing)
1946 audio_stop_playback();
1947 if (ev.data != 0)
1948 queue_clear(&audio_queue);
1949 break;
1951 case Q_AUDIO_PAUSE:
1952 LOGFQUEUE("audio < Q_AUDIO_PAUSE");
1953 if (!(bool) ev.data && skipped_during_pause
1954 #ifdef HAVE_CROSSFADE
1955 && !pcmbuf_is_crossfade_active()
1956 #endif
1958 pcmbuf_play_stop(); /* Flush old track on resume after skip */
1959 skipped_during_pause = false;
1960 if (!playing)
1961 break;
1962 pcmbuf_pause((bool)ev.data);
1963 paused = (bool)ev.data;
1964 break;
1966 case Q_AUDIO_SKIP:
1967 LOGFQUEUE("audio < Q_AUDIO_SKIP");
1968 audio_initiate_track_change((long)ev.data);
1969 break;
1971 case Q_AUDIO_PRE_FF_REWIND:
1972 LOGFQUEUE("audio < Q_AUDIO_PRE_FF_REWIND");
1973 if (!playing)
1974 break;
1975 pcmbuf_pause(true);
1976 break;
1978 case Q_AUDIO_FF_REWIND:
1979 LOGFQUEUE("audio < Q_AUDIO_FF_REWIND");
1980 if (!playing)
1981 break;
1982 if (automatic_skip)
1984 /* An automatic track skip is in progress. Finalize it,
1985 then go back to the previous track */
1986 audio_finalise_track_change();
1987 ci.new_track = -1;
1989 ci.seek_time = (long)ev.data+1;
1990 break;
1992 case Q_AUDIO_CHECK_NEW_TRACK:
1993 LOGFQUEUE("audio < Q_AUDIO_CHECK_NEW_TRACK");
1994 queue_reply(&audio_queue, audio_check_new_track());
1995 break;
1997 case Q_AUDIO_DIR_SKIP:
1998 LOGFQUEUE("audio < Q_AUDIO_DIR_SKIP");
1999 audio_initiate_dir_change(ev.data);
2000 break;
2002 case Q_AUDIO_FLUSH:
2003 LOGFQUEUE("audio < Q_AUDIO_FLUSH");
2004 audio_invalidate_tracks();
2005 break;
2007 case Q_AUDIO_TRACK_CHANGED:
2008 /* PCM track change done */
2009 LOGFQUEUE("audio < Q_AUDIO_TRACK_CHANGED");
2010 audio_finalise_track_change();
2011 break;
2012 #ifndef SIMULATOR
2013 case SYS_USB_CONNECTED:
2014 LOGFQUEUE("audio < SYS_USB_CONNECTED");
2015 if (playing)
2016 audio_stop_playback();
2017 #ifdef PLAYBACK_VOICE
2018 voice_stop();
2019 #endif
2020 usb_acknowledge(SYS_USB_CONNECTED_ACK);
2021 usb_wait_for_disconnect(&audio_queue);
2023 /* Mark all entries null. */
2024 audio_clear_track_entries();
2026 /* release tracks to make sure all handles are closed */
2027 audio_release_tracks();
2028 break;
2029 #endif
2031 case SYS_TIMEOUT:
2032 LOGFQUEUE_SYS_TIMEOUT("audio < SYS_TIMEOUT");
2033 break;
2035 default:
2036 /* LOGFQUEUE("audio < default : %08lX", ev.id); */
2037 break;
2038 } /* end switch */
2039 } /* end while */
2042 /* Initialize the audio system - called from init() in main.c.
2043 * Last function because of all the references to internal symbols
2045 void audio_init(void)
2047 unsigned int audio_thread_id;
2049 /* Can never do this twice */
2050 if (audio_is_initialized)
2052 logf("audio: already initialized");
2053 return;
2056 logf("audio: initializing");
2058 /* Initialize queues before giving control elsewhere in case it likes
2059 to send messages. Thread creation will be delayed however so nothing
2060 starts running until ready if something yields such as talk_init. */
2061 queue_init(&audio_queue, true);
2062 queue_init(&codec_queue, false);
2063 queue_init(&pcmbuf_queue, false);
2065 pcm_init();
2067 codec_init_codec_api();
2069 thistrack_id3 = &mp3entry_buf[0];
2070 othertrack_id3 = &mp3entry_buf[1];
2072 /* cuesheet support */
2073 if (global_settings.cuesheet)
2074 curr_cue = (struct cuesheet*)buffer_alloc(sizeof(struct cuesheet));
2076 /* initialize the buffer */
2077 filebuf = audiobuf;
2079 /* audio_reset_buffer must to know the size of voice buffer so init
2080 talk first */
2081 talk_init();
2083 make_codec_thread();
2085 audio_thread_id = create_thread(audio_thread, audio_stack,
2086 sizeof(audio_stack), CREATE_THREAD_FROZEN,
2087 audio_thread_name IF_PRIO(, PRIORITY_USER_INTERFACE)
2088 IF_COP(, CPU));
2090 queue_enable_queue_send(&audio_queue, &audio_queue_sender_list,
2091 audio_thread_id);
2093 #ifdef PLAYBACK_VOICE
2094 voice_thread_init();
2095 #endif
2097 #ifdef HAVE_CROSSFADE
2098 /* Set crossfade setting for next buffer init which should be about... */
2099 pcmbuf_request_crossfade_enable(global_settings.crossfade);
2100 #endif
2102 /* initialize the buffering system */
2104 buffering_init();
2105 /* ...now! Set up the buffers */
2106 audio_reset_buffer();
2108 int i;
2109 for(i = 0; i < MAX_TRACK; i++)
2111 tracks[i].audio_hid = -1;
2112 tracks[i].id3_hid = -1;
2113 tracks[i].codec_hid = -1;
2114 tracks[i].cuesheet_hid = -1;
2116 #ifdef HAVE_ALBUMART
2117 FOREACH_ALBUMART(i)
2119 int j;
2120 for (j = 0; j < MAX_TRACK; j++)
2122 tracks[j].aa_hid[i] = -1;
2125 #endif
2127 add_event(BUFFER_EVENT_REBUFFER, false, buffering_handle_rebuffer_callback);
2128 add_event(BUFFER_EVENT_FINISHED, false, buffering_handle_finished_callback);
2130 /* Probably safe to say */
2131 audio_is_initialized = true;
2133 sound_settings_apply();
2134 #ifdef HAVE_DISK_STORAGE
2135 audio_set_buffer_margin(global_settings.buffer_margin);
2136 #endif
2138 /* it's safe to let the threads run now */
2139 #ifdef PLAYBACK_VOICE
2140 voice_thread_resume();
2141 #endif
2142 thread_thaw(codec_thread_id);
2143 thread_thaw(audio_thread_id);
2145 } /* audio_init */
2147 bool audio_is_thread_ready(void)
2149 return audio_thread_ready;
2152 size_t audio_get_filebuflen(void)
2154 return filebuflen;
2157 int get_audio_hid()
2159 return CUR_TI->audio_hid;
2162 int *get_codec_hid()
2164 return &tracks[track_ridx].codec_hid;