1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
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 */
28 #include "codec_thread.h"
31 #include "buffering.h"
32 #include "voice_thread.h"
42 #ifdef HAVE_LCD_BITMAP
54 #include "pcm_record.h"
57 #define PLAYBACK_VOICE
59 /* amount of guess-space to allow for codecs that must hunt and peck
60 * for their correct seeek target, 32k seems a good size */
61 #define AUDIO_REBUFFER_GUESS_SIZE (1024*32)
63 /* Define LOGF_ENABLE to enable logf output in this file */
64 /*#define LOGF_ENABLE*/
67 /* macros to enable logf for queues
68 logging on SYS_TIMEOUT can be disabled */
70 /* Define this for logf output of all queuing except SYS_TIMEOUT */
71 #define PLAYBACK_LOGQUEUES
72 /* Define this to logf SYS_TIMEOUT messages */
73 /*#define PLAYBACK_LOGQUEUES_SYS_TIMEOUT*/
76 #ifdef PLAYBACK_LOGQUEUES
77 #define LOGFQUEUE logf
79 #define LOGFQUEUE(...)
82 #ifdef PLAYBACK_LOGQUEUES_SYS_TIMEOUT
83 #define LOGFQUEUE_SYS_TIMEOUT logf
85 #define LOGFQUEUE_SYS_TIMEOUT(...)
89 static enum filling_state
{
90 STATE_IDLE
, /* audio is stopped: nothing to do */
91 STATE_FILLING
, /* adding tracks to the buffer */
92 STATE_FULL
, /* can't add any more tracks */
93 STATE_END_OF_PLAYLIST
, /* all remaining tracks have been added */
94 STATE_FINISHED
, /* all remaining tracks are fully buffered */
97 /* As defined in plugins/lib/xxx2wav.h */
98 #define GUARD_BUFSIZE (32*1024)
100 bool audio_is_initialized
= false;
101 static bool audio_thread_ready SHAREDBSS_ATTR
= false;
103 /* Variables are commented with the threads that use them: *
104 * A=audio, C=codec, V=voice. A suffix of - indicates that *
105 * the variable is read but not updated on that thread. */
106 /* TBD: Split out "audio" and "playback" (ie. calling) threads */
108 /* Main state control */
109 static volatile bool playing SHAREDBSS_ATTR
= false;/* Is audio playing? (A) */
110 static volatile bool paused SHAREDBSS_ATTR
= false; /* Is audio paused? (A/C-) */
111 extern volatile bool audio_codec_loaded
; /* Codec loaded? (C/A-) */
113 /* Ring buffer where compressed audio and codecs are loaded */
114 static unsigned char *filebuf
= NULL
; /* Start of buffer (A/C-) */
115 static unsigned char *malloc_buf
= NULL
; /* Start of malloc buffer (A/C-) */
116 static size_t filebuflen
= 0; /* Size of buffer (A/C-) */
117 /* FIXME: make buf_ridx (C/A-) */
119 /* Possible arrangements of the buffer */
120 enum audio_buffer_state
122 AUDIOBUF_STATE_TRASHED
= -1, /* trashed; must be reset */
123 AUDIOBUF_STATE_INITIALIZED
= 0, /* voice+audio OR audio-only */
124 AUDIOBUF_STATE_VOICED_ONLY
= 1, /* voice-only */
126 static int buffer_state
= AUDIOBUF_STATE_TRASHED
; /* Buffer state */
128 /* These are used to store the current and next (or prev if the current is the last)
129 * mp3entry's in a round-robin system. This guarentees that the pointer returned
130 * by audio_current/next_track will be valid for the full duration of the
131 * currently playing track */
132 static struct mp3entry mp3entry_buf
[2];
133 struct mp3entry
*thistrack_id3
, /* the currently playing track */
134 *othertrack_id3
; /* prev track during track-change-transition, or end of playlist,
135 * next track otherwise */
136 static struct mp3entry unbuffered_id3
; /* the id3 for the first unbuffered track */
138 /* for cuesheet support */
139 static struct cuesheet
*curr_cue
= NULL
;
142 #define MAX_MULTIPLE_AA SKINNABLE_SCREENS_COUNT
146 static struct albumart_slot
{
147 struct dim dim
; /* holds width, height of the albumart */
148 int used
; /* counter, increments if something uses it */
149 } albumart_slots
[MAX_MULTIPLE_AA
];
151 #define FOREACH_ALBUMART(i) for(i = 0;i < MAX_MULTIPLE_AA; i++)
155 #define MAX_TRACK 128
156 #define MAX_TRACK_MASK (MAX_TRACK-1)
158 /* Track info structure about songs in the file buffer (A/C-) */
159 static struct track_info
{
160 int audio_hid
; /* The ID for the track's buffer handle */
161 int id3_hid
; /* The ID for the track's metadata handle */
162 int codec_hid
; /* The ID for the track's codec handle */
164 int aa_hid
[MAX_MULTIPLE_AA
];/* The ID for the track's album art handle */
166 int cuesheet_hid
; /* The ID for the track's parsed cueesheet handle */
168 size_t filesize
; /* File total length */
170 bool taginfo_ready
; /* Is metadata read */
174 static volatile int track_ridx
= 0; /* Track being decoded (A/C-) */
175 static int track_widx
= 0; /* Track being buffered (A) */
176 #define CUR_TI (&tracks[track_ridx]) /* Playing track info pointer (A/C-) */
178 static struct track_info
*prev_ti
= NULL
; /* Pointer to the previously played
181 /* Information used only for filling the buffer */
182 /* Playlist steps from playing track to next track to be buffered (A) */
183 static int last_peek_offset
= 0;
185 /* Scrobbler support */
186 static unsigned long prev_track_elapsed
= 0; /* Previous track elapsed time (C/A-)*/
188 /* Track change controls */
189 bool automatic_skip
= false; /* Who initiated in-progress skip? (C/A-) */
190 extern bool track_transition
; /* Are we in a track transition? */
191 static bool dir_skip
= false; /* Is a directory skip pending? (A) */
192 static bool new_playlist
= false; /* Are we starting a new playlist? (A) */
193 static int wps_offset
= 0; /* Pending track change offset, to keep WPS responsive (A) */
194 static bool skipped_during_pause
= false; /* Do we need to clear the PCM buffer when playback resumes (A) */
196 static bool start_play_g
= false; /* Used by audio_load_track to notify
197 audio_finish_load_track about start_play */
199 /* True when a track load is in progress, i.e. audio_load_track() has returned
200 * but audio_finish_load_track() hasn't been called yet. Used to avoid allowing
201 * audio_load_track() to get called twice in a row, which would cause problems.
203 static bool track_load_started
= false;
205 #ifdef HAVE_DISK_STORAGE
206 static size_t buffer_margin
= 5; /* Buffer margin aka anti-skip buffer (A/C-) */
210 struct event_queue audio_queue SHAREDBSS_ATTR
;
211 struct event_queue codec_queue SHAREDBSS_ATTR
;
212 static struct event_queue pcmbuf_queue SHAREDBSS_ATTR
;
214 extern struct codec_api ci
;
215 extern unsigned int codec_thread_id
;
217 /* Multiple threads */
218 /* Set the watermark to trigger buffer fill (A/C) */
219 static void set_filebuf_watermark(void);
222 static struct queue_sender_list audio_queue_sender_list SHAREDBSS_ATTR
;
223 static long audio_stack
[(DEFAULT_STACK_SIZE
+ 0x1000)/sizeof(long)];
224 static const char audio_thread_name
[] = "audio";
226 static void audio_thread(void);
227 static void audio_initiate_track_change(long direction
);
228 static bool audio_have_tracks(void);
229 static void audio_reset_buffer(void);
230 static void audio_stop_playback(void);
232 /**************************************/
235 /** Pcmbuf callbacks */
237 /* Between the codec and PCM track change, we need to keep updating the
238 * "elapsed" value of the previous (to the codec, but current to the
239 * user/PCM/WPS) track, so that the progressbar reaches the end.
240 * During that transition, the WPS will display othertrack_id3. */
241 void audio_pcmbuf_position_callback(unsigned int time
)
243 time
+= othertrack_id3
->elapsed
;
245 if (time
>= othertrack_id3
->length
)
247 /* we just played the end of the track, so stop this callback */
248 track_transition
= false;
249 othertrack_id3
->elapsed
= othertrack_id3
->length
;
252 othertrack_id3
->elapsed
= time
;
255 /* Post message from pcmbuf that the end of the previous track
256 * has just been played. */
257 void audio_post_track_change(bool pcmbuf
)
261 LOGFQUEUE("pcmbuf > pcmbuf Q_AUDIO_TRACK_CHANGED");
262 queue_post(&pcmbuf_queue
, Q_AUDIO_TRACK_CHANGED
, 0);
266 LOGFQUEUE("pcmbuf > audio Q_AUDIO_TRACK_CHANGED");
267 queue_post(&audio_queue
, Q_AUDIO_TRACK_CHANGED
, 0);
271 /* Scan the pcmbuf queue and return true if a message pulled */
272 static bool pcmbuf_queue_scan(struct queue_event
*ev
)
274 if (!queue_empty(&pcmbuf_queue
))
276 /* Transfer message to audio queue */
278 /* Pull message - never, ever any blocking call! */
279 queue_wait_w_tmo(&pcmbuf_queue
, ev
, 0);
288 /** Helper functions */
290 static struct mp3entry
*bufgetid3(int handle_id
)
295 struct mp3entry
*id3
;
296 ssize_t ret
= bufgetdata(handle_id
, 0, (void *)&id3
);
298 if (ret
< 0 || ret
!= sizeof(struct mp3entry
))
304 static bool clear_track_info(struct track_info
*track
)
306 /* bufclose returns true if the handle is not found, or if it is closed
307 * successfully, so these checks are safe on non-existant handles */
311 if (track
->codec_hid
>= 0) {
312 if (bufclose(track
->codec_hid
))
313 track
->codec_hid
= -1;
318 if (track
->id3_hid
>= 0) {
319 if (bufclose(track
->id3_hid
))
325 if (track
->audio_hid
>= 0) {
326 if (bufclose(track
->audio_hid
))
327 track
->audio_hid
= -1;
337 if (track
->aa_hid
[i
] >= 0) {
338 if (bufclose(track
->aa_hid
[i
]))
339 track
->aa_hid
[i
] = -1;
347 if (track
->cuesheet_hid
>= 0) {
348 if (bufclose(track
->cuesheet_hid
))
349 track
->cuesheet_hid
= -1;
355 track
->taginfo_ready
= false;
360 /* --- External interfaces --- */
362 /* This sends a stop message and the audio thread will dump all it's
363 subsequenct messages */
364 void audio_hard_stop(void)
367 LOGFQUEUE("audio >| audio Q_AUDIO_STOP: 1");
368 queue_send(&audio_queue
, Q_AUDIO_STOP
, 1);
369 #ifdef PLAYBACK_VOICE
374 bool audio_restore_playback(int type
)
378 case AUDIO_WANT_PLAYBACK
:
379 if (buffer_state
!= AUDIOBUF_STATE_INITIALIZED
)
380 audio_reset_buffer();
382 case AUDIO_WANT_VOICE
:
383 if (buffer_state
== AUDIOBUF_STATE_TRASHED
)
384 audio_reset_buffer();
391 unsigned char *audio_get_buffer(bool talk_buf
, size_t *buffer_size
)
393 unsigned char *buf
, *end
;
395 if (audio_is_initialized
)
399 /* else buffer_state will be AUDIOBUF_STATE_TRASHED at this point */
401 /* Reset the buffering thread so that it doesn't try to use the data */
402 buffering_reset(filebuf
, filebuflen
);
404 if (buffer_size
== NULL
)
406 /* Special case for talk_init to use since it already knows it's
408 buffer_state
= AUDIOBUF_STATE_TRASHED
;
412 if (talk_buf
|| buffer_state
== AUDIOBUF_STATE_TRASHED
413 || !talk_voice_required())
415 logf("get buffer: talk, audio");
416 /* Ok to use everything from audiobuf to audiobufend - voice is loaded,
417 the talk buffer is not needed because voice isn't being used, or
418 could be AUDIOBUF_STATE_TRASHED already. If state is
419 AUDIOBUF_STATE_VOICED_ONLY, no problem as long as memory isn't written
420 without the caller knowing what's going on. Changing certain settings
421 may move it to a worse condition but the memory in use by something
422 else will remain undisturbed.
424 if (buffer_state
!= AUDIOBUF_STATE_TRASHED
)
427 buffer_state
= AUDIOBUF_STATE_TRASHED
;
435 /* Safe to just return this if already AUDIOBUF_STATE_VOICED_ONLY or
436 still AUDIOBUF_STATE_INITIALIZED */
437 /* Skip talk buffer and move pcm buffer to end to maximize available
438 contiguous memory - no audio running means voice will not need the
440 logf("get buffer: audio");
441 buf
= audiobuf
+ talk_get_bufsize();
442 end
= audiobufend
- pcmbuf_init(audiobufend
);
443 buffer_state
= AUDIOBUF_STATE_VOICED_ONLY
;
446 *buffer_size
= end
- buf
;
451 bool audio_buffer_state_trashed(void)
453 return buffer_state
== AUDIOBUF_STATE_TRASHED
;
456 #ifdef HAVE_RECORDING
457 unsigned char *audio_get_recording_buffer(size_t *buffer_size
)
459 /* Stop audio, voice and obtain all available buffer space */
463 unsigned char *end
= audiobufend
;
464 buffer_state
= AUDIOBUF_STATE_TRASHED
;
465 *buffer_size
= end
- audiobuf
;
467 return (unsigned char *)audiobuf
;
470 bool audio_load_encoder(int afmt
)
472 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
473 const char *enc_fn
= get_codec_filename(afmt
| CODEC_TYPE_ENCODER
);
477 audio_remove_encoder();
478 ci
.enc_codec_loaded
= 0; /* clear any previous error condition */
480 LOGFQUEUE("codec > Q_ENCODER_LOAD_DISK");
481 queue_post(&codec_queue
, Q_ENCODER_LOAD_DISK
, (intptr_t)enc_fn
);
483 while (ci
.enc_codec_loaded
== 0)
486 logf("codec loaded: %d", ci
.enc_codec_loaded
);
488 return ci
.enc_codec_loaded
> 0;
493 } /* audio_load_encoder */
495 void audio_remove_encoder(void)
497 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
498 /* force encoder codec unload (if currently loaded) */
499 if (ci
.enc_codec_loaded
<= 0)
502 ci
.stop_encoder
= true;
503 while (ci
.enc_codec_loaded
> 0)
506 } /* audio_remove_encoder */
508 #endif /* HAVE_RECORDING */
511 struct mp3entry
* audio_current_track(void)
513 const char *filename
;
514 struct playlist_track_info trackinfo
;
516 int offset
= ci
.new_track
+ wps_offset
;
517 struct mp3entry
*write_id3
;
519 cur_idx
= (track_ridx
+ offset
) & MAX_TRACK_MASK
;
521 if (cur_idx
== track_ridx
&& *thistrack_id3
->path
)
524 if (tracks
[cur_idx
].cuesheet_hid
>= 0 && !thistrack_id3
->cuesheet
)
526 bufread(tracks
[cur_idx
].cuesheet_hid
, sizeof(struct cuesheet
), curr_cue
);
527 thistrack_id3
->cuesheet
= curr_cue
;
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
;
542 return othertrack_id3
;
547 /* Codec may be using thistrack_id3, so it must not be overwritten.
548 If this is a manual skip, othertrack_id3 will become
549 thistrack_id3 in audio_check_new_track().
550 FIXME: If this is an automatic skip, it probably means multiple
551 short tracks fit in the PCM buffer. Overwriting othertrack_id3
552 can lead to an incorrect value later.
553 Note that othertrack_id3 may also be used for next track.
555 write_id3
= othertrack_id3
;
559 write_id3
= thistrack_id3
;
562 if (tracks
[cur_idx
].id3_hid
>= 0)
564 /* The current track's info has been buffered but not read yet, so get it */
565 if (bufread(tracks
[cur_idx
].id3_hid
, sizeof(struct mp3entry
), write_id3
)
566 == sizeof(struct mp3entry
))
570 /* We didn't find the ID3 metadata, so we fill temp_id3 with the little info
571 we have and return that. */
573 memset(write_id3
, 0, sizeof(struct mp3entry
));
575 playlist_get_track_info(NULL
, playlist_next(0)+wps_offset
, &trackinfo
);
576 filename
= trackinfo
.filename
;
578 filename
= "No file!";
580 #if defined(HAVE_TC_RAMCACHE) && defined(HAVE_DIRCACHE)
581 if (tagcache_fill_tags(write_id3
, filename
))
585 strlcpy(write_id3
->path
, filename
, sizeof(write_id3
->path
));
586 write_id3
->title
= strrchr(write_id3
->path
, '/');
587 if (!write_id3
->title
)
588 write_id3
->title
= &write_id3
->path
[0];
595 struct mp3entry
* audio_next_track(void)
598 int offset
= ci
.new_track
+ wps_offset
;
600 if (!audio_have_tracks())
603 if (wps_offset
== -1 && *thistrack_id3
->path
)
605 /* We're in a track transition. The next track for the WPS is the one
606 currently being decoded. */
607 return thistrack_id3
;
610 next_idx
= (track_ridx
+ offset
+ 1) & MAX_TRACK_MASK
;
612 if (tracks
[next_idx
].id3_hid
>= 0)
614 if (bufread(tracks
[next_idx
].id3_hid
, sizeof(struct mp3entry
), othertrack_id3
)
615 == sizeof(struct mp3entry
))
616 return othertrack_id3
;
621 if (next_idx
== track_widx
)
623 /* The next track hasn't been buffered yet, so we return the static
624 version of its metadata. */
625 return &unbuffered_id3
;
631 /* gets a copy of the id3 data */
632 bool audio_peek_track(struct mp3entry
* id3
, int offset
)
635 int new_offset
= ci
.new_track
+ wps_offset
+ offset
;
637 if (!audio_have_tracks())
639 next_idx
= (track_ridx
+ new_offset
) & MAX_TRACK_MASK
;
641 if (tracks
[next_idx
].id3_hid
>= 0)
643 struct mp3entry
*id3src
;
644 if (bufgetdata(tracks
[next_idx
].id3_hid
, 0, (void**)&id3src
)
645 == sizeof(struct mp3entry
))
647 copy_mp3entry(id3
, id3src
);
656 int playback_current_aa_hid(int slot
)
661 int offset
= ci
.new_track
+ wps_offset
;
663 cur_idx
= track_ridx
+ offset
;
664 cur_idx
&= MAX_TRACK_MASK
;
665 return tracks
[cur_idx
].aa_hid
[slot
];
668 int playback_claim_aa_slot(struct dim
*dim
)
672 /* first try to find a slot already having the size to reuse it
673 * since we don't want albumart of the same size buffered multiple times */
676 struct albumart_slot
*slot
= &albumart_slots
[i
];
677 if (slot
->dim
.width
== dim
->width
678 && slot
->dim
.height
== dim
->height
)
684 /* size is new, find a free slot */
687 if (!albumart_slots
[i
].used
)
689 albumart_slots
[i
].used
++;
690 albumart_slots
[i
].dim
= *dim
;
694 /* sorry, no free slot */
698 void playback_release_aa_slot(int slot
)
700 /* invalidate the albumart_slot */
701 struct albumart_slot
*aa_slot
= &albumart_slots
[slot
];
703 if (aa_slot
->used
> 0)
708 void audio_play(long offset
)
712 #ifdef PLAYBACK_VOICE
713 /* Truncate any existing voice output so we don't have spelling
714 * etc. over the first part of the played track */
719 LOGFQUEUE("audio >| audio Q_AUDIO_PLAY: %ld", offset
);
720 /* Don't return until playback has actually started */
721 queue_send(&audio_queue
, Q_AUDIO_PLAY
, offset
);
724 void audio_stop(void)
727 LOGFQUEUE("audio >| audio Q_AUDIO_STOP");
728 /* Don't return until playback has actually stopped */
729 queue_send(&audio_queue
, Q_AUDIO_STOP
, 0);
732 void audio_pause(void)
734 LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE");
735 /* Don't return until playback has actually paused */
736 queue_send(&audio_queue
, Q_AUDIO_PAUSE
, true);
739 void audio_resume(void)
741 LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE resume");
742 /* Don't return until playback has actually resumed */
743 queue_send(&audio_queue
, Q_AUDIO_PAUSE
, false);
746 void audio_skip(int direction
)
748 if (playlist_check(ci
.new_track
+ wps_offset
+ direction
))
750 if (global_settings
.beep
)
751 pcmbuf_beep(2000, 100, 2500*global_settings
.beep
);
753 LOGFQUEUE("audio > audio Q_AUDIO_SKIP %d", direction
);
754 queue_post(&audio_queue
, Q_AUDIO_SKIP
, direction
);
755 /* Update wps while our message travels inside deep playback queues. */
756 wps_offset
+= direction
;
760 /* No more tracks. */
761 if (global_settings
.beep
)
762 pcmbuf_beep(1000, 100, 1500*global_settings
.beep
);
766 void audio_next(void)
771 void audio_prev(void)
776 void audio_next_dir(void)
778 LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP 1");
779 queue_post(&audio_queue
, Q_AUDIO_DIR_SKIP
, 1);
782 void audio_prev_dir(void)
784 LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP -1");
785 queue_post(&audio_queue
, Q_AUDIO_DIR_SKIP
, -1);
788 void audio_pre_ff_rewind(void)
790 LOGFQUEUE("audio > audio Q_AUDIO_PRE_FF_REWIND");
791 queue_post(&audio_queue
, Q_AUDIO_PRE_FF_REWIND
, 0);
794 void audio_ff_rewind(long newpos
)
796 LOGFQUEUE("audio > audio Q_AUDIO_FF_REWIND");
797 queue_post(&audio_queue
, Q_AUDIO_FF_REWIND
, newpos
);
800 void audio_flush_and_reload_tracks(void)
802 LOGFQUEUE("audio > audio Q_AUDIO_FLUSH");
803 queue_post(&audio_queue
, Q_AUDIO_FLUSH
, 0);
806 void audio_error_clear(void)
808 #ifdef AUDIO_HAVE_RECORDING
809 pcm_rec_error_clear();
813 int audio_status(void)
818 ret
|= AUDIO_STATUS_PLAY
;
821 ret
|= AUDIO_STATUS_PAUSE
;
823 #ifdef HAVE_RECORDING
824 /* Do this here for constitency with mpeg.c version */
825 /* FIXME: pcm_rec_status() is deprecated */
826 ret
|= pcm_rec_status();
832 int audio_get_file_pos(void)
837 #ifdef HAVE_DISK_STORAGE
838 void audio_set_buffer_margin(int setting
)
840 static const unsigned short lookup
[] = {5, 15, 30, 60, 120, 180, 300, 600};
841 buffer_margin
= lookup
[setting
];
842 logf("buffer margin: %ld", (long)buffer_margin
);
843 set_filebuf_watermark();
847 #ifdef HAVE_CROSSFADE
848 /* Take necessary steps to enable or disable the crossfade setting */
849 void audio_set_crossfade(int enable
)
855 /* Tell it the next setting to use */
856 pcmbuf_request_crossfade_enable(enable
);
858 /* Return if size hasn't changed or this is too early to determine
859 which in the second case there's no way we could be playing
861 if (pcmbuf_is_same_size()) return;
864 was_playing
= playing
;
866 /* Playback has to be stopped before changing the buffer size */
869 /* Store the track resume position */
870 offset
= thistrack_id3
->offset
;
873 /* Blast it - audio buffer will have to be setup again next time
875 audio_get_buffer(true, &size
);
877 /* Restart playback if audio was running previously */
883 /* --- Routines called from multiple threads --- */
885 static void set_filebuf_watermark(void)
888 return; /* Audio buffers not yet set up */
890 #ifdef HAVE_DISK_STORAGE
892 int spinup
= ata_spinup_time();
894 seconds
= (spinup
/ HZ
) + 1;
898 seconds
+= buffer_margin
;
904 /* bitrate of last track in buffer dictates watermark */
905 struct mp3entry
* id3
= NULL
;
906 if (tracks
[track_widx
].taginfo_ready
)
907 id3
= bufgetid3(tracks
[track_widx
].id3_hid
);
909 id3
= bufgetid3(tracks
[track_widx
-1].id3_hid
);
911 logf("fwmark: No id3 for last track (r%d/w%d), aborting!", track_ridx
, track_widx
);
914 size_t bytes
= id3
->bitrate
* (1000/8) * seconds
;
915 buf_set_watermark(bytes
);
916 logf("fwmark: %d", bytes
);
919 /* --- Buffering callbacks --- */
921 static void buffering_low_buffer_callback(void *data
)
924 logf("low buffer callback");
926 if (filling
== STATE_FULL
|| filling
== STATE_END_OF_PLAYLIST
) {
928 LOGFQUEUE("buffering > audio Q_AUDIO_FILL_BUFFER");
929 queue_post(&audio_queue
, Q_AUDIO_FILL_BUFFER
, 0);
933 static void buffering_handle_rebuffer_callback(void *data
)
936 LOGFQUEUE("audio >| audio Q_AUDIO_FLUSH");
937 queue_post(&audio_queue
, Q_AUDIO_FLUSH
, 0);
940 static void buffering_handle_finished_callback(void *data
)
942 logf("handle %d finished buffering", *(int*)data
);
943 int hid
= (*(int*)data
);
945 if (hid
== tracks
[track_widx
].id3_hid
)
947 int offset
= ci
.new_track
+ wps_offset
;
948 int next_idx
= (track_ridx
+ offset
+ 1) & MAX_TRACK_MASK
;
949 /* The metadata handle for the last loaded track has been buffered.
950 We can ask the audio thread to load the rest of the track's data. */
951 LOGFQUEUE("audio >| audio Q_AUDIO_FINISH_LOAD");
952 queue_post(&audio_queue
, Q_AUDIO_FINISH_LOAD
, 0);
953 if (tracks
[next_idx
].id3_hid
== hid
)
954 send_event(PLAYBACK_EVENT_NEXTTRACKID3_AVAILABLE
, NULL
);
958 /* This is most likely an audio handle, so we strip the useless
959 trailing tags that are left. */
962 if (hid
== tracks
[track_widx
-1].audio_hid
963 && filling
== STATE_END_OF_PLAYLIST
)
965 /* This was the last track in the playlist.
966 We now have all the data we need. */
967 logf("last track finished buffering");
968 filling
= STATE_FINISHED
;
974 /* --- Audio thread --- */
976 static bool audio_have_tracks(void)
978 return (audio_track_count() != 0);
981 static int audio_free_track_count(void)
983 /* Used tracks + free tracks adds up to MAX_TRACK - 1 */
984 return MAX_TRACK
- 1 - audio_track_count();
987 int audio_track_count(void)
989 /* Calculate difference from track_ridx to track_widx
990 * taking into account a possible wrap-around. */
991 return (MAX_TRACK
+ track_widx
- track_ridx
) & MAX_TRACK_MASK
;
994 long audio_filebufused(void)
996 return (long) buf_used();
999 /* Update track info after successful a codec track change */
1000 static void audio_update_trackinfo(void)
1002 bool resume
= false;
1004 /* Load the curent track's metadata into curtrack_id3 */
1005 if (CUR_TI
->id3_hid
>= 0)
1006 copy_mp3entry(thistrack_id3
, bufgetid3(CUR_TI
->id3_hid
));
1008 /* Reset current position */
1009 thistrack_id3
->elapsed
= 0;
1011 #ifdef HAVE_TAGCACHE
1012 /* Ignoring resume position for automatic track change if so configured */
1013 resume
= global_settings
.autoresume_enable
&&
1014 (!automatic_skip
/* Resume all manually selected tracks */
1015 || global_settings
.autoresume_automatic
== AUTORESUME_NEXTTRACK_ALWAYS
1016 || (global_settings
.autoresume_automatic
!= AUTORESUME_NEXTTRACK_NEVER
1017 /* Not never resume? */
1018 && autoresumable(thistrack_id3
))); /* Pass Resume filter? */
1023 thistrack_id3
->offset
= 0;
1026 logf("audio_update_trackinfo: Set offset for %s to %lX\n",
1027 thistrack_id3
->title
, thistrack_id3
->offset
);
1029 /* Update the codec API */
1030 ci
.filesize
= CUR_TI
->filesize
;
1031 ci
.id3
= thistrack_id3
;
1033 ci
.taginfo_ready
= &CUR_TI
->taginfo_ready
;
1036 /* Clear tracks between write and read, non inclusive */
1037 static void audio_clear_track_entries(void)
1039 int cur_idx
= track_widx
;
1041 logf("Clearing tracks: r%d/w%d", track_ridx
, track_widx
);
1043 /* Loop over all tracks from write-to-read */
1046 cur_idx
= (cur_idx
+ 1) & MAX_TRACK_MASK
;
1048 if (cur_idx
== track_ridx
)
1051 clear_track_info(&tracks
[cur_idx
]);
1055 /* Clear all tracks */
1056 static bool audio_release_tracks(void)
1060 logf("releasing all tracks");
1062 for(i
= 0; i
< MAX_TRACK
; i
++)
1064 cur_idx
= (track_ridx
+ i
) & MAX_TRACK_MASK
;
1065 if (!clear_track_info(&tracks
[cur_idx
]))
1072 static bool audio_loadcodec(bool start_play
)
1074 int prev_track
, hid
;
1075 char codec_path
[MAX_PATH
]; /* Full path to codec */
1076 const struct mp3entry
*id3
, *prev_id3
;
1078 if (tracks
[track_widx
].id3_hid
< 0) {
1082 id3
= bufgetid3(tracks
[track_widx
].id3_hid
);
1086 const char *codec_fn
= get_codec_filename(id3
->codectype
);
1087 if (codec_fn
== NULL
)
1090 tracks
[track_widx
].codec_hid
= -1;
1094 /* Load the codec directly from disk and save some memory. */
1095 track_ridx
= track_widx
;
1096 ci
.filesize
= CUR_TI
->filesize
;
1097 ci
.id3
= thistrack_id3
;
1098 ci
.taginfo_ready
= &CUR_TI
->taginfo_ready
;
1100 LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK");
1101 queue_post(&codec_queue
, Q_CODEC_LOAD_DISK
, (intptr_t)codec_fn
);
1106 /* If we already have another track than this one buffered */
1107 if (track_widx
!= track_ridx
)
1109 prev_track
= (track_widx
- 1) & MAX_TRACK_MASK
;
1111 id3
= bufgetid3(tracks
[track_widx
].id3_hid
);
1112 prev_id3
= bufgetid3(tracks
[prev_track
].id3_hid
);
1114 /* If the previous codec is the same as this one, there is no need
1115 * to put another copy of it on the file buffer */
1116 if (id3
&& prev_id3
&&
1117 get_codec_base_type(id3
->codectype
) ==
1118 get_codec_base_type(prev_id3
->codectype
)
1119 && audio_codec_loaded
)
1121 logf("Reusing prev. codec");
1127 codec_get_full_path(codec_path
, codec_fn
);
1129 hid
= tracks
[track_widx
].codec_hid
= bufopen(codec_path
, 0, TYPE_CODEC
, NULL
);
1131 /* not an error if codec load it supported, will load it from disk
1132 * application builds don't support it
1134 if (hid
< 0 && hid
!= ERR_UNSUPPORTED_TYPE
)
1138 logf("Loaded codec");
1140 logf("Buffering codec unsupported, load later from disk");
1145 /* Load metadata for the next track (with bufopen). The rest of the track
1146 loading will be handled by audio_finish_load_track once the metadata has been
1147 actually loaded by the buffering thread. */
1148 static bool audio_load_track(size_t offset
, bool start_play
)
1150 char name_buf
[MAX_PATH
+ 1];
1151 const char *trackname
;
1154 if (track_load_started
) {
1155 /* There is already a track load in progress, so track_widx hasn't been
1156 incremented yet. Loading another track would overwrite the one that
1157 hasn't finished loading. */
1158 logf("audio_load_track(): a track load is already in progress");
1162 start_play_g
= start_play
; /* will be read by audio_finish_load_track */
1164 /* Stop buffer filling if there is no free track entries.
1165 Don't fill up the last track entry (we wan't to store next track
1167 if (!audio_free_track_count())
1169 logf("No free tracks");
1174 tracks
[track_widx
].taginfo_ready
= false;
1176 logf("Buffering track: r%d/w%d", track_ridx
, track_widx
);
1177 /* Get track name from current playlist read position. */
1178 while ((trackname
= playlist_peek(last_peek_offset
, name_buf
,
1179 sizeof(name_buf
))) != NULL
)
1181 /* Handle broken playlists. */
1182 fd
= open(trackname
, O_RDONLY
);
1185 logf("Open failed");
1186 /* Skip invalid entry from playlist. */
1187 playlist_skip_entry(NULL
, last_peek_offset
);
1195 logf("End-of-playlist");
1196 memset(&unbuffered_id3
, 0, sizeof(struct mp3entry
));
1197 filling
= STATE_END_OF_PLAYLIST
;
1199 if (thistrack_id3
->length
== 0 && thistrack_id3
->filesize
== 0)
1201 /* Stop playback if no valid track was found. */
1202 audio_stop_playback();
1208 tracks
[track_widx
].filesize
= filesize(fd
);
1210 if (offset
> tracks
[track_widx
].filesize
)
1213 /* Set default values */
1216 buf_set_watermark(filebuflen
/2);
1217 dsp_configure(ci
.dsp
, DSP_RESET
, 0);
1218 playlist_update_resume_info(audio_current_track());
1221 /* Get track metadata if we don't already have it. */
1222 if (tracks
[track_widx
].id3_hid
< 0)
1224 tracks
[track_widx
].id3_hid
= bufopen(trackname
, 0, TYPE_ID3
, NULL
);
1226 if (tracks
[track_widx
].id3_hid
< 0)
1228 /* Buffer is full. */
1229 get_metadata(&unbuffered_id3
, fd
, trackname
);
1232 logf("buffer is full for now (get metadata)");
1233 filling
= STATE_FULL
;
1237 if (track_widx
== track_ridx
)
1239 /* TODO: Superfluos buffering call? */
1240 buf_request_buffer_handle(tracks
[track_widx
].id3_hid
);
1241 struct mp3entry
*id3
= bufgetid3(tracks
[track_widx
].id3_hid
);
1244 copy_mp3entry(thistrack_id3
, id3
);
1245 thistrack_id3
->offset
= offset
;
1246 logf("audio_load_track: set offset for %s to %lX\n",
1247 thistrack_id3
->title
,
1251 memset(thistrack_id3
, 0, sizeof(struct mp3entry
));
1256 playlist_update_resume_info(audio_current_track());
1261 track_load_started
= true; /* Remember that we've started loading a track */
1265 /* Second part of the track loading: We now have the metadata available, so we
1266 can load the codec, the album art and finally the audio data.
1267 This is called on the audio thread after the buffering thread calls the
1268 buffering_handle_finished_callback callback. */
1269 static void audio_finish_load_track(void)
1271 size_t file_offset
= 0;
1273 bool start_play
= start_play_g
;
1275 track_load_started
= false;
1277 if (tracks
[track_widx
].id3_hid
< 0) {
1278 logf("No metadata");
1282 struct mp3entry
*track_id3
;
1284 if (track_widx
== track_ridx
)
1285 track_id3
= thistrack_id3
;
1287 track_id3
= bufgetid3(tracks
[track_widx
].id3_hid
);
1289 if (track_id3
->length
== 0 && track_id3
->filesize
== 0)
1291 logf("audio_finish_load_track: invalid metadata");
1293 /* Invalid metadata */
1294 bufclose(tracks
[track_widx
].id3_hid
);
1295 tracks
[track_widx
].id3_hid
= -1;
1297 /* Skip invalid entry from playlist. */
1298 playlist_skip_entry(NULL
, last_peek_offset
--);
1300 /* load next track */
1301 LOGFQUEUE("audio > audio Q_AUDIO_FILL_BUFFER %d", (int)start_play
);
1302 queue_post(&audio_queue
, Q_AUDIO_FILL_BUFFER
, start_play
);
1306 /* Try to load a cuesheet for the track */
1309 char cuepath
[MAX_PATH
];
1310 if (look_for_cuesheet_file(track_id3
->path
, cuepath
))
1313 tracks
[track_widx
].cuesheet_hid
=
1314 bufalloc(NULL
, sizeof(struct cuesheet
), TYPE_CUESHEET
);
1315 if (tracks
[track_widx
].cuesheet_hid
>= 0)
1317 bufgetdata(tracks
[track_widx
].cuesheet_hid
,
1318 sizeof(struct cuesheet
), &temp
);
1319 struct cuesheet
*cuesheet
= (struct cuesheet
*)temp
;
1320 if (!parse_cuesheet(cuepath
, cuesheet
))
1322 bufclose(tracks
[track_widx
].cuesheet_hid
);
1323 track_id3
->cuesheet
= NULL
;
1328 #ifdef HAVE_ALBUMART
1331 char aa_path
[MAX_PATH
];
1335 /* albumart_slots may change during a yield of bufopen,
1336 * but that's no problem */
1337 if (tracks
[track_widx
].aa_hid
[i
] >= 0 || !albumart_slots
[i
].used
)
1340 /* we can only decode jpeg for embedded AA */
1341 bool embedded_albumart
=
1342 track_id3
->embed_albumart
&& track_id3
->albumart
.type
== AA_TYPE_JPG
;
1343 /* find_albumart will error out if the wps doesn't have AA */
1344 if (embedded_albumart
|| find_albumart(track_id3
, aa_path
,
1345 sizeof(aa_path
), &(albumart_slots
[i
].dim
)))
1348 struct bufopen_bitmap_data user_data
= {
1349 .dim
= &(albumart_slots
[i
].dim
),
1350 .embedded_albumart
= NULL
,
1352 if (embedded_albumart
)
1354 user_data
.embedded_albumart
= &(track_id3
->albumart
);
1355 aa_hid
= bufopen(track_id3
->path
, 0,
1356 TYPE_BITMAP
, &user_data
);
1360 aa_hid
= bufopen(aa_path
, 0, TYPE_BITMAP
,
1363 if(aa_hid
== ERR_BUFFER_FULL
)
1365 filling
= STATE_FULL
;
1366 logf("buffer is full for now (get album art)");
1367 return; /* No space for track's album art, not an error */
1369 else if (aa_hid
< 0)
1371 /* another error, ignore AlbumArt */
1372 logf("Album art loading failed");
1374 tracks
[track_widx
].aa_hid
[i
] = aa_hid
;
1380 /* Load the codec. */
1381 if (!audio_loadcodec(start_play
))
1383 if (tracks
[track_widx
].codec_hid
== ERR_BUFFER_FULL
)
1385 /* No space for codec on buffer, not an error */
1386 filling
= STATE_FULL
;
1390 /* This is an error condition, either no codec was found, or reading
1391 * the codec file failed part way through, either way, skip the track */
1392 /* FIXME: We should not use splashf from audio thread! */
1393 splashf(HZ
*2, "No codec for: %s", track_id3
->path
);
1394 /* Skip invalid entry from playlist. */
1395 playlist_skip_entry(NULL
, last_peek_offset
);
1399 track_id3
->elapsed
= 0;
1400 offset
= track_id3
->offset
;
1401 size_t resume_rewind
= (global_settings
.resume_rewind
*
1402 track_id3
->bitrate
* 1000) / 8;
1404 if (offset
< resume_rewind
)
1410 offset
-= resume_rewind
;
1413 enum data_type type
= TYPE_PACKET_AUDIO
;
1415 switch (track_id3
->codectype
) {
1420 file_offset
= offset
;
1426 file_offset
= offset
;
1427 track_id3
->elapsed
= track_id3
->length
/ 2;
1434 logf("Loading atomic %d",track_id3
->codectype
);
1435 type
= TYPE_ATOMIC_AUDIO
;
1439 /* no special treatment needed */
1443 track_id3
->offset
= offset
;
1445 logf("load track: %s", track_id3
->path
);
1447 if (file_offset
> AUDIO_REBUFFER_GUESS_SIZE
)
1448 file_offset
-= AUDIO_REBUFFER_GUESS_SIZE
;
1449 else if (track_id3
->first_frame_offset
)
1450 file_offset
= track_id3
->first_frame_offset
;
1454 tracks
[track_widx
].audio_hid
= bufopen(track_id3
->path
, file_offset
, type
,
1457 /* No space left, not an error */
1458 if (tracks
[track_widx
].audio_hid
== ERR_BUFFER_FULL
)
1460 filling
= STATE_FULL
;
1461 logf("buffer is full for now (load audio)");
1464 else if (tracks
[track_widx
].audio_hid
< 0)
1466 /* another error, do not continue either */
1467 logf("Could not add audio data handle");
1471 /* All required data is now available for the codec -- unless the
1472 autoresume feature is in effect. In the latter case, the codec
1473 must wait until after PLAYBACK_EVENT_TRACK_BUFFER, which may
1474 generate a resume position. */
1475 #ifdef HAVE_TAGCACHE
1476 if (! global_settings
.autoresume_enable
)
1478 tracks
[track_widx
].taginfo_ready
= true;
1482 ci
.curpos
=file_offset
;
1483 buf_request_buffer_handle(tracks
[track_widx
].audio_hid
);
1486 send_event(PLAYBACK_EVENT_TRACK_BUFFER
, track_id3
);
1488 #ifdef HAVE_TAGCACHE
1489 /* In case the autoresume feature has been enabled, finally all
1490 required data is available for the codec. */
1491 if (global_settings
.autoresume_enable
)
1492 tracks
[track_widx
].taginfo_ready
= true;
1495 track_widx
= (track_widx
+ 1) & MAX_TRACK_MASK
;
1497 /* load next track */
1498 LOGFQUEUE("audio > audio Q_AUDIO_FILL_BUFFER");
1499 queue_post(&audio_queue
, Q_AUDIO_FILL_BUFFER
, 0);
1504 static void audio_fill_file_buffer(bool start_play
, size_t offset
)
1506 trigger_cpu_boost();
1508 /* No need to rebuffer if there are track skips pending,
1509 * however don't cancel buffering on skipping while filling. */
1510 if (ci
.new_track
!= 0 && filling
!= STATE_FILLING
)
1512 filling
= STATE_FILLING
;
1514 /* Must reset the buffer before use if trashed or voice only - voice
1515 file size shouldn't have changed so we can go straight from
1516 AUDIOBUF_STATE_VOICED_ONLY to AUDIOBUF_STATE_INITIALIZED */
1517 if (buffer_state
!= AUDIOBUF_STATE_INITIALIZED
)
1518 audio_reset_buffer();
1520 logf("Starting buffer fill");
1523 audio_clear_track_entries();
1525 /* Save the current resume position once. */
1526 playlist_update_resume_info(audio_current_track());
1528 audio_load_track(offset
, start_play
);
1531 static void audio_rebuffer(void)
1533 logf("Forcing rebuffer");
1535 clear_track_info(CUR_TI
);
1537 /* Reset track pointers */
1538 track_widx
= track_ridx
;
1539 audio_clear_track_entries();
1541 /* Reset a possibly interrupted track load */
1542 track_load_started
= false;
1544 /* Fill the buffer */
1545 last_peek_offset
= -1;
1548 if (!CUR_TI
->taginfo_ready
)
1549 memset(thistrack_id3
, 0, sizeof(struct mp3entry
));
1551 audio_fill_file_buffer(false, 0);
1554 /* Called on request from the codec to get a new track. This is the codec part
1555 of the track transition. */
1556 static int audio_check_new_track(void)
1558 int track_count
= audio_track_count();
1559 int old_track_ridx
= track_ridx
;
1562 struct mp3entry
*temp
= thistrack_id3
;
1564 /* Now it's good time to send track finish events. */
1565 send_event(PLAYBACK_EVENT_TRACK_FINISH
, thistrack_id3
);
1566 /* swap the mp3entry pointers */
1567 thistrack_id3
= othertrack_id3
;
1568 othertrack_id3
= temp
;
1569 ci
.id3
= thistrack_id3
;
1570 memset(thistrack_id3
, 0, sizeof(struct mp3entry
));
1575 /* regardless of the return value we need to rebuffer.
1576 if it fails the old playlist will resume, else the
1577 next dir will start playing */
1578 playlist_next_dir(ci
.new_track
);
1587 /* If the playlist isn't that big */
1590 while (!playlist_check(ci
.new_track
))
1592 if (ci
.new_track
>= 0)
1594 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1595 return Q_CODEC_REQUEST_FAILED
;
1601 /* Update the playlist */
1602 last_peek_offset
-= ci
.new_track
;
1604 if (playlist_next(ci
.new_track
) < 0)
1606 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1607 return Q_CODEC_REQUEST_FAILED
;
1613 new_playlist
= false;
1616 /* Save a pointer to the old track to allow later clearing */
1619 for (i
= 0; i
< ci
.new_track
; i
++)
1621 idx
= (track_ridx
+ i
) & MAX_TRACK_MASK
;
1622 struct mp3entry
*id3
= bufgetid3(tracks
[idx
].id3_hid
);
1623 ssize_t offset
= buf_handle_offset(tracks
[idx
].audio_hid
);
1624 if (!id3
|| offset
< 0 || (unsigned)offset
> id3
->first_frame_offset
)
1626 /* We don't have all the audio data for that track, so clear it,
1627 but keep the metadata. */
1628 if (tracks
[idx
].audio_hid
>= 0 && bufclose(tracks
[idx
].audio_hid
))
1630 tracks
[idx
].audio_hid
= -1;
1631 tracks
[idx
].filesize
= 0;
1636 /* Move to the new track */
1637 track_ridx
= (track_ridx
+ ci
.new_track
) & MAX_TRACK_MASK
;
1638 buf_set_base_handle(CUR_TI
->audio_hid
);
1643 wps_offset
= -ci
.new_track
;
1646 /* If it is not safe to even skip this many track entries */
1647 if (ci
.new_track
>= track_count
|| ci
.new_track
<= track_count
- MAX_TRACK
)
1654 forward
= ci
.new_track
> 0;
1657 /* If the target track is clearly not in memory */
1658 if (CUR_TI
->filesize
== 0 || !CUR_TI
->taginfo_ready
)
1664 /* When skipping backwards, it is possible that we've found a track that's
1665 * buffered, but which is around the track-wrap and therefore not the track
1666 * we are looking for */
1669 int cur_idx
= track_ridx
;
1670 bool taginfo_ready
= true;
1671 /* We've wrapped the buffer backwards if new > old */
1672 bool wrap
= track_ridx
> old_track_ridx
;
1676 cur_idx
= (cur_idx
+ 1) & MAX_TRACK_MASK
;
1678 /* if we've advanced past the wrap when cur_idx is zeroed */
1682 /* if we aren't still on the wrap and we've caught the old track */
1683 if (!(wrap
|| cur_idx
< old_track_ridx
))
1686 /* If we hit a track in between without valid tag info, bail */
1687 if (!tracks
[cur_idx
].taginfo_ready
)
1689 taginfo_ready
= false;
1700 audio_update_trackinfo();
1701 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_COMPLETE");
1702 return Q_CODEC_REQUEST_COMPLETE
;
1705 unsigned long audio_prev_elapsed(void)
1707 return prev_track_elapsed
;
1710 void audio_set_prev_elapsed(unsigned long setting
)
1712 prev_track_elapsed
= setting
;
1715 static void audio_stop_codec_flush(void)
1717 ci
.stop_codec
= true;
1720 while (audio_codec_loaded
)
1723 /* If the audio codec is not loaded any more, and the audio is still
1724 * playing, it is now and _only_ now safe to call this function from the
1726 if (pcm_is_playing())
1730 queue_clear(&pcmbuf_queue
);
1733 pcmbuf_pause(paused
);
1736 static void audio_stop_playback(void)
1740 /* If we were playing, save resume information */
1741 struct mp3entry
*id3
= NULL
;
1745 /* Set this early, the outside code yields and may allow the codec
1746 to try to wait for a reply on a buffer wait */
1747 ci
.stop_codec
= true;
1748 id3
= audio_current_track();
1751 /* Save the current playing spot, or NULL if the playlist has ended */
1752 playlist_update_resume_info(id3
);
1754 /* Now it's good time to send track finish events. Do this
1755 only if this hasn't been done already as part of a track
1757 if (id3
== thistrack_id3
)
1758 send_event(PLAYBACK_EVENT_TRACK_FINISH
, thistrack_id3
);
1760 /* TODO: Create auto bookmark too? */
1762 prev_track_elapsed
= othertrack_id3
->elapsed
;
1764 remove_event(BUFFER_EVENT_BUFFER_LOW
, buffering_low_buffer_callback
);
1767 audio_stop_codec_flush();
1770 track_load_started
= false;
1772 filling
= STATE_IDLE
;
1774 /* Mark all entries null. */
1775 audio_clear_track_entries();
1777 /* Close all tracks */
1778 audio_release_tracks();
1781 static void audio_play_start(size_t offset
)
1785 send_event(PLAYBACK_EVENT_START_PLAYBACK
, NULL
);
1786 #if INPUT_SRC_CAPS != 0
1787 audio_set_input_source(AUDIO_SRC_PLAYBACK
, SRCF_PLAYBACK
);
1788 audio_set_output_source(AUDIO_SRC_PLAYBACK
);
1791 /* Wait for any previously playing audio to flush - TODO: Not necessary? */
1793 audio_stop_codec_flush();
1796 track_load_started
= false;
1802 sound_set_volume(global_settings
.volume
);
1803 track_widx
= track_ridx
= 0;
1804 buf_set_base_handle(-1);
1806 /* Clear all track entries. */
1807 for (i
= 0; i
< MAX_TRACK
; i
++) {
1808 clear_track_info(&tracks
[i
]);
1811 last_peek_offset
= -1;
1813 /* Officially playing */
1814 queue_reply(&audio_queue
, 1);
1816 audio_fill_file_buffer(true, offset
);
1818 add_event(BUFFER_EVENT_BUFFER_LOW
, false, buffering_low_buffer_callback
);
1820 LOGFQUEUE("audio > audio Q_AUDIO_TRACK_CHANGED");
1821 queue_post(&audio_queue
, Q_AUDIO_TRACK_CHANGED
, 0);
1825 /* Invalidates all but currently playing track. */
1826 static void audio_invalidate_tracks(void)
1828 if (audio_have_tracks())
1830 last_peek_offset
= 0;
1831 track_widx
= track_ridx
;
1833 /* Mark all other entries null (also buffered wrong metadata). */
1834 audio_clear_track_entries();
1836 track_widx
= (track_widx
+ 1) & MAX_TRACK_MASK
;
1838 audio_fill_file_buffer(false, 0);
1839 send_event(PLAYBACK_EVENT_TRACK_CHANGE
, thistrack_id3
);
1843 static void audio_new_playlist(void)
1845 /* Prepare to start a new fill from the beginning of the playlist */
1846 last_peek_offset
= -1;
1847 if (audio_have_tracks())
1850 skipped_during_pause
= true;
1851 track_widx
= track_ridx
;
1852 audio_clear_track_entries();
1854 track_widx
= (track_widx
+ 1) & MAX_TRACK_MASK
;
1856 /* Mark the current track as invalid to prevent skipping back to it */
1857 CUR_TI
->taginfo_ready
= false;
1860 /* Signal the codec to initiate a track change forward */
1861 new_playlist
= true;
1864 /* Officially playing */
1865 queue_reply(&audio_queue
, 1);
1867 audio_fill_file_buffer(false, 0);
1870 /* Called on manual track skip */
1871 static void audio_initiate_track_change(long direction
)
1873 logf("audio_initiate_track_change(%ld)", direction
);
1875 ci
.new_track
+= direction
;
1876 wps_offset
-= direction
;
1878 skipped_during_pause
= true;
1881 /* Called on manual dir skip */
1882 static void audio_initiate_dir_change(long direction
)
1885 ci
.new_track
= direction
;
1887 skipped_during_pause
= true;
1890 /* Called when PCM track change is complete */
1891 static void audio_finalise_track_change(void)
1893 logf("audio_finalise_track_change");
1898 automatic_skip
= false;
1900 /* Invalidate prevtrack_id3 */
1901 memset(othertrack_id3
, 0, sizeof(struct mp3entry
));
1903 if (prev_ti
&& prev_ti
->audio_hid
< 0)
1905 /* No audio left so we clear all the track info. */
1906 clear_track_info(prev_ti
);
1909 send_event(PLAYBACK_EVENT_TRACK_CHANGE
, thistrack_id3
);
1910 playlist_update_resume_info(audio_current_track());
1914 * Layout audio buffer as follows - iram buffer depends on target:
1915 * [|SWAP:iram][|TALK]|FILE|GUARD|PCM|[SWAP:dram[|iram]|]
1917 static void audio_reset_buffer(void)
1919 /* see audio_get_recording_buffer if this is modified */
1920 logf("audio_reset_buffer");
1922 /* If the setup of anything allocated before the file buffer is
1923 changed, do check the adjustments after the buffer_alloc call
1924 as it will likely be affected and need sliding over */
1926 /* Initially set up file buffer as all space available */
1927 malloc_buf
= audiobuf
+ talk_get_bufsize();
1929 /* Align the malloc buf to line size.
1930 * Especially important to cf targets that do line reads/writes.
1931 * Also for targets which need aligned DMA storage buffers */
1932 malloc_buf
= (unsigned char *)(((uintptr_t)malloc_buf
+ (CACHEALIGN_SIZE
- 1)) & ~(CACHEALIGN_SIZE
- 1));
1933 filebuf
= malloc_buf
; /* filebuf line align implied */
1934 filebuflen
= (audiobufend
- filebuf
) & ~(CACHEALIGN_SIZE
- 1);
1936 /* Subtract whatever the pcm buffer says it used plus the guard buffer */
1937 const size_t pcmbuf_size
= pcmbuf_init(filebuf
+ filebuflen
) +GUARD_BUFSIZE
;
1938 if(pcmbuf_size
> filebuflen
)
1939 panicf("%s(): EOM (%zu > %zu)", __func__
, pcmbuf_size
, filebuflen
);
1941 filebuflen
-= pcmbuf_size
;
1943 /* Make sure filebuflen is a longword multiple after adjustment - filebuf
1944 will already be line aligned */
1947 buffering_reset(filebuf
, filebuflen
);
1949 /* Clear any references to the file buffer */
1950 buffer_state
= AUDIOBUF_STATE_INITIALIZED
;
1952 #if defined(ROCKBOX_HAS_LOGF) && defined(LOGF_ENABLE)
1953 /* Make sure everything adds up - yes, some info is a bit redundant but
1954 aids viewing and the sumation of certain variables should add up to
1955 the location of others. */
1958 const unsigned char *pcmbuf
= pcmbuf_get_meminfo(&pcmbufsize
);
1959 logf("mabuf: %08X", (unsigned)malloc_buf
);
1960 logf("fbuf: %08X", (unsigned)filebuf
);
1961 logf("fbufe: %08X", (unsigned)(filebuf
+ filebuflen
));
1962 logf("gbuf: %08X", (unsigned)(filebuf
+ filebuflen
));
1963 logf("gbufe: %08X", (unsigned)(filebuf
+ filebuflen
+ GUARD_BUFSIZE
));
1964 logf("pcmb: %08X", (unsigned)pcmbuf
);
1965 logf("pcmbe: %08X", (unsigned)(pcmbuf
+ pcmbufsize
));
1970 static void audio_thread(void)
1972 struct queue_event ev
;
1976 audio_thread_ready
= true;
1980 if (filling
!= STATE_FILLING
&& filling
!= STATE_IDLE
) {
1981 /* End of buffering, let's calculate the watermark and unboost */
1982 set_filebuf_watermark();
1986 if (!pcmbuf_queue_scan(&ev
))
1987 queue_wait_w_tmo(&audio_queue
, &ev
, HZ
/2);
1991 case Q_AUDIO_FILL_BUFFER
:
1992 LOGFQUEUE("audio < Q_AUDIO_FILL_BUFFER %d", (int)ev
.data
);
1993 audio_fill_file_buffer((bool)ev
.data
, 0);
1996 case Q_AUDIO_FINISH_LOAD
:
1997 LOGFQUEUE("audio < Q_AUDIO_FINISH_LOAD");
1998 audio_finish_load_track();
1999 buf_set_base_handle(CUR_TI
->audio_hid
);
2003 LOGFQUEUE("audio < Q_AUDIO_PLAY");
2004 if (playing
&& ev
.data
<= 0)
2005 audio_new_playlist();
2008 audio_stop_playback();
2009 audio_play_start((size_t)ev
.data
);
2014 LOGFQUEUE("audio < Q_AUDIO_STOP");
2016 audio_stop_playback();
2018 queue_clear(&audio_queue
);
2022 LOGFQUEUE("audio < Q_AUDIO_PAUSE");
2023 if (!(bool) ev
.data
&& skipped_during_pause
2024 #ifdef HAVE_CROSSFADE
2025 && !pcmbuf_is_crossfade_active()
2028 pcmbuf_play_stop(); /* Flush old track on resume after skip */
2029 skipped_during_pause
= false;
2032 pcmbuf_pause((bool)ev
.data
);
2033 paused
= (bool)ev
.data
;
2037 LOGFQUEUE("audio < Q_AUDIO_SKIP");
2038 audio_initiate_track_change((long)ev
.data
);
2041 case Q_AUDIO_PRE_FF_REWIND
:
2042 LOGFQUEUE("audio < Q_AUDIO_PRE_FF_REWIND");
2048 case Q_AUDIO_FF_REWIND
:
2049 LOGFQUEUE("audio < Q_AUDIO_FF_REWIND");
2053 if ((long)ev
.data
== 0)
2055 /* About to restart the track - send track finish
2056 events if not already done. */
2057 if (thistrack_id3
== audio_current_track())
2058 send_event(PLAYBACK_EVENT_TRACK_FINISH
, thistrack_id3
);
2063 /* An automatic track skip is in progress. Finalize it,
2064 then go back to the previous track */
2065 audio_finalise_track_change();
2068 ci
.seek_time
= (long)ev
.data
+1;
2071 case Q_AUDIO_CHECK_NEW_TRACK
:
2072 LOGFQUEUE("audio < Q_AUDIO_CHECK_NEW_TRACK");
2073 queue_reply(&audio_queue
, audio_check_new_track());
2076 case Q_AUDIO_DIR_SKIP
:
2077 LOGFQUEUE("audio < Q_AUDIO_DIR_SKIP");
2078 audio_initiate_dir_change(ev
.data
);
2082 LOGFQUEUE("audio < Q_AUDIO_FLUSH");
2083 audio_invalidate_tracks();
2086 case Q_AUDIO_TRACK_CHANGED
:
2087 /* PCM track change done */
2088 LOGFQUEUE("audio < Q_AUDIO_TRACK_CHANGED");
2089 audio_finalise_track_change();
2091 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
2092 case SYS_USB_CONNECTED
:
2093 LOGFQUEUE("audio < SYS_USB_CONNECTED");
2095 audio_stop_playback();
2096 #ifdef PLAYBACK_VOICE
2099 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
2100 usb_wait_for_disconnect(&audio_queue
);
2102 /* Mark all entries null. */
2103 audio_clear_track_entries();
2105 /* release tracks to make sure all handles are closed */
2106 audio_release_tracks();
2111 LOGFQUEUE_SYS_TIMEOUT("audio < SYS_TIMEOUT");
2115 /* LOGFQUEUE("audio < default : %08lX", ev.id); */
2121 /* Initialize the audio system - called from init() in main.c.
2122 * Last function because of all the references to internal symbols
2124 void audio_init(void)
2126 unsigned int audio_thread_id
;
2128 /* Can never do this twice */
2129 if (audio_is_initialized
)
2131 logf("audio: already initialized");
2135 logf("audio: initializing");
2137 /* Initialize queues before giving control elsewhere in case it likes
2138 to send messages. Thread creation will be delayed however so nothing
2139 starts running until ready if something yields such as talk_init. */
2140 queue_init(&audio_queue
, true);
2141 queue_init(&codec_queue
, false);
2142 queue_init(&pcmbuf_queue
, false);
2146 codec_init_codec_api();
2148 thistrack_id3
= &mp3entry_buf
[0];
2149 othertrack_id3
= &mp3entry_buf
[1];
2151 /* cuesheet support */
2152 if (global_settings
.cuesheet
)
2153 curr_cue
= (struct cuesheet
*)buffer_alloc(sizeof(struct cuesheet
));
2155 /* initialize the buffer */
2158 /* audio_reset_buffer must to know the size of voice buffer so init
2162 make_codec_thread();
2164 audio_thread_id
= create_thread(audio_thread
, audio_stack
,
2165 sizeof(audio_stack
), CREATE_THREAD_FROZEN
,
2166 audio_thread_name
IF_PRIO(, PRIORITY_USER_INTERFACE
)
2169 queue_enable_queue_send(&audio_queue
, &audio_queue_sender_list
,
2172 #ifdef PLAYBACK_VOICE
2173 voice_thread_init();
2176 #ifdef HAVE_CROSSFADE
2177 /* Set crossfade setting for next buffer init which should be about... */
2178 pcmbuf_request_crossfade_enable(global_settings
.crossfade
);
2181 /* initialize the buffering system */
2184 /* ...now! Set up the buffers */
2185 audio_reset_buffer();
2188 for(i
= 0; i
< MAX_TRACK
; i
++)
2190 tracks
[i
].audio_hid
= -1;
2191 tracks
[i
].id3_hid
= -1;
2192 tracks
[i
].codec_hid
= -1;
2193 tracks
[i
].cuesheet_hid
= -1;
2195 #ifdef HAVE_ALBUMART
2199 for (j
= 0; j
< MAX_TRACK
; j
++)
2201 tracks
[j
].aa_hid
[i
] = -1;
2206 add_event(BUFFER_EVENT_REBUFFER
, false, buffering_handle_rebuffer_callback
);
2207 add_event(BUFFER_EVENT_FINISHED
, false, buffering_handle_finished_callback
);
2209 /* Probably safe to say */
2210 audio_is_initialized
= true;
2212 sound_settings_apply();
2213 #ifdef HAVE_DISK_STORAGE
2214 audio_set_buffer_margin(global_settings
.buffer_margin
);
2217 /* it's safe to let the threads run now */
2218 #ifdef PLAYBACK_VOICE
2219 voice_thread_resume();
2221 thread_thaw(codec_thread_id
);
2222 thread_thaw(audio_thread_id
);
2226 bool audio_is_thread_ready(void)
2228 return audio_thread_ready
;
2231 size_t audio_get_filebuflen(void)
2238 return CUR_TI
->audio_hid
;
2241 int *get_codec_hid()
2243 return &tracks
[track_ridx
].codec_hid
;