Some formatting fixes, reported by Alexander Levin
[kugel-rb.git] / apps / playback.c
blobb7078441c2bd067adc98a087d4e4434c4eb5a52d
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 bool audio_peek_track(struct mp3entry* id3, int offset)
634 int next_idx;
635 int new_offset = ci.new_track + wps_offset + offset;
637 if (!audio_have_tracks())
638 return false;
639 next_idx = (track_ridx + new_offset) & MAX_TRACK_MASK;
641 if (tracks[next_idx].id3_hid >= 0)
643 return bufread(tracks[next_idx].id3_hid, sizeof(struct mp3entry), id3)
644 == sizeof(struct mp3entry);
646 return false;
649 #ifdef HAVE_ALBUMART
650 int playback_current_aa_hid(int slot)
652 if (slot < 0)
653 return -1;
654 int cur_idx;
655 int offset = ci.new_track + wps_offset;
657 cur_idx = track_ridx + offset;
658 cur_idx &= MAX_TRACK_MASK;
660 return tracks[cur_idx].aa_hid[slot];
663 int playback_claim_aa_slot(struct dim *dim)
665 int i;
666 /* first try to find a slot already having the size to reuse it
667 * since we don't want albumart of the same size buffered multiple times */
668 FOREACH_ALBUMART(i)
670 struct albumart_slot *slot = &albumart_slots[i];
671 if (slot->dim.width == dim->width
672 && slot->dim.height == dim->height)
674 slot->used++;
675 return i;
678 /* size is new, find a free slot */
679 FOREACH_ALBUMART(i)
681 if (!albumart_slots[i].used)
683 albumart_slots[i].used++;
684 albumart_slots[i].dim = *dim;
685 return i;
688 /* sorry, no free slot */
689 return -1;
692 void playback_release_aa_slot(int slot)
694 /* invalidate the albumart_slot */
695 struct albumart_slot *aa_slot = &albumart_slots[slot];
696 if (aa_slot->used > 0)
697 aa_slot->used--;
700 #endif
701 void audio_play(long offset)
703 logf("audio_play");
705 #ifdef PLAYBACK_VOICE
706 /* Truncate any existing voice output so we don't have spelling
707 * etc. over the first part of the played track */
708 talk_force_shutup();
709 #endif
711 /* Start playback */
712 LOGFQUEUE("audio >| audio Q_AUDIO_PLAY: %ld", offset);
713 /* Don't return until playback has actually started */
714 queue_send(&audio_queue, Q_AUDIO_PLAY, offset);
717 void audio_stop(void)
719 /* Stop playback */
720 LOGFQUEUE("audio >| audio Q_AUDIO_STOP");
721 /* Don't return until playback has actually stopped */
722 queue_send(&audio_queue, Q_AUDIO_STOP, 0);
725 void audio_pause(void)
727 LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE");
728 /* Don't return until playback has actually paused */
729 queue_send(&audio_queue, Q_AUDIO_PAUSE, true);
732 void audio_resume(void)
734 LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE resume");
735 /* Don't return until playback has actually resumed */
736 queue_send(&audio_queue, Q_AUDIO_PAUSE, false);
739 void audio_skip(int direction)
741 if (playlist_check(ci.new_track + wps_offset + direction))
743 if (global_settings.beep)
744 pcmbuf_beep(2000, 100, 2500*global_settings.beep);
746 LOGFQUEUE("audio > audio Q_AUDIO_SKIP %d", direction);
747 queue_post(&audio_queue, Q_AUDIO_SKIP, direction);
748 /* Update wps while our message travels inside deep playback queues. */
749 wps_offset += direction;
751 else
753 /* No more tracks. */
754 if (global_settings.beep)
755 pcmbuf_beep(1000, 100, 1500*global_settings.beep);
759 void audio_next(void)
761 audio_skip(1);
764 void audio_prev(void)
766 audio_skip(-1);
769 void audio_next_dir(void)
771 LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP 1");
772 queue_post(&audio_queue, Q_AUDIO_DIR_SKIP, 1);
775 void audio_prev_dir(void)
777 LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP -1");
778 queue_post(&audio_queue, Q_AUDIO_DIR_SKIP, -1);
781 void audio_pre_ff_rewind(void)
783 LOGFQUEUE("audio > audio Q_AUDIO_PRE_FF_REWIND");
784 queue_post(&audio_queue, Q_AUDIO_PRE_FF_REWIND, 0);
787 void audio_ff_rewind(long newpos)
789 LOGFQUEUE("audio > audio Q_AUDIO_FF_REWIND");
790 queue_post(&audio_queue, Q_AUDIO_FF_REWIND, newpos);
793 void audio_flush_and_reload_tracks(void)
795 LOGFQUEUE("audio > audio Q_AUDIO_FLUSH");
796 queue_post(&audio_queue, Q_AUDIO_FLUSH, 0);
799 void audio_error_clear(void)
801 #ifdef AUDIO_HAVE_RECORDING
802 pcm_rec_error_clear();
803 #endif
806 int audio_status(void)
808 int ret = 0;
810 if (playing)
811 ret |= AUDIO_STATUS_PLAY;
813 if (paused)
814 ret |= AUDIO_STATUS_PAUSE;
816 #ifdef HAVE_RECORDING
817 /* Do this here for constitency with mpeg.c version */
818 /* FIXME: pcm_rec_status() is deprecated */
819 ret |= pcm_rec_status();
820 #endif
822 return ret;
825 int audio_get_file_pos(void)
827 return 0;
830 #ifdef HAVE_DISK_STORAGE
831 void audio_set_buffer_margin(int setting)
833 static const unsigned short lookup[] = {5, 15, 30, 60, 120, 180, 300, 600};
834 buffer_margin = lookup[setting];
835 logf("buffer margin: %ld", (long)buffer_margin);
836 set_filebuf_watermark();
838 #endif
840 #ifdef HAVE_CROSSFADE
841 /* Take necessary steps to enable or disable the crossfade setting */
842 void audio_set_crossfade(int enable)
844 size_t offset;
845 bool was_playing;
846 size_t size;
848 /* Tell it the next setting to use */
849 pcmbuf_request_crossfade_enable(enable);
851 /* Return if size hasn't changed or this is too early to determine
852 which in the second case there's no way we could be playing
853 anything at all */
854 if (pcmbuf_is_same_size()) return;
856 offset = 0;
857 was_playing = playing;
859 /* Playback has to be stopped before changing the buffer size */
860 if (was_playing)
862 /* Store the track resume position */
863 offset = thistrack_id3->offset;
866 /* Blast it - audio buffer will have to be setup again next time
867 something plays */
868 audio_get_buffer(true, &size);
870 /* Restart playback if audio was running previously */
871 if (was_playing)
872 audio_play(offset);
874 #endif
876 /* --- Routines called from multiple threads --- */
878 static void set_filebuf_watermark(void)
880 if (!filebuf)
881 return; /* Audio buffers not yet set up */
883 #ifdef HAVE_DISK_STORAGE
884 int seconds;
885 int spinup = ata_spinup_time();
886 if (spinup)
887 seconds = (spinup / HZ) + 1;
888 else
889 seconds = 5;
891 seconds += buffer_margin;
892 #else
893 /* flash storage */
894 int seconds = 1;
895 #endif
897 /* bitrate of last track in buffer dictates watermark */
898 struct mp3entry* id3 = NULL;
899 if (tracks[track_widx].taginfo_ready)
900 id3 = bufgetid3(tracks[track_widx].id3_hid);
901 else
902 id3 = bufgetid3(tracks[track_widx-1].id3_hid);
903 if (!id3) {
904 logf("fwmark: No id3 for last track (r%d/w%d), aborting!", track_ridx, track_widx);
905 return;
907 size_t bytes = id3->bitrate * (1000/8) * seconds;
908 buf_set_watermark(bytes);
909 logf("fwmark: %d", bytes);
912 /* --- Buffering callbacks --- */
914 static void buffering_low_buffer_callback(void *data)
916 (void)data;
917 logf("low buffer callback");
919 if (filling == STATE_FULL || filling == STATE_END_OF_PLAYLIST) {
920 /* force a refill */
921 LOGFQUEUE("buffering > audio Q_AUDIO_FILL_BUFFER");
922 queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, 0);
926 static void buffering_handle_rebuffer_callback(void *data)
928 (void)data;
929 LOGFQUEUE("audio >| audio Q_AUDIO_FLUSH");
930 queue_post(&audio_queue, Q_AUDIO_FLUSH, 0);
933 static void buffering_handle_finished_callback(void *data)
935 logf("handle %d finished buffering", *(int*)data);
936 int hid = (*(int*)data);
938 if (hid == tracks[track_widx].id3_hid)
940 int offset = ci.new_track + wps_offset;
941 int next_idx = (track_ridx + offset + 1) & MAX_TRACK_MASK;
942 /* The metadata handle for the last loaded track has been buffered.
943 We can ask the audio thread to load the rest of the track's data. */
944 LOGFQUEUE("audio >| audio Q_AUDIO_FINISH_LOAD");
945 queue_post(&audio_queue, Q_AUDIO_FINISH_LOAD, 0);
946 if (tracks[next_idx].id3_hid == hid)
947 send_event(PLAYBACK_EVENT_NEXTTRACKID3_AVAILABLE, NULL);
949 else
951 /* This is most likely an audio handle, so we strip the useless
952 trailing tags that are left. */
953 strip_tags(hid);
955 if (hid == tracks[track_widx-1].audio_hid
956 && filling == STATE_END_OF_PLAYLIST)
958 /* This was the last track in the playlist.
959 We now have all the data we need. */
960 logf("last track finished buffering");
961 filling = STATE_FINISHED;
967 /* --- Audio thread --- */
969 static bool audio_have_tracks(void)
971 return (audio_track_count() != 0);
974 static int audio_free_track_count(void)
976 /* Used tracks + free tracks adds up to MAX_TRACK - 1 */
977 return MAX_TRACK - 1 - audio_track_count();
980 int audio_track_count(void)
982 /* Calculate difference from track_ridx to track_widx
983 * taking into account a possible wrap-around. */
984 return (MAX_TRACK + track_widx - track_ridx) & MAX_TRACK_MASK;
987 long audio_filebufused(void)
989 return (long) buf_used();
992 /* Update track info after successful a codec track change */
993 static void audio_update_trackinfo(void)
995 /* Load the curent track's metadata into curtrack_id3 */
996 if (CUR_TI->id3_hid >= 0)
997 copy_mp3entry(thistrack_id3, bufgetid3(CUR_TI->id3_hid));
999 /* Reset current position */
1000 thistrack_id3->elapsed = 0;
1001 thistrack_id3->offset = 0;
1003 /* Update the codec API */
1004 ci.filesize = CUR_TI->filesize;
1005 ci.id3 = thistrack_id3;
1006 ci.curpos = 0;
1007 ci.taginfo_ready = &CUR_TI->taginfo_ready;
1010 /* Clear tracks between write and read, non inclusive */
1011 static void audio_clear_track_entries(void)
1013 int cur_idx = track_widx;
1015 logf("Clearing tracks: r%d/w%d", track_ridx, track_widx);
1017 /* Loop over all tracks from write-to-read */
1018 while (1)
1020 cur_idx = (cur_idx + 1) & MAX_TRACK_MASK;
1022 if (cur_idx == track_ridx)
1023 break;
1025 clear_track_info(&tracks[cur_idx]);
1029 /* Clear all tracks */
1030 static bool audio_release_tracks(void)
1032 int i, cur_idx;
1034 logf("releasing all tracks");
1036 for(i = 0; i < MAX_TRACK; i++)
1038 cur_idx = (track_ridx + i) & MAX_TRACK_MASK;
1039 if (!clear_track_info(&tracks[cur_idx]))
1040 return false;
1043 return true;
1046 static bool audio_loadcodec(bool start_play)
1048 int prev_track;
1049 char codec_path[MAX_PATH]; /* Full path to codec */
1050 const struct mp3entry *id3, *prev_id3;
1052 if (tracks[track_widx].id3_hid < 0) {
1053 return false;
1056 id3 = bufgetid3(tracks[track_widx].id3_hid);
1057 if (!id3)
1058 return false;
1060 const char *codec_fn = get_codec_filename(id3->codectype);
1061 if (codec_fn == NULL)
1062 return false;
1064 tracks[track_widx].codec_hid = -1;
1066 if (start_play)
1068 /* Load the codec directly from disk and save some memory. */
1069 track_ridx = track_widx;
1070 ci.filesize = CUR_TI->filesize;
1071 ci.id3 = thistrack_id3;
1072 ci.taginfo_ready = &CUR_TI->taginfo_ready;
1073 ci.curpos = 0;
1074 LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK");
1075 queue_post(&codec_queue, Q_CODEC_LOAD_DISK, (intptr_t)codec_fn);
1076 return true;
1078 else
1080 /* If we already have another track than this one buffered */
1081 if (track_widx != track_ridx)
1083 prev_track = (track_widx - 1) & MAX_TRACK_MASK;
1085 id3 = bufgetid3(tracks[track_widx].id3_hid);
1086 prev_id3 = bufgetid3(tracks[prev_track].id3_hid);
1088 /* If the previous codec is the same as this one, there is no need
1089 * to put another copy of it on the file buffer */
1090 if (id3 && prev_id3 &&
1091 get_codec_base_type(id3->codectype) ==
1092 get_codec_base_type(prev_id3->codectype)
1093 && audio_codec_loaded)
1095 logf("Reusing prev. codec");
1096 return true;
1101 codec_get_full_path(codec_path, codec_fn);
1103 tracks[track_widx].codec_hid = bufopen(codec_path, 0, TYPE_CODEC, NULL);
1104 if (tracks[track_widx].codec_hid < 0)
1105 return false;
1107 logf("Loaded codec");
1109 return true;
1112 /* Load metadata for the next track (with bufopen). The rest of the track
1113 loading will be handled by audio_finish_load_track once the metadata has been
1114 actually loaded by the buffering thread. */
1115 static bool audio_load_track(size_t offset, bool start_play)
1117 const char *trackname;
1118 int fd = -1;
1120 if (track_load_started) {
1121 /* There is already a track load in progress, so track_widx hasn't been
1122 incremented yet. Loading another track would overwrite the one that
1123 hasn't finished loading. */
1124 logf("audio_load_track(): a track load is already in progress");
1125 return false;
1128 start_play_g = start_play; /* will be read by audio_finish_load_track */
1130 /* Stop buffer filling if there is no free track entries.
1131 Don't fill up the last track entry (we wan't to store next track
1132 metadata there). */
1133 if (!audio_free_track_count())
1135 logf("No free tracks");
1136 return false;
1139 last_peek_offset++;
1140 tracks[track_widx].taginfo_ready = false;
1142 logf("Buffering track: r%d/w%d", track_ridx, track_widx);
1143 /* Get track name from current playlist read position. */
1144 while ((trackname = playlist_peek(last_peek_offset)) != NULL)
1146 /* Handle broken playlists. */
1147 fd = open(trackname, O_RDONLY);
1148 if (fd < 0)
1150 logf("Open failed");
1151 /* Skip invalid entry from playlist. */
1152 playlist_skip_entry(NULL, last_peek_offset);
1154 else
1155 break;
1158 if (!trackname)
1160 logf("End-of-playlist");
1161 memset(&unbuffered_id3, 0, sizeof(struct mp3entry));
1162 filling = STATE_END_OF_PLAYLIST;
1164 if (thistrack_id3->length == 0 && thistrack_id3->filesize == 0)
1166 /* Stop playback if no valid track was found. */
1167 audio_stop_playback();
1170 return false;
1173 tracks[track_widx].filesize = filesize(fd);
1175 if (offset > tracks[track_widx].filesize)
1176 offset = 0;
1178 /* Set default values */
1179 if (start_play)
1181 buf_set_watermark(filebuflen/2);
1182 dsp_configure(ci.dsp, DSP_RESET, 0);
1183 playlist_update_resume_info(audio_current_track());
1186 /* Get track metadata if we don't already have it. */
1187 if (tracks[track_widx].id3_hid < 0)
1189 tracks[track_widx].id3_hid = bufopen(trackname, 0, TYPE_ID3, NULL);
1191 if (tracks[track_widx].id3_hid < 0)
1193 /* Buffer is full. */
1194 get_metadata(&unbuffered_id3, fd, trackname);
1195 last_peek_offset--;
1196 close(fd);
1197 logf("buffer is full for now (get metadata)");
1198 filling = STATE_FULL;
1199 return false;
1202 if (track_widx == track_ridx)
1204 /* TODO: Superfluos buffering call? */
1205 buf_request_buffer_handle(tracks[track_widx].id3_hid);
1206 struct mp3entry *id3 = bufgetid3(tracks[track_widx].id3_hid);
1207 if (id3)
1209 copy_mp3entry(thistrack_id3, id3);
1210 thistrack_id3->offset = offset;
1212 else
1213 memset(thistrack_id3, 0, sizeof(struct mp3entry));
1216 if (start_play)
1218 playlist_update_resume_info(audio_current_track());
1222 close(fd);
1223 track_load_started = true; /* Remember that we've started loading a track */
1224 return true;
1227 /* Second part of the track loading: We now have the metadata available, so we
1228 can load the codec, the album art and finally the audio data.
1229 This is called on the audio thread after the buffering thread calls the
1230 buffering_handle_finished_callback callback. */
1231 static void audio_finish_load_track(void)
1233 size_t file_offset = 0;
1234 size_t offset = 0;
1235 bool start_play = start_play_g;
1237 track_load_started = false;
1239 if (tracks[track_widx].id3_hid < 0) {
1240 logf("No metadata");
1241 return;
1244 struct mp3entry *track_id3;
1246 if (track_widx == track_ridx)
1247 track_id3 = thistrack_id3;
1248 else
1249 track_id3 = bufgetid3(tracks[track_widx].id3_hid);
1251 if (track_id3->length == 0 && track_id3->filesize == 0)
1253 logf("audio_finish_load_track: invalid metadata");
1255 /* Invalid metadata */
1256 bufclose(tracks[track_widx].id3_hid);
1257 tracks[track_widx].id3_hid = -1;
1259 /* Skip invalid entry from playlist. */
1260 playlist_skip_entry(NULL, last_peek_offset--);
1262 /* load next track */
1263 LOGFQUEUE("audio > audio Q_AUDIO_FILL_BUFFER %d", (int)start_play);
1264 queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, start_play);
1266 return;
1268 /* Try to load a cuesheet for the track */
1269 if (curr_cue)
1271 char cuepath[MAX_PATH];
1272 if (look_for_cuesheet_file(track_id3->path, cuepath))
1274 void *temp;
1275 tracks[track_widx].cuesheet_hid =
1276 bufalloc(NULL, sizeof(struct cuesheet), TYPE_CUESHEET);
1277 if (tracks[track_widx].cuesheet_hid >= 0)
1279 bufgetdata(tracks[track_widx].cuesheet_hid,
1280 sizeof(struct cuesheet), &temp);
1281 struct cuesheet *cuesheet = (struct cuesheet*)temp;
1282 if (!parse_cuesheet(cuepath, cuesheet))
1284 bufclose(tracks[track_widx].cuesheet_hid);
1285 track_id3->cuesheet = NULL;
1290 #ifdef HAVE_ALBUMART
1292 int i;
1293 char aa_path[MAX_PATH];
1294 FOREACH_ALBUMART(i)
1296 /* albumart_slots may change during a yield of bufopen,
1297 * but that's no problem */
1298 if (tracks[track_widx].aa_hid[i] >= 0 || !albumart_slots[i].used)
1299 continue;
1300 /* find_albumart will error out if the wps doesn't have AA */
1301 if (find_albumart(track_id3, aa_path, sizeof(aa_path),
1302 &(albumart_slots[i].dim)))
1304 int aa_hid = bufopen(aa_path, 0, TYPE_BITMAP,
1305 &(albumart_slots[i].dim));
1307 if(aa_hid == ERR_BUFFER_FULL)
1309 filling = STATE_FULL;
1310 logf("buffer is full for now (get album art)");
1311 return; /* No space for track's album art, not an error */
1313 else if (aa_hid < 0)
1315 /* another error, ignore AlbumArt */
1316 logf("Album art loading failed");
1318 tracks[track_widx].aa_hid[i] = aa_hid;
1323 #endif
1325 /* Load the codec. */
1326 if (!audio_loadcodec(start_play))
1328 if (tracks[track_widx].codec_hid == ERR_BUFFER_FULL)
1330 /* No space for codec on buffer, not an error */
1331 filling = STATE_FULL;
1332 return;
1335 /* This is an error condition, either no codec was found, or reading
1336 * the codec file failed part way through, either way, skip the track */
1337 /* FIXME: We should not use splashf from audio thread! */
1338 splashf(HZ*2, "No codec for: %s", track_id3->path);
1339 /* Skip invalid entry from playlist. */
1340 playlist_skip_entry(NULL, last_peek_offset);
1341 return;
1344 track_id3->elapsed = 0;
1345 offset = track_id3->offset;
1347 enum data_type type = TYPE_PACKET_AUDIO;
1349 switch (track_id3->codectype) {
1350 case AFMT_MPA_L1:
1351 case AFMT_MPA_L2:
1352 case AFMT_MPA_L3:
1353 if (offset > 0) {
1354 file_offset = offset;
1355 track_id3->offset = offset;
1357 break;
1359 case AFMT_WAVPACK:
1360 if (offset > 0) {
1361 file_offset = offset;
1362 track_id3->offset = offset;
1363 track_id3->elapsed = track_id3->length / 2;
1365 break;
1367 case AFMT_OGG_VORBIS:
1368 case AFMT_SPEEX:
1369 case AFMT_FLAC:
1370 case AFMT_PCM_WAV:
1371 case AFMT_A52:
1372 case AFMT_MP4_AAC:
1373 case AFMT_MPC:
1374 case AFMT_APE:
1375 case AFMT_WMA:
1376 if (offset > 0)
1377 track_id3->offset = offset;
1378 break;
1380 case AFMT_NSF:
1381 case AFMT_SPC:
1382 case AFMT_SID:
1383 logf("Loading atomic %d",track_id3->codectype);
1384 type = TYPE_ATOMIC_AUDIO;
1385 break;
1388 logf("load track: %s", track_id3->path);
1390 if (file_offset > AUDIO_REBUFFER_GUESS_SIZE)
1391 file_offset -= AUDIO_REBUFFER_GUESS_SIZE;
1392 else if (track_id3->first_frame_offset)
1393 file_offset = track_id3->first_frame_offset;
1394 else
1395 file_offset = 0;
1397 tracks[track_widx].audio_hid = bufopen(track_id3->path, file_offset, type,
1398 NULL);
1400 /* No space left, not an error */
1401 if (tracks[track_widx].audio_hid == ERR_BUFFER_FULL)
1403 filling = STATE_FULL;
1404 logf("buffer is full for now (load audio)");
1405 return;
1407 else if (tracks[track_widx].audio_hid < 0)
1409 /* another error, do not continue either */
1410 logf("Could not add audio data handle");
1411 return;
1414 /* All required data is now available for the codec. */
1415 tracks[track_widx].taginfo_ready = true;
1417 if (start_play)
1419 ci.curpos=file_offset;
1420 buf_request_buffer_handle(tracks[track_widx].audio_hid);
1423 track_widx = (track_widx + 1) & MAX_TRACK_MASK;
1425 send_event(PLAYBACK_EVENT_TRACK_BUFFER, track_id3);
1427 /* load next track */
1428 LOGFQUEUE("audio > audio Q_AUDIO_FILL_BUFFER");
1429 queue_post(&audio_queue, Q_AUDIO_FILL_BUFFER, 0);
1431 return;
1434 static void audio_fill_file_buffer(bool start_play, size_t offset)
1436 trigger_cpu_boost();
1438 /* No need to rebuffer if there are track skips pending,
1439 * however don't cancel buffering on skipping while filling. */
1440 if (ci.new_track != 0 && filling != STATE_FILLING)
1441 return;
1442 filling = STATE_FILLING;
1444 /* Must reset the buffer before use if trashed or voice only - voice
1445 file size shouldn't have changed so we can go straight from
1446 AUDIOBUF_STATE_VOICED_ONLY to AUDIOBUF_STATE_INITIALIZED */
1447 if (buffer_state != AUDIOBUF_STATE_INITIALIZED)
1448 audio_reset_buffer();
1450 logf("Starting buffer fill");
1452 if (!start_play)
1453 audio_clear_track_entries();
1455 /* Save the current resume position once. */
1456 playlist_update_resume_info(audio_current_track());
1458 audio_load_track(offset, start_play);
1461 static void audio_rebuffer(void)
1463 logf("Forcing rebuffer");
1465 clear_track_info(CUR_TI);
1467 /* Reset track pointers */
1468 track_widx = track_ridx;
1469 audio_clear_track_entries();
1471 /* Reset a possibly interrupted track load */
1472 track_load_started = false;
1474 /* Fill the buffer */
1475 last_peek_offset = -1;
1476 ci.curpos = 0;
1478 if (!CUR_TI->taginfo_ready)
1479 memset(thistrack_id3, 0, sizeof(struct mp3entry));
1481 audio_fill_file_buffer(false, 0);
1484 /* Called on request from the codec to get a new track. This is the codec part
1485 of the track transition. */
1486 static int audio_check_new_track(void)
1488 int track_count = audio_track_count();
1489 int old_track_ridx = track_ridx;
1490 int i, idx;
1491 bool forward;
1492 struct mp3entry *temp = thistrack_id3;
1494 /* Now it's good time to send track finish events. */
1495 send_event(PLAYBACK_EVENT_TRACK_FINISH, thistrack_id3);
1496 /* swap the mp3entry pointers */
1497 thistrack_id3 = othertrack_id3;
1498 othertrack_id3 = temp;
1499 ci.id3 = thistrack_id3;
1500 memset(thistrack_id3, 0, sizeof(struct mp3entry));
1502 if (dir_skip)
1504 dir_skip = false;
1505 /* regardless of the return value we need to rebuffer.
1506 if it fails the old playlist will resume, else the
1507 next dir will start playing */
1508 playlist_next_dir(ci.new_track);
1509 ci.new_track = 0;
1510 audio_rebuffer();
1511 goto skip_done;
1514 if (new_playlist)
1515 ci.new_track = 0;
1517 /* If the playlist isn't that big */
1518 if (automatic_skip)
1520 while (!playlist_check(ci.new_track))
1522 if (ci.new_track >= 0)
1524 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1525 return Q_CODEC_REQUEST_FAILED;
1527 ci.new_track++;
1531 /* Update the playlist */
1532 last_peek_offset -= ci.new_track;
1534 if (playlist_next(ci.new_track) < 0)
1536 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1537 return Q_CODEC_REQUEST_FAILED;
1540 if (new_playlist)
1542 ci.new_track = 1;
1543 new_playlist = false;
1546 /* Save a pointer to the old track to allow later clearing */
1547 prev_ti = CUR_TI;
1549 for (i = 0; i < ci.new_track; i++)
1551 idx = (track_ridx + i) & MAX_TRACK_MASK;
1552 struct mp3entry *id3 = bufgetid3(tracks[idx].id3_hid);
1553 ssize_t offset = buf_handle_offset(tracks[idx].audio_hid);
1554 if (!id3 || offset < 0 || (unsigned)offset > id3->first_frame_offset)
1556 /* We don't have all the audio data for that track, so clear it,
1557 but keep the metadata. */
1558 if (tracks[idx].audio_hid >= 0 && bufclose(tracks[idx].audio_hid))
1560 tracks[idx].audio_hid = -1;
1561 tracks[idx].filesize = 0;
1566 /* Move to the new track */
1567 track_ridx = (track_ridx + ci.new_track) & MAX_TRACK_MASK;
1570 if (automatic_skip)
1572 wps_offset = -ci.new_track;
1575 /* If it is not safe to even skip this many track entries */
1576 if (ci.new_track >= track_count || ci.new_track <= track_count - MAX_TRACK)
1578 ci.new_track = 0;
1579 audio_rebuffer();
1580 goto skip_done;
1583 forward = ci.new_track > 0;
1584 ci.new_track = 0;
1586 /* If the target track is clearly not in memory */
1587 if (CUR_TI->filesize == 0 || !CUR_TI->taginfo_ready)
1589 audio_rebuffer();
1590 goto skip_done;
1593 /* When skipping backwards, it is possible that we've found a track that's
1594 * buffered, but which is around the track-wrap and therefore not the track
1595 * we are looking for */
1596 if (!forward)
1598 int cur_idx = track_ridx;
1599 bool taginfo_ready = true;
1600 /* We've wrapped the buffer backwards if new > old */
1601 bool wrap = track_ridx > old_track_ridx;
1603 while (1)
1605 cur_idx = (cur_idx + 1) & MAX_TRACK_MASK;
1607 /* if we've advanced past the wrap when cur_idx is zeroed */
1608 if (!cur_idx)
1609 wrap = false;
1611 /* if we aren't still on the wrap and we've caught the old track */
1612 if (!(wrap || cur_idx < old_track_ridx))
1613 break;
1615 /* If we hit a track in between without valid tag info, bail */
1616 if (!tracks[cur_idx].taginfo_ready)
1618 taginfo_ready = false;
1619 break;
1622 if (!taginfo_ready)
1624 audio_rebuffer();
1628 skip_done:
1629 audio_update_trackinfo();
1630 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_COMPLETE");
1631 return Q_CODEC_REQUEST_COMPLETE;
1634 unsigned long audio_prev_elapsed(void)
1636 return prev_track_elapsed;
1639 void audio_set_prev_elapsed(unsigned long setting)
1641 prev_track_elapsed = setting;
1644 static void audio_stop_codec_flush(void)
1646 ci.stop_codec = true;
1647 pcmbuf_pause(true);
1649 while (audio_codec_loaded)
1650 yield();
1652 /* If the audio codec is not loaded any more, and the audio is still
1653 * playing, it is now and _only_ now safe to call this function from the
1654 * audio thread */
1655 if (pcm_is_playing())
1657 pcmbuf_play_stop();
1658 pcm_play_lock();
1659 queue_clear(&pcmbuf_queue);
1660 pcm_play_unlock();
1662 pcmbuf_pause(paused);
1665 static void audio_stop_playback(void)
1667 if (playing)
1669 /* If we were playing, save resume information */
1670 struct mp3entry *id3 = NULL;
1672 if (!ci.stop_codec)
1674 /* Set this early, the outside code yields and may allow the codec
1675 to try to wait for a reply on a buffer wait */
1676 ci.stop_codec = true;
1677 id3 = audio_current_track();
1680 /* Save the current playing spot, or NULL if the playlist has ended */
1681 playlist_update_resume_info(id3);
1683 /* TODO: Create auto bookmark too? */
1685 prev_track_elapsed = othertrack_id3->elapsed;
1687 remove_event(BUFFER_EVENT_BUFFER_LOW, buffering_low_buffer_callback);
1690 audio_stop_codec_flush();
1691 paused = false;
1692 playing = false;
1693 track_load_started = false;
1695 filling = STATE_IDLE;
1697 /* Mark all entries null. */
1698 audio_clear_track_entries();
1700 /* Close all tracks */
1701 audio_release_tracks();
1704 static void audio_play_start(size_t offset)
1706 int i;
1708 #if INPUT_SRC_CAPS != 0
1709 audio_set_input_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK);
1710 audio_set_output_source(AUDIO_SRC_PLAYBACK);
1711 #endif
1713 /* Wait for any previously playing audio to flush - TODO: Not necessary? */
1714 paused = false;
1715 audio_stop_codec_flush();
1717 playing = true;
1718 track_load_started = false;
1720 ci.new_track = 0;
1721 ci.seek_time = 0;
1722 wps_offset = 0;
1724 sound_set_volume(global_settings.volume);
1725 track_widx = track_ridx = 0;
1727 /* Clear all track entries. */
1728 for (i = 0; i < MAX_TRACK; i++) {
1729 clear_track_info(&tracks[i]);
1732 last_peek_offset = -1;
1734 /* Officially playing */
1735 queue_reply(&audio_queue, 1);
1737 audio_fill_file_buffer(true, offset);
1739 add_event(BUFFER_EVENT_BUFFER_LOW, false, buffering_low_buffer_callback);
1741 LOGFQUEUE("audio > audio Q_AUDIO_TRACK_CHANGED");
1742 queue_post(&audio_queue, Q_AUDIO_TRACK_CHANGED, 0);
1746 /* Invalidates all but currently playing track. */
1747 static void audio_invalidate_tracks(void)
1749 if (audio_have_tracks())
1751 last_peek_offset = 0;
1752 track_widx = track_ridx;
1754 /* Mark all other entries null (also buffered wrong metadata). */
1755 audio_clear_track_entries();
1757 track_widx = (track_widx + 1) & MAX_TRACK_MASK;
1759 audio_fill_file_buffer(false, 0);
1763 static void audio_new_playlist(void)
1765 /* Prepare to start a new fill from the beginning of the playlist */
1766 last_peek_offset = -1;
1767 if (audio_have_tracks())
1769 if (paused)
1770 skipped_during_pause = true;
1771 track_widx = track_ridx;
1772 audio_clear_track_entries();
1774 track_widx = (track_widx + 1) & MAX_TRACK_MASK;
1776 /* Mark the current track as invalid to prevent skipping back to it */
1777 CUR_TI->taginfo_ready = false;
1780 /* Signal the codec to initiate a track change forward */
1781 new_playlist = true;
1782 ci.new_track = 1;
1784 /* Officially playing */
1785 queue_reply(&audio_queue, 1);
1787 audio_fill_file_buffer(false, 0);
1790 /* Called on manual track skip */
1791 static void audio_initiate_track_change(long direction)
1793 logf("audio_initiate_track_change(%ld)", direction);
1795 ci.new_track += direction;
1796 wps_offset -= direction;
1797 if (paused)
1798 skipped_during_pause = true;
1801 /* Called on manual dir skip */
1802 static void audio_initiate_dir_change(long direction)
1804 dir_skip = true;
1805 ci.new_track = direction;
1806 if (paused)
1807 skipped_during_pause = true;
1810 /* Called when PCM track change is complete */
1811 static void audio_finalise_track_change(void)
1813 logf("audio_finalise_track_change");
1815 if (automatic_skip)
1817 wps_offset = 0;
1818 automatic_skip = false;
1820 /* Invalidate prevtrack_id3 */
1821 memset(othertrack_id3, 0, sizeof(struct mp3entry));
1823 if (prev_ti && prev_ti->audio_hid < 0)
1825 /* No audio left so we clear all the track info. */
1826 clear_track_info(prev_ti);
1829 send_event(PLAYBACK_EVENT_TRACK_CHANGE, thistrack_id3);
1830 playlist_update_resume_info(audio_current_track());
1834 * Layout audio buffer as follows - iram buffer depends on target:
1835 * [|SWAP:iram][|TALK]|FILE|GUARD|PCM|[SWAP:dram[|iram]|]
1837 static void audio_reset_buffer(void)
1839 /* see audio_get_recording_buffer if this is modified */
1840 logf("audio_reset_buffer");
1842 /* If the setup of anything allocated before the file buffer is
1843 changed, do check the adjustments after the buffer_alloc call
1844 as it will likely be affected and need sliding over */
1846 /* Initially set up file buffer as all space available */
1847 malloc_buf = audiobuf + talk_get_bufsize();
1848 /* Align the malloc buf to line size. Especially important to cf
1849 targets that do line reads/writes. */
1850 malloc_buf = (unsigned char *)(((uintptr_t)malloc_buf + 15) & ~15);
1851 filebuf = malloc_buf; /* filebuf line align implied */
1852 filebuflen = audiobufend - filebuf;
1854 filebuflen &= ~15;
1856 /* Subtract whatever the pcm buffer says it used plus the guard buffer */
1857 const size_t pcmbuf_size = pcmbuf_init(filebuf + filebuflen) +GUARD_BUFSIZE;
1859 #ifdef DEBUG
1860 if(pcmbuf_size > filebuflen)
1861 panicf("Not enough memory for pcmbuf_init() : %d > %d",
1862 (int)pcmbuf_size, (int)filebuflen);
1863 #endif
1865 filebuflen -= pcmbuf_size;
1867 /* Make sure filebuflen is a longword multiple after adjustment - filebuf
1868 will already be line aligned */
1869 filebuflen &= ~3;
1871 buffering_reset(filebuf, filebuflen);
1873 /* Clear any references to the file buffer */
1874 buffer_state = AUDIOBUF_STATE_INITIALIZED;
1876 #if defined(ROCKBOX_HAS_LOGF) && defined(LOGF_ENABLE)
1877 /* Make sure everything adds up - yes, some info is a bit redundant but
1878 aids viewing and the sumation of certain variables should add up to
1879 the location of others. */
1881 size_t pcmbufsize;
1882 const unsigned char *pcmbuf = pcmbuf_get_meminfo(&pcmbufsize);
1883 logf("mabuf: %08X", (unsigned)malloc_buf);
1884 logf("fbuf: %08X", (unsigned)filebuf);
1885 logf("fbufe: %08X", (unsigned)(filebuf + filebuflen));
1886 logf("gbuf: %08X", (unsigned)(filebuf + filebuflen));
1887 logf("gbufe: %08X", (unsigned)(filebuf + filebuflen + GUARD_BUFSIZE));
1888 logf("pcmb: %08X", (unsigned)pcmbuf);
1889 logf("pcmbe: %08X", (unsigned)(pcmbuf + pcmbufsize));
1891 #endif
1894 static void audio_thread(void)
1896 struct queue_event ev;
1898 pcm_postinit();
1900 audio_thread_ready = true;
1902 while (1)
1904 if (filling != STATE_FILLING && filling != STATE_IDLE) {
1905 /* End of buffering, let's calculate the watermark and unboost */
1906 set_filebuf_watermark();
1907 cancel_cpu_boost();
1910 if (!pcmbuf_queue_scan(&ev))
1911 queue_wait_w_tmo(&audio_queue, &ev, HZ/2);
1913 switch (ev.id) {
1915 case Q_AUDIO_FILL_BUFFER:
1916 LOGFQUEUE("audio < Q_AUDIO_FILL_BUFFER %d", (int)ev.data);
1917 audio_fill_file_buffer((bool)ev.data, 0);
1918 break;
1920 case Q_AUDIO_FINISH_LOAD:
1921 LOGFQUEUE("audio < Q_AUDIO_FINISH_LOAD");
1922 audio_finish_load_track();
1923 buf_set_base_handle(CUR_TI->audio_hid);
1924 break;
1926 case Q_AUDIO_PLAY:
1927 LOGFQUEUE("audio < Q_AUDIO_PLAY");
1928 if (playing && ev.data <= 0)
1929 audio_new_playlist();
1930 else
1932 audio_stop_playback();
1933 audio_play_start((size_t)ev.data);
1935 break;
1937 case Q_AUDIO_STOP:
1938 LOGFQUEUE("audio < Q_AUDIO_STOP");
1939 if (playing)
1940 audio_stop_playback();
1941 if (ev.data != 0)
1942 queue_clear(&audio_queue);
1943 break;
1945 case Q_AUDIO_PAUSE:
1946 LOGFQUEUE("audio < Q_AUDIO_PAUSE");
1947 if (!(bool) ev.data && skipped_during_pause
1948 #ifdef HAVE_CROSSFADE
1949 && !pcmbuf_is_crossfade_active()
1950 #endif
1952 pcmbuf_play_stop(); /* Flush old track on resume after skip */
1953 skipped_during_pause = false;
1954 if (!playing)
1955 break;
1956 pcmbuf_pause((bool)ev.data);
1957 paused = (bool)ev.data;
1958 break;
1960 case Q_AUDIO_SKIP:
1961 LOGFQUEUE("audio < Q_AUDIO_SKIP");
1962 audio_initiate_track_change((long)ev.data);
1963 break;
1965 case Q_AUDIO_PRE_FF_REWIND:
1966 LOGFQUEUE("audio < Q_AUDIO_PRE_FF_REWIND");
1967 if (!playing)
1968 break;
1969 pcmbuf_pause(true);
1970 break;
1972 case Q_AUDIO_FF_REWIND:
1973 LOGFQUEUE("audio < Q_AUDIO_FF_REWIND");
1974 if (!playing)
1975 break;
1976 if (automatic_skip)
1978 /* An automatic track skip is in progress. Finalize it,
1979 then go back to the previous track */
1980 audio_finalise_track_change();
1981 ci.new_track = -1;
1983 ci.seek_time = (long)ev.data+1;
1984 break;
1986 case Q_AUDIO_CHECK_NEW_TRACK:
1987 LOGFQUEUE("audio < Q_AUDIO_CHECK_NEW_TRACK");
1988 queue_reply(&audio_queue, audio_check_new_track());
1989 break;
1991 case Q_AUDIO_DIR_SKIP:
1992 LOGFQUEUE("audio < Q_AUDIO_DIR_SKIP");
1993 audio_initiate_dir_change(ev.data);
1994 break;
1996 case Q_AUDIO_FLUSH:
1997 LOGFQUEUE("audio < Q_AUDIO_FLUSH");
1998 audio_invalidate_tracks();
1999 break;
2001 case Q_AUDIO_TRACK_CHANGED:
2002 /* PCM track change done */
2003 LOGFQUEUE("audio < Q_AUDIO_TRACK_CHANGED");
2004 audio_finalise_track_change();
2005 break;
2006 #ifndef SIMULATOR
2007 case SYS_USB_CONNECTED:
2008 LOGFQUEUE("audio < SYS_USB_CONNECTED");
2009 if (playing)
2010 audio_stop_playback();
2011 #ifdef PLAYBACK_VOICE
2012 voice_stop();
2013 #endif
2014 usb_acknowledge(SYS_USB_CONNECTED_ACK);
2015 usb_wait_for_disconnect(&audio_queue);
2017 /* Mark all entries null. */
2018 audio_clear_track_entries();
2020 /* release tracks to make sure all handles are closed */
2021 audio_release_tracks();
2022 break;
2023 #endif
2025 case SYS_TIMEOUT:
2026 LOGFQUEUE_SYS_TIMEOUT("audio < SYS_TIMEOUT");
2027 break;
2029 default:
2030 /* LOGFQUEUE("audio < default : %08lX", ev.id); */
2031 break;
2032 } /* end switch */
2033 } /* end while */
2036 /* Initialize the audio system - called from init() in main.c.
2037 * Last function because of all the references to internal symbols
2039 void audio_init(void)
2041 unsigned int audio_thread_id;
2043 /* Can never do this twice */
2044 if (audio_is_initialized)
2046 logf("audio: already initialized");
2047 return;
2050 logf("audio: initializing");
2052 /* Initialize queues before giving control elsewhere in case it likes
2053 to send messages. Thread creation will be delayed however so nothing
2054 starts running until ready if something yields such as talk_init. */
2055 queue_init(&audio_queue, true);
2056 queue_init(&codec_queue, false);
2057 queue_init(&pcmbuf_queue, false);
2059 pcm_init();
2061 codec_init_codec_api();
2063 thistrack_id3 = &mp3entry_buf[0];
2064 othertrack_id3 = &mp3entry_buf[1];
2066 /* cuesheet support */
2067 if (global_settings.cuesheet)
2068 curr_cue = (struct cuesheet*)buffer_alloc(sizeof(struct cuesheet));
2070 /* initialize the buffer */
2071 filebuf = audiobuf;
2073 /* audio_reset_buffer must to know the size of voice buffer so init
2074 talk first */
2075 talk_init();
2077 make_codec_thread();
2079 audio_thread_id = create_thread(audio_thread, audio_stack,
2080 sizeof(audio_stack), CREATE_THREAD_FROZEN,
2081 audio_thread_name IF_PRIO(, PRIORITY_USER_INTERFACE)
2082 IF_COP(, CPU));
2084 queue_enable_queue_send(&audio_queue, &audio_queue_sender_list,
2085 audio_thread_id);
2087 #ifdef PLAYBACK_VOICE
2088 voice_thread_init();
2089 #endif
2091 #ifdef HAVE_CROSSFADE
2092 /* Set crossfade setting for next buffer init which should be about... */
2093 pcmbuf_request_crossfade_enable(global_settings.crossfade);
2094 #endif
2096 /* initialize the buffering system */
2098 buffering_init();
2099 /* ...now! Set up the buffers */
2100 audio_reset_buffer();
2102 int i;
2103 for(i = 0; i < MAX_TRACK; i++)
2105 tracks[i].audio_hid = -1;
2106 tracks[i].id3_hid = -1;
2107 tracks[i].codec_hid = -1;
2108 tracks[i].cuesheet_hid = -1;
2110 #ifdef HAVE_ALBUMART
2111 FOREACH_ALBUMART(i)
2113 int j;
2114 for (j = 0; j < MAX_TRACK; j++)
2116 tracks[j].aa_hid[i] = -1;
2119 #endif
2121 add_event(BUFFER_EVENT_REBUFFER, false, buffering_handle_rebuffer_callback);
2122 add_event(BUFFER_EVENT_FINISHED, false, buffering_handle_finished_callback);
2124 /* Probably safe to say */
2125 audio_is_initialized = true;
2127 sound_settings_apply();
2128 #ifdef HAVE_DISK_STORAGE
2129 audio_set_buffer_margin(global_settings.buffer_margin);
2130 #endif
2132 /* it's safe to let the threads run now */
2133 #ifdef PLAYBACK_VOICE
2134 voice_thread_resume();
2135 #endif
2136 thread_thaw(codec_thread_id);
2137 thread_thaw(audio_thread_id);
2139 } /* audio_init */
2141 bool audio_is_thread_ready(void)
2143 return audio_thread_ready;
2146 size_t audio_get_filebuflen(void)
2148 return filebuflen;
2151 int get_audio_hid()
2153 return CUR_TI->audio_hid;
2156 int *get_codec_hid()
2158 return &tracks[track_ridx].codec_hid;