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 */
46 #include "buffering.h"
48 #include "voice_thread.h"
49 #include "mp3_playback.h"
64 #ifdef HAVE_LCD_BITMAP
66 #include "peakmeter.h"
77 #include "ata_idle_notify.h"
80 #include "recording.h"
84 #define PLAYBACK_VOICE
86 /* default point to start buffer refill */
87 #define AUDIO_DEFAULT_WATERMARK (1024*512)
88 /* amount of guess-space to allow for codecs that must hunt and peck
89 * for their correct seeek target, 32k seems a good size */
90 #define AUDIO_REBUFFER_GUESS_SIZE (1024*32)
92 /* Define LOGF_ENABLE to enable logf output in this file */
93 /*#define LOGF_ENABLE*/
96 /* macros to enable logf for queues
97 logging on SYS_TIMEOUT can be disabled */
99 /* Define this for logf output of all queuing except SYS_TIMEOUT */
100 #define PLAYBACK_LOGQUEUES
101 /* Define this to logf SYS_TIMEOUT messages */
102 /*#define PLAYBACK_LOGQUEUES_SYS_TIMEOUT*/
105 #ifdef PLAYBACK_LOGQUEUES
106 #define LOGFQUEUE logf
108 #define LOGFQUEUE(...)
111 #ifdef PLAYBACK_LOGQUEUES_SYS_TIMEOUT
112 #define LOGFQUEUE_SYS_TIMEOUT logf
114 #define LOGFQUEUE_SYS_TIMEOUT(...)
118 /* Define one constant that includes recording related functionality */
119 #if defined(HAVE_RECORDING) && !defined(SIMULATOR)
120 #define AUDIO_HAVE_RECORDING
129 Q_AUDIO_PRE_FF_REWIND
,
131 Q_AUDIO_CHECK_NEW_TRACK
,
133 Q_AUDIO_TRACK_CHANGED
,
138 Q_CODEC_REQUEST_COMPLETE
,
139 Q_CODEC_REQUEST_FAILED
,
144 #ifdef AUDIO_HAVE_RECORDING
151 STATE_IDLE
, /* audio is stopped: nothing to do */
152 STATE_FILLING
, /* adding tracks to the buffer */
153 STATE_FULL
, /* can't add any more tracks */
154 STATE_END_OF_PLAYLIST
, /* all remaining tracks have been added */
155 STATE_FINISHED
, /* all remaining tracks are fully buffered */
159 #define MAX_TRACK 128
164 #define MAX_TRACK_MASK (MAX_TRACK-1)
166 /* As defined in plugins/lib/xxx2wav.h */
168 #define MALLOC_BUFSIZE (512*1024)
169 #define GUARD_BUFSIZE (32*1024)
171 #define MALLOC_BUFSIZE (100*1024)
172 #define GUARD_BUFSIZE (8*1024)
175 /* As defined in plugin.lds */
177 #define CODEC_IRAM_ORIGIN ((unsigned char *)0x4000c000)
178 #define CODEC_IRAM_SIZE ((size_t)0xc000)
179 #elif defined(IAUDIO_X5) || defined(IAUDIO_M5)
180 #define CODEC_IRAM_ORIGIN ((unsigned char *)0x10010000)
181 #define CODEC_IRAM_SIZE ((size_t)0x10000)
183 #define CODEC_IRAM_ORIGIN ((unsigned char *)0x1000c000)
184 #define CODEC_IRAM_SIZE ((size_t)0xc000)
187 bool audio_is_initialized
= false;
188 static bool audio_thread_ready SHAREDBSS_ATTR
= false;
190 /* Variables are commented with the threads that use them: *
191 * A=audio, C=codec, V=voice. A suffix of - indicates that *
192 * the variable is read but not updated on that thread. */
193 /* TBD: Split out "audio" and "playback" (ie. calling) threads */
195 /* Main state control */
196 static volatile bool audio_codec_loaded SHAREDBSS_ATTR
= false; /* Codec loaded? (C/A-) */
197 static volatile bool playing SHAREDBSS_ATTR
= false; /* Is audio playing? (A) */
198 static volatile bool paused SHAREDBSS_ATTR
= false; /* Is audio paused? (A/C-) */
200 /* Ring buffer where compressed audio and codecs are loaded */
201 static unsigned char *filebuf
= NULL
; /* Start of buffer (A/C-) */
202 static unsigned char *malloc_buf
= NULL
; /* Start of malloc buffer (A/C-) */
203 /* FIXME: make filebuflen static */
204 size_t filebuflen
= 0; /* Size of buffer (A/C-) */
205 /* FIXME: make buf_ridx (C/A-) */
207 /* Possible arrangements of the buffer */
208 #define BUFFER_STATE_TRASHED -1 /* trashed; must be reset */
209 #define BUFFER_STATE_INITIALIZED 0 /* voice+audio OR audio-only */
210 #define BUFFER_STATE_VOICED_ONLY 1 /* voice-only */
211 static int buffer_state
= BUFFER_STATE_TRASHED
; /* Buffer state */
213 /* Used to keep the WPS up-to-date during track transtition */
214 static struct mp3entry prevtrack_id3
;
216 /* Used to provide the codec with a pointer */
217 static struct mp3entry curtrack_id3
;
219 /* Used to make next track info available while playing last track on buffer */
220 static struct mp3entry lasttrack_id3
;
222 /* Track info structure about songs in the file buffer (A/C-) */
224 int audio_hid
; /* The ID for the track's buffer handle */
225 int id3_hid
; /* The ID for the track's metadata handle */
226 int codec_hid
; /* The ID for the track's codec handle */
228 int aa_hid
; /* The ID for the track's album art handle */
231 size_t filesize
; /* File total length */
233 bool taginfo_ready
; /* Is metadata read */
236 static struct track_info tracks
[MAX_TRACK
];
237 static volatile int track_ridx
= 0; /* Track being decoded (A/C-) */
238 static int track_widx
= 0; /* Track being buffered (A) */
240 #define CUR_TI (&tracks[track_ridx]) /* Playing track info pointer (A/C-) */
241 static struct track_info
*prev_ti
= NULL
; /* Pointer to the previously played
244 /* Set by the audio thread when the current track information has updated
245 * and the WPS may need to update its cached information */
246 static bool track_changed
= false;
248 /* Information used only for filling the buffer */
249 /* Playlist steps from playing track to next track to be buffered (A) */
250 static int last_peek_offset
= 0;
252 /* Scrobbler support */
253 static unsigned long prev_track_elapsed
= 0; /* Previous track elapsed time (C/A-)*/
255 static enum filling_state filling
;
257 /* Track change controls */
258 static bool automatic_skip
= false; /* Who initiated in-progress skip? (C/A-) */
259 static bool dir_skip
= false; /* Is a directory skip pending? (A) */
260 static bool new_playlist
= false; /* Are we starting a new playlist? (A) */
261 static int wps_offset
= 0; /* Pending track change offset, to keep WPS responsive (A) */
262 static bool skipped_during_pause
= false; /* Do we need to clear the PCM buffer when playback resumes (A) */
264 static bool start_play_g
= false; /* Used by audio_load_track to notify
265 audio_finish_load_track about start_play */
267 /* True when a track load is in progress, i.e. audio_load_track() has returned
268 * but audio_finish_load_track() hasn't been called yet. Used to avoid allowing
269 * audio_load_track() to get called twice in a row, which would cause problems.
271 static bool track_load_started
= false;
273 /* Set to true if the codec thread should send an audio stop request
274 * (typically because the end of the playlist has been reached).
276 static bool codec_requested_stop
= false;
278 static size_t buffer_margin
= 0; /* Buffer margin aka anti-skip buffer (A/C-) */
280 /* Multiple threads */
281 /* Set the watermark to trigger buffer fill (A/C) FIXME */
282 static void set_filebuf_watermark(int seconds
, size_t max
);
285 static struct event_queue audio_queue SHAREDBSS_ATTR
;
286 static struct queue_sender_list audio_queue_sender_list SHAREDBSS_ATTR
;
287 static long audio_stack
[(DEFAULT_STACK_SIZE
+ 0x1000)/sizeof(long)];
288 static const char audio_thread_name
[] = "audio";
290 static void audio_thread(void);
291 static void audio_initiate_track_change(long direction
);
292 static bool audio_have_tracks(void);
293 static void audio_reset_buffer(void);
296 extern struct codec_api ci
;
297 static struct event_queue codec_queue SHAREDBSS_ATTR
;
298 static struct queue_sender_list codec_queue_sender_list
;
299 static long codec_stack
[(DEFAULT_STACK_SIZE
+ 0x2000)/sizeof(long)]
301 static const char codec_thread_name
[] = "codec";
302 struct thread_entry
*codec_thread_p
; /* For modifying thread priority later. */
304 /* PCM buffer messaging */
305 static struct event_queue pcmbuf_queue SHAREDBSS_ATTR
;
307 /* Function to be called by pcm buffer callbacks.
308 * Permissible Context(s): Audio interrupt
310 static void pcmbuf_callback_queue_post(long id
, intptr_t data
)
312 /* No lock since we're already in audio interrupt context */
313 queue_post(&pcmbuf_queue
, id
, data
);
316 /* Scan the pcmbuf queue and return true if a message pulled.
317 * Permissible Context(s): Thread
319 static bool pcmbuf_queue_scan(struct queue_event
*ev
)
321 if (!queue_empty(&pcmbuf_queue
))
323 /* Transfer message to audio queue */
325 /* Pull message - never, ever any blocking call! */
326 queue_wait_w_tmo(&pcmbuf_queue
, ev
, 0);
334 /* Clear the pcmbuf queue of messages
335 * Permissible Context(s): Thread
337 static void pcmbuf_queue_clear(void)
340 queue_clear(&pcmbuf_queue
);
344 /* --- Helper functions --- */
346 static struct mp3entry
*bufgetid3(int handle_id
)
351 struct mp3entry
*id3
;
352 ssize_t ret
= bufgetdata(handle_id
, 0, (void *)&id3
);
354 if (ret
< 0 || ret
!= sizeof(struct mp3entry
))
360 static bool clear_track_info(struct track_info
*track
)
362 /* bufclose returns true if the handle is not found, or if it is closed
363 * successfully, so these checks are safe on non-existant handles */
367 if (track
->codec_hid
>= 0) {
368 if (bufclose(track
->codec_hid
))
369 track
->codec_hid
= -1;
374 if (track
->id3_hid
>= 0) {
375 if (bufclose(track
->id3_hid
))
381 if (track
->audio_hid
>= 0) {
382 if (bufclose(track
->audio_hid
))
383 track
->audio_hid
= -1;
389 if (track
->aa_hid
>= 0) {
390 if (bufclose(track
->aa_hid
))
398 track
->taginfo_ready
= false;
403 /* --- External interfaces --- */
405 /* This sends a stop message and the audio thread will dump all it's
406 subsequenct messages */
407 void audio_hard_stop(void)
410 LOGFQUEUE("audio >| audio Q_AUDIO_STOP: 1");
411 queue_send(&audio_queue
, Q_AUDIO_STOP
, 1);
412 #ifdef PLAYBACK_VOICE
417 bool audio_restore_playback(int type
)
421 case AUDIO_WANT_PLAYBACK
:
422 if (buffer_state
!= BUFFER_STATE_INITIALIZED
)
423 audio_reset_buffer();
425 case AUDIO_WANT_VOICE
:
426 if (buffer_state
== BUFFER_STATE_TRASHED
)
427 audio_reset_buffer();
434 unsigned char *audio_get_buffer(bool talk_buf
, size_t *buffer_size
)
436 unsigned char *buf
, *end
;
438 if (audio_is_initialized
)
442 /* else buffer_state will be BUFFER_STATE_TRASHED at this point */
444 if (buffer_size
== NULL
)
446 /* Special case for talk_init to use since it already knows it's
448 buffer_state
= BUFFER_STATE_TRASHED
;
452 if (talk_buf
|| buffer_state
== BUFFER_STATE_TRASHED
453 || !talk_voice_required())
455 logf("get buffer: talk, audio");
456 /* Ok to use everything from audiobuf to audiobufend - voice is loaded,
457 the talk buffer is not needed because voice isn't being used, or
458 could be BUFFER_STATE_TRASHED already. If state is
459 BUFFER_STATE_VOICED_ONLY, no problem as long as memory isn't written
460 without the caller knowing what's going on. Changing certain settings
461 may move it to a worse condition but the memory in use by something
462 else will remain undisturbed.
464 if (buffer_state
!= BUFFER_STATE_TRASHED
)
467 buffer_state
= BUFFER_STATE_TRASHED
;
475 /* Safe to just return this if already BUFFER_STATE_VOICED_ONLY or
476 still BUFFER_STATE_INITIALIZED */
477 /* Skip talk buffer and move pcm buffer to end to maximize available
478 contiguous memory - no audio running means voice will not need the
480 logf("get buffer: audio");
481 buf
= audiobuf
+ talk_get_bufsize();
482 end
= audiobufend
- pcmbuf_init(audiobufend
);
483 buffer_state
= BUFFER_STATE_VOICED_ONLY
;
486 *buffer_size
= end
- buf
;
491 #ifdef HAVE_RECORDING
492 unsigned char *audio_get_recording_buffer(size_t *buffer_size
)
494 /* Stop audio, voice and obtain all available buffer space */
498 unsigned char *end
= audiobufend
;
499 buffer_state
= BUFFER_STATE_TRASHED
;
500 *buffer_size
= end
- audiobuf
;
502 return (unsigned char *)audiobuf
;
505 bool audio_load_encoder(int afmt
)
508 const char *enc_fn
= get_codec_filename(afmt
| CODEC_TYPE_ENCODER
);
512 audio_remove_encoder();
513 ci
.enc_codec_loaded
= 0; /* clear any previous error condition */
515 LOGFQUEUE("codec > Q_ENCODER_LOAD_DISK");
516 queue_post(&codec_queue
, Q_ENCODER_LOAD_DISK
, (intptr_t)enc_fn
);
518 while (ci
.enc_codec_loaded
== 0)
521 logf("codec loaded: %d", ci
.enc_codec_loaded
);
523 return ci
.enc_codec_loaded
> 0;
528 } /* audio_load_encoder */
530 void audio_remove_encoder(void)
533 /* force encoder codec unload (if currently loaded) */
534 if (ci
.enc_codec_loaded
<= 0)
537 ci
.stop_encoder
= true;
538 while (ci
.enc_codec_loaded
> 0)
541 } /* audio_remove_encoder */
543 #endif /* HAVE_RECORDING */
546 int audio_current_aa_hid(void)
549 int offset
= ci
.new_track
+ wps_offset
;
551 cur_idx
= track_ridx
+ offset
;
552 cur_idx
&= MAX_TRACK_MASK
;
554 return tracks
[cur_idx
].aa_hid
;
558 struct mp3entry
* audio_current_track(void)
560 const char *filename
;
562 static struct mp3entry temp_id3
;
563 struct playlist_track_info trackinfo
;
565 int offset
= ci
.new_track
+ wps_offset
;
567 cur_idx
= (track_ridx
+ offset
) & MAX_TRACK_MASK
;
569 if (cur_idx
== track_ridx
&& *curtrack_id3
.path
)
572 return &curtrack_id3
;
574 else if (automatic_skip
&& offset
== -1 && *prevtrack_id3
.path
)
576 /* We're in a track transition. The codec has moved on to the nex track,
577 but the audio being played is still the same (now previous) track.
578 prevtrack_id3.elapsed is being updated in an ISR by
579 codec_pcmbuf_position_callback */
580 return &prevtrack_id3
;
582 else if (tracks
[cur_idx
].id3_hid
>= 0)
584 /* Get the ID3 metadata from the main buffer */
585 struct mp3entry
*ret
= bufgetid3(tracks
[cur_idx
].id3_hid
);
589 /* We didn't find the ID3 metadata, so we fill temp_id3 with the little info
590 we have and return that. */
592 memset(&temp_id3
, 0, sizeof(struct mp3entry
));
594 playlist_get_track_info(NULL
, playlist_next(0)+wps_offset
, &trackinfo
);
595 filename
= trackinfo
.filename
;
597 filename
= "No file!";
599 #if defined(HAVE_TC_RAMCACHE) && defined(HAVE_DIRCACHE)
600 if (tagcache_fill_tags(&temp_id3
, filename
))
604 p
= strrchr(filename
, '/');
610 strncpy(temp_id3
.path
, p
, sizeof(temp_id3
.path
)-1);
611 temp_id3
.title
= &temp_id3
.path
[0];
616 struct mp3entry
* audio_next_track(void)
619 int offset
= ci
.new_track
+ wps_offset
;
621 if (!audio_have_tracks())
624 if (wps_offset
== -1 && *prevtrack_id3
.path
)
626 /* We're in a track transition. The next track for the WPS is the one
627 currently being decoded. */
628 return &curtrack_id3
;
631 next_idx
= (track_ridx
+ offset
+ 1) & MAX_TRACK_MASK
;
633 if (tracks
[next_idx
].id3_hid
>= 0)
634 return bufgetid3(tracks
[next_idx
].id3_hid
);
636 if (next_idx
== track_widx
)
638 /* The next track hasn't been buffered yet, so we return the static
639 version of its metadata. */
640 return &lasttrack_id3
;
646 bool audio_has_changed_track(void)
650 track_changed
= false;
657 void audio_play(long offset
)
661 #ifdef PLAYBACK_VOICE
662 /* Truncate any existing voice output so we don't have spelling
663 * etc. over the first part of the played track */
668 LOGFQUEUE("audio >| audio Q_AUDIO_PLAY: %ld", offset
);
669 /* Don't return until playback has actually started */
670 queue_send(&audio_queue
, Q_AUDIO_PLAY
, offset
);
673 void audio_stop(void)
676 LOGFQUEUE("audio >| audio Q_AUDIO_STOP");
677 /* Don't return until playback has actually stopped */
678 queue_send(&audio_queue
, Q_AUDIO_STOP
, 0);
681 void audio_pause(void)
683 LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE");
684 /* Don't return until playback has actually paused */
685 queue_send(&audio_queue
, Q_AUDIO_PAUSE
, true);
688 void audio_resume(void)
690 LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE resume");
691 /* Don't return until playback has actually resumed */
692 queue_send(&audio_queue
, Q_AUDIO_PAUSE
, false);
695 static void audio_skip(int direction
)
697 if (playlist_check(ci
.new_track
+ wps_offset
+ direction
))
699 if (global_settings
.beep
)
700 pcmbuf_beep(5000, 100, 2500*global_settings
.beep
);
702 LOGFQUEUE("audio > audio Q_AUDIO_SKIP %d", direction
);
703 queue_post(&audio_queue
, Q_AUDIO_SKIP
, direction
);
704 /* Update wps while our message travels inside deep playback queues. */
705 wps_offset
+= direction
;
706 track_changed
= true;
710 /* No more tracks. */
711 if (global_settings
.beep
)
712 pcmbuf_beep(1000, 100, 1000*global_settings
.beep
);
716 void audio_next(void)
721 void audio_prev(void)
726 void audio_next_dir(void)
728 LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP 1");
729 queue_post(&audio_queue
, Q_AUDIO_DIR_SKIP
, 1);
732 void audio_prev_dir(void)
734 LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP -1");
735 queue_post(&audio_queue
, Q_AUDIO_DIR_SKIP
, -1);
738 void audio_pre_ff_rewind(void)
740 LOGFQUEUE("audio > audio Q_AUDIO_PRE_FF_REWIND");
741 queue_post(&audio_queue
, Q_AUDIO_PRE_FF_REWIND
, 0);
744 void audio_ff_rewind(long newpos
)
746 LOGFQUEUE("audio > audio Q_AUDIO_FF_REWIND");
747 queue_post(&audio_queue
, Q_AUDIO_FF_REWIND
, newpos
);
750 void audio_flush_and_reload_tracks(void)
752 LOGFQUEUE("audio > audio Q_AUDIO_FLUSH");
753 queue_post(&audio_queue
, Q_AUDIO_FLUSH
, 0);
756 void audio_error_clear(void)
758 #ifdef AUDIO_HAVE_RECORDING
759 pcm_rec_error_clear();
763 int audio_status(void)
768 ret
|= AUDIO_STATUS_PLAY
;
771 ret
|= AUDIO_STATUS_PAUSE
;
773 #ifdef HAVE_RECORDING
774 /* Do this here for constitency with mpeg.c version */
775 ret
|= pcm_rec_status();
781 int audio_get_file_pos(void)
786 #ifndef HAVE_FLASH_STORAGE
787 void audio_set_buffer_margin(int setting
)
789 static const int lookup
[] = {5, 15, 30, 60, 120, 180, 300, 600};
790 buffer_margin
= lookup
[setting
];
791 logf("buffer margin: %ld", (long)buffer_margin
);
792 set_filebuf_watermark(buffer_margin
, 0);
796 /* Take necessary steps to enable or disable the crossfade setting */
797 void audio_set_crossfade(int enable
)
803 /* Tell it the next setting to use */
804 pcmbuf_crossfade_enable(enable
);
806 /* Return if size hasn't changed or this is too early to determine
807 which in the second case there's no way we could be playing
809 if (pcmbuf_is_same_size())
811 /* This function is a copout and just syncs some variables -
812 to be removed at a later date */
813 pcmbuf_crossfade_enable_finished();
818 was_playing
= playing
;
820 /* Playback has to be stopped before changing the buffer size */
823 /* Store the track resume position */
824 offset
= curtrack_id3
.offset
;
825 gui_syncsplash(0, str(LANG_RESTARTING_PLAYBACK
));
828 /* Blast it - audio buffer will have to be setup again next time
830 audio_get_buffer(true, &size
);
832 /* Restart playback if audio was running previously */
837 /* --- Routines called from multiple threads --- */
839 static void set_filebuf_watermark(int seconds
, size_t max
)
844 return; /* Audio buffers not yet set up */
846 bytes
= seconds
?MAX(curtrack_id3
.bitrate
* seconds
* (1000/8), max
):max
;
847 bytes
= MIN(bytes
, filebuflen
/ 2);
848 buf_set_watermark(bytes
);
851 const char *get_codec_filename(int cod_spec
)
855 #ifdef HAVE_RECORDING
856 /* Can choose decoder or encoder if one available */
857 int type
= cod_spec
& CODEC_TYPE_MASK
;
858 int afmt
= cod_spec
& CODEC_AFMT_MASK
;
860 if ((unsigned)afmt
>= AFMT_NUM_CODECS
)
861 type
= AFMT_UNKNOWN
| (type
& CODEC_TYPE_MASK
);
863 fname
= (type
== CODEC_TYPE_ENCODER
) ?
864 audio_formats
[afmt
].codec_enc_root_fn
:
865 audio_formats
[afmt
].codec_root_fn
;
868 (type
== CODEC_TYPE_ENCODER
) ? "Encoder" : "Decoder",
869 afmt
, fname
? fname
: "<unknown>");
870 #else /* !HAVE_RECORDING */
872 if ((unsigned)cod_spec
>= AFMT_NUM_CODECS
)
873 cod_spec
= AFMT_UNKNOWN
;
874 fname
= audio_formats
[cod_spec
].codec_root_fn
;
875 logf("Codec: %d - %s", cod_spec
, fname
? fname
: "<unknown>");
876 #endif /* HAVE_RECORDING */
879 } /* get_codec_filename */
881 /* --- Codec thread --- */
882 static bool codec_pcmbuf_insert_callback(
883 const void *ch1
, const void *ch2
, int count
)
885 const char *src
[2] = { ch1
, ch2
};
889 int out_count
= dsp_output_count(ci
.dsp
, count
);
893 /* Prevent audio from a previous track from playing */
894 if (ci
.new_track
|| ci
.stop_codec
)
897 while ((dest
= pcmbuf_request_buffer(&out_count
)) == NULL
)
901 if (ci
.seek_time
|| ci
.new_track
|| ci
.stop_codec
)
905 /* Get the real input_size for output_size bytes, guarding
906 * against resampling buffer overflows. */
907 inp_count
= dsp_input_count(ci
.dsp
, out_count
);
912 /* Input size has grown, no error, just don't write more than length */
913 if (inp_count
> count
)
916 out_count
= dsp_process(ci
.dsp
, dest
, src
, inp_count
);
921 pcmbuf_write_complete(out_count
);
927 } /* codec_pcmbuf_insert_callback */
929 static void* codec_get_memory_callback(size_t *size
)
931 *size
= MALLOC_BUFSIZE
;
935 /* Between the codec and PCM track change, we need to keep updating the
936 "elapsed" value of the previous (to the codec, but current to the
937 user/PCM/WPS) track, so that the progressbar reaches the end.
938 During that transition, the WPS will display prevtrack_id3. */
939 static void codec_pcmbuf_position_callback(size_t size
) ICODE_ATTR
;
940 static void codec_pcmbuf_position_callback(size_t size
)
942 /* This is called from an ISR, so be quick */
943 unsigned int time
= size
* 1000 / 4 / NATIVE_FREQUENCY
+
944 prevtrack_id3
.elapsed
;
946 if (time
>= prevtrack_id3
.length
)
948 pcmbuf_set_position_callback(NULL
);
949 prevtrack_id3
.elapsed
= prevtrack_id3
.length
;
952 prevtrack_id3
.elapsed
= time
;
955 static void codec_set_elapsed_callback(unsigned int value
)
957 unsigned int latency
;
961 #ifdef AB_REPEAT_ENABLE
962 ab_position_report(value
);
965 latency
= pcmbuf_get_latency();
967 curtrack_id3
.elapsed
= 0;
968 else if (value
- latency
> curtrack_id3
.elapsed
||
969 value
- latency
< curtrack_id3
.elapsed
- 2)
971 curtrack_id3
.elapsed
= value
- latency
;
975 static void codec_set_offset_callback(size_t value
)
977 unsigned int latency
;
982 latency
= pcmbuf_get_latency() * curtrack_id3
.bitrate
/ 8;
984 curtrack_id3
.offset
= 0;
986 curtrack_id3
.offset
= value
- latency
;
989 static void codec_advance_buffer_counters(size_t amount
)
991 bufadvance(CUR_TI
->audio_hid
, amount
);
995 /* copy up-to size bytes into ptr and return the actual size copied */
996 static size_t codec_filebuf_callback(void *ptr
, size_t size
)
1000 if (ci
.stop_codec
|| !playing
)
1003 copy_n
= bufread(CUR_TI
->audio_hid
, size
, ptr
);
1005 /* Nothing requested OR nothing left */
1009 /* Update read and other position pointers */
1010 codec_advance_buffer_counters(copy_n
);
1012 /* Return the actual amount of data copied to the buffer */
1014 } /* codec_filebuf_callback */
1016 static void* codec_request_buffer_callback(size_t *realsize
, size_t reqsize
)
1018 size_t copy_n
= reqsize
;
1028 ret
= bufgetdata(CUR_TI
->audio_hid
, reqsize
, &ptr
);
1030 copy_n
= MIN((size_t)ret
, reqsize
);
1041 } /* codec_request_buffer_callback */
1043 static int get_codec_base_type(int type
)
1055 static void codec_advance_buffer_callback(size_t amount
)
1057 codec_advance_buffer_counters(amount
);
1058 codec_set_offset_callback(ci
.curpos
);
1061 static void codec_advance_buffer_loc_callback(void *ptr
)
1063 size_t amount
= buf_get_offset(CUR_TI
->audio_hid
, ptr
);
1064 codec_advance_buffer_callback(amount
);
1067 static void codec_seek_complete_callback(void)
1069 logf("seek_complete");
1070 if (pcm_is_paused())
1072 /* If this is not a seamless seek, clear the buffer */
1074 dsp_configure(ci
.dsp
, DSP_FLUSH
, 0);
1076 /* If playback was not 'deliberately' paused, unpause now */
1078 pcmbuf_pause(false);
1083 static bool codec_seek_buffer_callback(size_t newpos
)
1085 logf("codec_seek_buffer_callback");
1087 int ret
= bufseek(CUR_TI
->audio_hid
, newpos
);
1097 static void codec_configure_callback(int setting
, intptr_t value
)
1100 case CODEC_SET_FILEBUF_WATERMARK
:
1101 set_filebuf_watermark(buffer_margin
, value
);
1105 if (!dsp_configure(ci
.dsp
, setting
, value
))
1106 { logf("Illegal key:%d", setting
); }
1110 static void codec_track_changed(void)
1112 LOGFQUEUE("codec > audio Q_AUDIO_TRACK_CHANGED");
1113 queue_post(&audio_queue
, Q_AUDIO_TRACK_CHANGED
, 0);
1116 static void codec_pcmbuf_track_changed_callback(void)
1118 pcmbuf_set_position_callback(NULL
);
1119 pcmbuf_callback_queue_post(Q_AUDIO_TRACK_CHANGED
, 0);
1122 static void codec_discard_codec_callback(void)
1124 if (CUR_TI
->codec_hid
>= 0)
1126 bufclose(CUR_TI
->codec_hid
);
1127 CUR_TI
->codec_hid
= -1;
1131 static inline void codec_gapless_track_change(void)
1133 /* callback keeps the progress bar moving while the pcmbuf empties */
1134 pcmbuf_set_position_callback(codec_pcmbuf_position_callback
);
1135 /* set the pcmbuf callback for when the track really changes */
1136 pcmbuf_set_event_handler(codec_pcmbuf_track_changed_callback
);
1139 static inline void codec_crossfade_track_change(void)
1141 /* Initiate automatic crossfade mode */
1142 pcmbuf_crossfade_init(false);
1143 /* Notify the wps that the track change starts now */
1144 codec_track_changed();
1147 static void codec_track_skip_done(bool was_manual
)
1149 /* Manual track change (always crossfade or flush audio). */
1152 pcmbuf_crossfade_init(true);
1153 LOGFQUEUE("codec > audio Q_AUDIO_TRACK_CHANGED");
1154 queue_post(&audio_queue
, Q_AUDIO_TRACK_CHANGED
, 0);
1156 /* Automatic track change w/crossfade, if not in "Track Skip Only" mode. */
1157 else if (pcmbuf_is_crossfade_enabled() && !pcmbuf_is_crossfade_active()
1158 && global_settings
.crossfade
!= CROSSFADE_ENABLE_TRACKSKIP
)
1160 if (global_settings
.crossfade
== CROSSFADE_ENABLE_SHUFFLE_AND_TRACKSKIP
)
1162 if (global_settings
.playlist_shuffle
)
1163 /* shuffle mode is on, so crossfade: */
1164 codec_crossfade_track_change();
1166 /* shuffle mode is off, so do a gapless track change */
1167 codec_gapless_track_change();
1170 /* normal crossfade: */
1171 codec_crossfade_track_change();
1174 /* normal gapless playback. */
1175 codec_gapless_track_change();
1178 static bool codec_load_next_track(void)
1180 intptr_t result
= Q_CODEC_REQUEST_FAILED
;
1182 prev_track_elapsed
= curtrack_id3
.elapsed
;
1184 #ifdef AB_REPEAT_ENABLE
1185 ab_end_of_track_report();
1188 logf("Request new track");
1190 if (ci
.new_track
== 0)
1193 automatic_skip
= true;
1198 trigger_cpu_boost();
1199 LOGFQUEUE("codec >| audio Q_AUDIO_CHECK_NEW_TRACK");
1200 result
= queue_send(&audio_queue
, Q_AUDIO_CHECK_NEW_TRACK
, 0);
1205 case Q_CODEC_REQUEST_COMPLETE
:
1206 LOGFQUEUE("codec |< Q_CODEC_REQUEST_COMPLETE");
1207 codec_track_skip_done(!automatic_skip
);
1210 case Q_CODEC_REQUEST_FAILED
:
1211 LOGFQUEUE("codec |< Q_CODEC_REQUEST_FAILED");
1213 ci
.stop_codec
= true;
1214 codec_requested_stop
= true;
1218 LOGFQUEUE("codec |< default");
1219 ci
.stop_codec
= true;
1220 codec_requested_stop
= true;
1225 static bool codec_request_next_track_callback(void)
1229 if (ci
.stop_codec
|| !playing
)
1232 prev_codectype
= get_codec_base_type(curtrack_id3
.codectype
);
1234 if (!codec_load_next_track())
1237 /* Seek to the beginning of the new track because if the struct
1238 mp3entry was buffered, "elapsed" might not be zero (if the track has
1239 been played already but not unbuffered) */
1240 codec_seek_buffer_callback(curtrack_id3
.first_frame_offset
);
1242 /* Check if the next codec is the same file. */
1243 if (prev_codectype
== get_codec_base_type(curtrack_id3
.codectype
))
1245 logf("New track loaded");
1246 codec_discard_codec_callback();
1251 logf("New codec:%d/%d", curtrack_id3
.codectype
, prev_codectype
);
1256 static void codec_thread(void)
1258 struct queue_event ev
;
1264 if (!pcmbuf_is_crossfade_active()) {
1268 queue_wait(&codec_queue
, &ev
);
1269 codec_requested_stop
= false;
1272 case Q_CODEC_LOAD_DISK
:
1273 LOGFQUEUE("codec < Q_CODEC_LOAD_DISK");
1274 queue_reply(&codec_queue
, 1);
1275 audio_codec_loaded
= true;
1276 ci
.stop_codec
= false;
1277 status
= codec_load_file((const char *)ev
.data
, &ci
);
1281 LOGFQUEUE("codec < Q_CODEC_LOAD");
1282 if (CUR_TI
->codec_hid
< 0) {
1283 logf("Codec slot is empty!");
1284 /* Wait for the pcm buffer to go empty */
1285 while (pcm_is_playing())
1287 /* This must be set to prevent an infinite loop */
1288 ci
.stop_codec
= true;
1289 LOGFQUEUE("codec > codec Q_AUDIO_PLAY");
1290 queue_post(&codec_queue
, Q_AUDIO_PLAY
, 0);
1294 audio_codec_loaded
= true;
1295 ci
.stop_codec
= false;
1296 status
= codec_load_buf(CUR_TI
->codec_hid
, &ci
);
1299 #ifdef AUDIO_HAVE_RECORDING
1300 case Q_ENCODER_LOAD_DISK
:
1301 LOGFQUEUE("codec < Q_ENCODER_LOAD_DISK");
1302 audio_codec_loaded
= false; /* Not audio codec! */
1303 logf("loading encoder");
1304 ci
.stop_encoder
= false;
1305 status
= codec_load_file((const char *)ev
.data
, &ci
);
1306 logf("encoder stopped");
1308 #endif /* AUDIO_HAVE_RECORDING */
1311 LOGFQUEUE("codec < default");
1314 if (audio_codec_loaded
)
1323 audio_codec_loaded
= false;
1327 case Q_CODEC_LOAD_DISK
:
1329 LOGFQUEUE("codec < Q_CODEC_LOAD");
1332 if (ci
.new_track
|| status
!= CODEC_OK
)
1336 logf("Codec failure");
1337 gui_syncsplash(HZ
*2, "Codec failure");
1340 if (!codec_load_next_track())
1342 LOGFQUEUE("codec > audio Q_AUDIO_STOP");
1343 /* End of playlist */
1344 queue_post(&audio_queue
, Q_AUDIO_STOP
, 0);
1350 logf("Codec finished");
1353 /* Wait for the audio to stop playing before
1354 * triggering the WPS exit */
1355 while(pcm_is_playing())
1357 curtrack_id3
.elapsed
=
1358 curtrack_id3
.length
- pcmbuf_get_latency();
1362 if (codec_requested_stop
)
1364 LOGFQUEUE("codec > audio Q_AUDIO_STOP");
1365 queue_post(&audio_queue
, Q_AUDIO_STOP
, 0);
1371 if (CUR_TI
->codec_hid
>= 0)
1373 LOGFQUEUE("codec > codec Q_CODEC_LOAD");
1374 queue_post(&codec_queue
, Q_CODEC_LOAD
, 0);
1378 const char *codec_fn
=
1379 get_codec_filename(curtrack_id3
.codectype
);
1382 LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK");
1383 queue_post(&codec_queue
, Q_CODEC_LOAD_DISK
,
1384 (intptr_t)codec_fn
);
1390 #ifdef AUDIO_HAVE_RECORDING
1391 case Q_ENCODER_LOAD_DISK
:
1392 LOGFQUEUE("codec < Q_ENCODER_LOAD_DISK");
1394 if (status
== CODEC_OK
)
1397 logf("Encoder failure");
1398 gui_syncsplash(HZ
*2, "Encoder failure");
1400 if (ci
.enc_codec_loaded
< 0)
1403 logf("Encoder failed to load");
1404 ci
.enc_codec_loaded
= -1;
1406 #endif /* AUDIO_HAVE_RECORDING */
1409 LOGFQUEUE("codec < default");
1416 /* --- Buffering callbacks --- */
1418 static void buffering_low_buffer_callback(void *data
)
1421 logf("low buffer callback");
1423 if (filling
== STATE_FULL
|| filling
== STATE_END_OF_PLAYLIST
) {
1424 /* force a refill */
1425 LOGFQUEUE("buffering > audio Q_AUDIO_FILL_BUFFER");
1426 queue_post(&audio_queue
, Q_AUDIO_FILL_BUFFER
, 0);
1430 static void buffering_handle_rebuffer_callback(void *data
)
1433 LOGFQUEUE("audio >| audio Q_AUDIO_FLUSH");
1434 queue_post(&audio_queue
, Q_AUDIO_FLUSH
, 0);
1437 static void buffering_handle_finished_callback(int *data
)
1439 logf("handle %d finished buffering", *data
);
1441 if (*data
== tracks
[track_widx
].id3_hid
)
1443 /* The metadata handle for the last loaded track has been buffered.
1444 We can ask the audio thread to load the rest of the track's data. */
1445 LOGFQUEUE("audio >| audio Q_AUDIO_FINISH_LOAD");
1446 queue_post(&audio_queue
, Q_AUDIO_FINISH_LOAD
, 0);
1450 /* This is most likely an audio handle, so we strip the useless
1451 trailing tags that are left. */
1454 if (*data
== tracks
[track_widx
-1].audio_hid
1455 && filling
== STATE_END_OF_PLAYLIST
)
1457 /* This was the last track in the playlist.
1458 We now have all the data we need. */
1459 logf("last track finished buffering");
1460 filling
= STATE_FINISHED
;
1466 /* --- Audio thread --- */
1468 static bool audio_have_tracks(void)
1470 return (audio_track_count() != 0);
1473 static int audio_free_track_count(void)
1475 /* Used tracks + free tracks adds up to MAX_TRACK - 1 */
1476 return MAX_TRACK
- 1 - audio_track_count();
1479 int audio_track_count(void)
1481 /* Calculate difference from track_ridx to track_widx
1482 * taking into account a possible wrap-around. */
1483 return (MAX_TRACK
+ track_widx
- track_ridx
) & MAX_TRACK_MASK
;
1486 long audio_filebufused(void)
1488 return (long) buf_used();
1491 /* Update track info after successful a codec track change */
1492 static void audio_update_trackinfo(void)
1494 /* Load the curent track's metadata into curtrack_id3 */
1495 if (CUR_TI
->id3_hid
>= 0)
1496 copy_mp3entry(&curtrack_id3
, bufgetid3(CUR_TI
->id3_hid
));
1498 /* Reset current position */
1499 curtrack_id3
.elapsed
= 0;
1500 curtrack_id3
.offset
= 0;
1502 /* Update the codec API */
1503 ci
.filesize
= CUR_TI
->filesize
;
1504 ci
.id3
= &curtrack_id3
;
1506 ci
.taginfo_ready
= &CUR_TI
->taginfo_ready
;
1509 /* Clear tracks between write and read, non inclusive */
1510 static void audio_clear_track_entries(void)
1512 int cur_idx
= track_widx
;
1514 logf("Clearing tracks:%d/%d", track_ridx
, track_widx
);
1516 /* Loop over all tracks from write-to-read */
1519 cur_idx
= (cur_idx
+ 1) & MAX_TRACK_MASK
;
1521 if (cur_idx
== track_ridx
)
1524 clear_track_info(&tracks
[cur_idx
]);
1528 /* Clear all tracks */
1529 static bool audio_release_tracks(void)
1533 logf("releasing all tracks");
1535 for(i
= 0; i
< MAX_TRACK
; i
++)
1537 cur_idx
= (track_ridx
+ i
) & MAX_TRACK_MASK
;
1538 if (!clear_track_info(&tracks
[cur_idx
]))
1545 static bool audio_loadcodec(bool start_play
)
1548 char codec_path
[MAX_PATH
]; /* Full path to codec */
1549 const struct mp3entry
*id3
, *prev_id3
;
1551 if (tracks
[track_widx
].id3_hid
< 0) {
1555 id3
= bufgetid3(tracks
[track_widx
].id3_hid
);
1559 const char *codec_fn
= get_codec_filename(id3
->codectype
);
1560 if (codec_fn
== NULL
)
1563 tracks
[track_widx
].codec_hid
= -1;
1567 /* Load the codec directly from disk and save some memory. */
1568 track_ridx
= track_widx
;
1569 ci
.filesize
= CUR_TI
->filesize
;
1570 ci
.id3
= &curtrack_id3
;
1571 ci
.taginfo_ready
= &CUR_TI
->taginfo_ready
;
1573 LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK");
1574 queue_post(&codec_queue
, Q_CODEC_LOAD_DISK
, (intptr_t)codec_fn
);
1579 /* If we already have another track than this one buffered */
1580 if (track_widx
!= track_ridx
)
1582 prev_track
= (track_widx
- 1) & MAX_TRACK_MASK
;
1584 id3
= bufgetid3(tracks
[track_widx
].id3_hid
);
1585 prev_id3
= bufgetid3(tracks
[prev_track
].id3_hid
);
1587 /* If the previous codec is the same as this one, there is no need
1588 * to put another copy of it on the file buffer */
1589 if (id3
&& prev_id3
&&
1590 get_codec_base_type(id3
->codectype
) ==
1591 get_codec_base_type(prev_id3
->codectype
)
1592 && audio_codec_loaded
)
1594 logf("Reusing prev. codec");
1600 codec_get_full_path(codec_path
, codec_fn
);
1602 tracks
[track_widx
].codec_hid
= bufopen(codec_path
, 0, TYPE_CODEC
);
1603 if (tracks
[track_widx
].codec_hid
< 0)
1606 logf("Loaded codec");
1611 /* Load metadata for the next track (with bufopen). The rest of the track
1612 loading will be handled by audio_finish_load_track once the metadata has been
1613 actually loaded by the buffering thread. */
1614 static bool audio_load_track(size_t offset
, bool start_play
)
1616 const char *trackname
;
1619 if (track_load_started
) {
1620 /* There is already a track load in progress, so track_widx hasn't been
1621 incremented yet. Loading another track would overwrite the one that
1622 hasn't finished loading. */
1623 logf("audio_load_track(): a track load is already in progress");
1627 start_play_g
= start_play
; /* will be read by audio_finish_load_track */
1629 /* Stop buffer filling if there is no free track entries.
1630 Don't fill up the last track entry (we wan't to store next track
1632 if (!audio_free_track_count())
1634 logf("No free tracks");
1639 tracks
[track_widx
].taginfo_ready
= false;
1641 logf("Buffering track:%d/%d", track_widx
, track_ridx
);
1642 /* Get track name from current playlist read position. */
1643 while ((trackname
= playlist_peek(last_peek_offset
)) != NULL
)
1645 /* Handle broken playlists. */
1646 fd
= open(trackname
, O_RDONLY
);
1649 logf("Open failed");
1650 /* Skip invalid entry from playlist. */
1651 playlist_skip_entry(NULL
, last_peek_offset
);
1659 logf("End-of-playlist");
1660 memset(&lasttrack_id3
, 0, sizeof(struct mp3entry
));
1661 filling
= STATE_END_OF_PLAYLIST
;
1665 tracks
[track_widx
].filesize
= filesize(fd
);
1667 if (offset
> tracks
[track_widx
].filesize
)
1670 /* Set default values */
1673 buf_set_watermark(AUDIO_DEFAULT_WATERMARK
);
1674 dsp_configure(ci
.dsp
, DSP_RESET
, 0);
1675 track_changed
= true;
1676 playlist_update_resume_info(audio_current_track());
1679 /* Get track metadata if we don't already have it. */
1680 if (tracks
[track_widx
].id3_hid
< 0)
1682 tracks
[track_widx
].id3_hid
= bufopen(trackname
, 0, TYPE_ID3
);
1684 if (tracks
[track_widx
].id3_hid
< 0)
1686 /* Buffer is full. */
1687 get_metadata(&lasttrack_id3
, fd
, trackname
);
1690 logf("buffer is full for now");
1691 filling
= STATE_FULL
;
1695 if (track_widx
== track_ridx
)
1697 buf_request_buffer_handle(tracks
[track_widx
].id3_hid
);
1698 copy_mp3entry(&curtrack_id3
, bufgetid3(tracks
[track_widx
].id3_hid
));
1699 curtrack_id3
.offset
= offset
;
1704 track_changed
= true;
1705 playlist_update_resume_info(audio_current_track());
1710 track_load_started
= true; /* Remember that we've started loading a track */
1714 /* Second part of the track loading: We now have the metadata available, so we
1715 can load the codec, the album art and finally the audio data.
1716 This is called on the audio thread after the buffering thread calls the
1717 buffering_handle_finished_callback callback. */
1718 static void audio_finish_load_track(void)
1721 size_t file_offset
= 0;
1723 bool start_play
= start_play_g
;
1726 if (cuesheet_is_enabled() && tracks
[track_widx
].id3
.cuesheet_type
== 1)
1728 char cuepath
[MAX_PATH
];
1730 struct cuesheet
*cue
= start_play
? curr_cue
: temp_cue
;
1732 if (look_for_cuesheet_file(trackname
, cuepath
) &&
1733 parse_cuesheet(cuepath
, cue
))
1735 strcpy((cue
)->audio_filename
, trackname
);
1737 cue_spoof_id3(curr_cue
, &tracks
[track_widx
].id3
);
1742 track_load_started
= false;
1744 if (tracks
[track_widx
].id3_hid
< 0) {
1745 logf("no metatdata");
1749 struct mp3entry
*track_id3
;
1751 if (track_widx
== track_ridx
)
1752 track_id3
= &curtrack_id3
;
1754 track_id3
= bufgetid3(tracks
[track_widx
].id3_hid
);
1756 if (track_id3
->length
== 0 && track_id3
->filesize
== 0)
1758 logf("audio_finish_load_track: invalid metadata");
1760 /* Invalid metadata */
1761 bufclose(tracks
[track_widx
].id3_hid
);
1762 tracks
[track_widx
].id3_hid
= -1;
1764 /* Skip invalid entry from playlist. */
1765 playlist_skip_entry(NULL
, last_peek_offset
--);
1767 /* load next track */
1768 LOGFQUEUE("audio > audio Q_AUDIO_FILL_BUFFER %d", (int)start_play
);
1769 queue_post(&audio_queue
, Q_AUDIO_FILL_BUFFER
, start_play
);
1774 #ifdef HAVE_ALBUMART
1775 if (tracks
[track_widx
].aa_hid
< 0 && gui_sync_wps_uses_albumart())
1777 char aa_path
[MAX_PATH
];
1778 if (find_albumart(track_id3
, aa_path
, sizeof(aa_path
)))
1779 tracks
[track_widx
].aa_hid
= bufopen(aa_path
, 0, TYPE_BITMAP
);
1783 /* Load the codec. */
1784 if (!audio_loadcodec(start_play
))
1786 if (tracks
[track_widx
].codec_hid
== ERR_BUFFER_FULL
)
1788 /* No space for codec on buffer, not an error */
1792 /* This is an error condition, either no codec was found, or reading
1793 * the codec file failed part way through, either way, skip the track */
1794 snprintf(msgbuf
, sizeof(msgbuf
)-1, "No codec for: %s", track_id3
->path
);
1795 /* We should not use gui_syncplash from audio thread! */
1796 gui_syncsplash(HZ
*2, msgbuf
);
1797 /* Skip invalid entry from playlist. */
1798 playlist_skip_entry(NULL
, last_peek_offset
);
1802 track_id3
->elapsed
= 0;
1803 offset
= track_id3
->offset
;
1805 enum data_type type
= TYPE_PACKET_AUDIO
;
1807 switch (track_id3
->codectype
) {
1812 file_offset
= offset
;
1813 track_id3
->offset
= offset
;
1819 file_offset
= offset
;
1820 track_id3
->offset
= offset
;
1821 track_id3
->elapsed
= track_id3
->length
/ 2;
1825 case AFMT_OGG_VORBIS
:
1835 track_id3
->offset
= offset
;
1841 logf("Loading atomic %d",track_id3
->codectype
);
1842 type
= TYPE_ATOMIC_AUDIO
;
1846 logf("alt:%s", track_id3
->path
);
1848 if (file_offset
> AUDIO_REBUFFER_GUESS_SIZE
)
1849 file_offset
-= AUDIO_REBUFFER_GUESS_SIZE
;
1850 else if (track_id3
->first_frame_offset
)
1851 file_offset
= track_id3
->first_frame_offset
;
1855 tracks
[track_widx
].audio_hid
= bufopen(track_id3
->path
, file_offset
, type
);
1857 if (tracks
[track_widx
].audio_hid
< 0)
1860 /* All required data is now available for the codec. */
1861 tracks
[track_widx
].taginfo_ready
= true;
1865 ci
.curpos
=file_offset
;
1866 buf_request_buffer_handle(tracks
[track_widx
].audio_hid
);
1869 track_widx
= (track_widx
+ 1) & MAX_TRACK_MASK
;
1871 send_event(PLAYBACK_EVENT_TRACK_BUFFER
, track_id3
);
1873 /* load next track */
1874 LOGFQUEUE("audio > audio Q_AUDIO_FILL_BUFFER");
1875 queue_post(&audio_queue
, Q_AUDIO_FILL_BUFFER
, 0);
1880 static void audio_fill_file_buffer(bool start_play
, size_t offset
)
1882 bool had_next_track
= audio_next_track() != NULL
;
1884 filling
= STATE_FILLING
;
1885 trigger_cpu_boost();
1887 /* No need to rebuffer if there are track skips pending. */
1888 if (ci
.new_track
!= 0)
1891 /* Must reset the buffer before use if trashed or voice only - voice
1892 file size shouldn't have changed so we can go straight from
1893 BUFFER_STATE_VOICED_ONLY to BUFFER_STATE_INITIALIZED */
1894 if (buffer_state
!= BUFFER_STATE_INITIALIZED
)
1895 audio_reset_buffer();
1897 logf("Starting buffer fill");
1900 audio_clear_track_entries();
1902 /* Save the current resume position once. */
1903 playlist_update_resume_info(audio_current_track());
1905 audio_load_track(offset
, start_play
);
1907 if (!had_next_track
&& audio_next_track())
1908 track_changed
= true;
1911 static void audio_rebuffer(void)
1913 logf("Forcing rebuffer");
1915 clear_track_info(CUR_TI
);
1917 /* Reset track pointers */
1918 track_widx
= track_ridx
;
1919 audio_clear_track_entries();
1921 /* Reset a possibly interrupted track load */
1922 track_load_started
= false;
1924 /* Fill the buffer */
1925 last_peek_offset
= -1;
1928 if (!CUR_TI
->taginfo_ready
)
1929 memset(&curtrack_id3
, 0, sizeof(struct mp3entry
));
1931 audio_fill_file_buffer(false, 0);
1934 /* Called on request from the codec to get a new track. This is the codec part
1935 of the track transition. */
1936 static int audio_check_new_track(void)
1938 int track_count
= audio_track_count();
1939 int old_track_ridx
= track_ridx
;
1943 /* Now it's good time to send track finish events. */
1944 send_event(PLAYBACK_EVENT_TRACK_FINISH
, &curtrack_id3
);
1948 if (playlist_next_dir(ci
.new_track
))
1956 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1957 return Q_CODEC_REQUEST_FAILED
;
1964 /* If the playlist isn't that big */
1967 while (!playlist_check(ci
.new_track
))
1969 if (ci
.new_track
>= 0)
1971 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1972 return Q_CODEC_REQUEST_FAILED
;
1978 /* Update the playlist */
1979 last_peek_offset
-= ci
.new_track
;
1981 if (playlist_next(ci
.new_track
) < 0)
1983 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1984 return Q_CODEC_REQUEST_FAILED
;
1990 new_playlist
= false;
1993 /* Save the track metadata to allow the WPS to display it
1994 while PCM finishes playing that track */
1995 copy_mp3entry(&prevtrack_id3
, &curtrack_id3
);
1997 /* Update the main buffer copy of the track metadata with the one
1998 the codec has been using (for the unbuffer callbacks) */
1999 if (CUR_TI
->id3_hid
>= 0)
2000 copy_mp3entry(bufgetid3(CUR_TI
->id3_hid
), &curtrack_id3
);
2002 /* Save a pointer to the old track to allow later clearing */
2005 for (i
= 0; i
< ci
.new_track
; i
++)
2007 idx
= (track_ridx
+ i
) & MAX_TRACK_MASK
;
2008 struct mp3entry
*id3
= bufgetid3(tracks
[idx
].id3_hid
);
2009 ssize_t offset
= buf_handle_offset(tracks
[idx
].audio_hid
);
2010 if (!id3
|| offset
< 0 || (unsigned)offset
> id3
->first_frame_offset
)
2012 /* We don't have all the audio data for that track, so clear it,
2013 but keep the metadata. */
2014 if (tracks
[idx
].audio_hid
>= 0 && bufclose(tracks
[idx
].audio_hid
))
2016 tracks
[idx
].audio_hid
= -1;
2017 tracks
[idx
].filesize
= 0;
2022 /* Move to the new track */
2023 track_ridx
= (track_ridx
+ ci
.new_track
) & MAX_TRACK_MASK
;
2025 buf_set_base_handle(CUR_TI
->audio_hid
);
2029 wps_offset
= -ci
.new_track
;
2030 track_changed
= true;
2033 /* If it is not safe to even skip this many track entries */
2034 if (ci
.new_track
>= track_count
|| ci
.new_track
<= track_count
- MAX_TRACK
)
2041 forward
= ci
.new_track
> 0;
2044 /* If the target track is clearly not in memory */
2045 if (CUR_TI
->filesize
== 0 || !CUR_TI
->taginfo_ready
)
2051 /* When skipping backwards, it is possible that we've found a track that's
2052 * buffered, but which is around the track-wrap and therefore not the track
2053 * we are looking for */
2056 int cur_idx
= track_ridx
;
2057 bool taginfo_ready
= true;
2058 /* We've wrapped the buffer backwards if new > old */
2059 bool wrap
= track_ridx
> old_track_ridx
;
2063 cur_idx
= (cur_idx
+ 1) & MAX_TRACK_MASK
;
2065 /* if we've advanced past the wrap when cur_idx is zeroed */
2069 /* if we aren't still on the wrap and we've caught the old track */
2070 if (!(wrap
|| cur_idx
< old_track_ridx
))
2073 /* If we hit a track in between without valid tag info, bail */
2074 if (!tracks
[cur_idx
].taginfo_ready
)
2076 taginfo_ready
= false;
2087 audio_update_trackinfo();
2088 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_COMPLETE");
2089 return Q_CODEC_REQUEST_COMPLETE
;
2092 unsigned long audio_prev_elapsed(void)
2094 return prev_track_elapsed
;
2097 static void audio_stop_codec_flush(void)
2099 ci
.stop_codec
= true;
2102 while (audio_codec_loaded
)
2105 /* If the audio codec is not loaded any more, and the audio is still
2106 * playing, it is now and _only_ now safe to call this function from the
2108 if (pcm_is_playing())
2111 pcmbuf_queue_clear();
2113 pcmbuf_pause(paused
);
2116 static void audio_stop_playback(void)
2118 /* If we were playing, save resume information */
2121 struct mp3entry
*id3
= NULL
;
2125 /* Set this early, the outside code yields and may allow the codec
2126 to try to wait for a reply on a buffer wait */
2127 ci
.stop_codec
= true;
2128 id3
= audio_current_track();
2131 /* Save the current playing spot, or NULL if the playlist has ended */
2132 playlist_update_resume_info(id3
);
2134 /* TODO: Create auto bookmark too? */
2136 prev_track_elapsed
= curtrack_id3
.elapsed
;
2138 remove_event(EVENT_BUFFER_LOW
, buffering_low_buffer_callback
);
2142 audio_stop_codec_flush();
2144 track_load_started
= false;
2146 filling
= STATE_IDLE
;
2148 /* Mark all entries null. */
2149 audio_clear_track_entries();
2151 /* Close all tracks */
2152 audio_release_tracks();
2154 memset(&curtrack_id3
, 0, sizeof(struct mp3entry
));
2157 static void audio_play_start(size_t offset
)
2161 #if INPUT_SRC_CAPS != 0
2162 audio_set_input_source(AUDIO_SRC_PLAYBACK
, SRCF_PLAYBACK
);
2163 audio_set_output_source(AUDIO_SRC_PLAYBACK
);
2166 /* Wait for any previously playing audio to flush - TODO: Not necessary? */
2168 audio_stop_codec_flush();
2170 track_changed
= true;
2173 track_load_started
= false;
2179 sound_set_volume(global_settings
.volume
);
2180 track_widx
= track_ridx
= 0;
2182 /* Clear all track entries. */
2183 for (i
= 0; i
< MAX_TRACK
; i
++) {
2184 clear_track_info(&tracks
[i
]);
2187 last_peek_offset
= -1;
2189 /* Officially playing */
2190 queue_reply(&audio_queue
, 1);
2192 #ifndef HAVE_FLASH_STORAGE
2193 set_filebuf_watermark(buffer_margin
, 0);
2196 audio_fill_file_buffer(true, offset
);
2198 add_event(EVENT_BUFFER_LOW
, false, buffering_low_buffer_callback
);
2200 LOGFQUEUE("audio > audio Q_AUDIO_TRACK_CHANGED");
2201 queue_post(&audio_queue
, Q_AUDIO_TRACK_CHANGED
, 0);
2205 /* Invalidates all but currently playing track. */
2206 static void audio_invalidate_tracks(void)
2208 if (audio_have_tracks())
2210 last_peek_offset
= 0;
2211 track_widx
= track_ridx
;
2213 /* Mark all other entries null (also buffered wrong metadata). */
2214 audio_clear_track_entries();
2216 track_widx
= (track_widx
+ 1) & MAX_TRACK_MASK
;
2218 audio_fill_file_buffer(false, 0);
2222 static void audio_new_playlist(void)
2224 /* Prepare to start a new fill from the beginning of the playlist */
2225 last_peek_offset
= -1;
2226 if (audio_have_tracks())
2229 skipped_during_pause
= true;
2230 track_widx
= track_ridx
;
2231 audio_clear_track_entries();
2233 track_widx
= (track_widx
+ 1) & MAX_TRACK_MASK
;
2235 /* Mark the current track as invalid to prevent skipping back to it */
2236 CUR_TI
->taginfo_ready
= false;
2239 /* Signal the codec to initiate a track change forward */
2240 new_playlist
= true;
2243 /* Officially playing */
2244 queue_reply(&audio_queue
, 1);
2246 audio_fill_file_buffer(false, 0);
2249 /* Called on manual track skip */
2250 static void audio_initiate_track_change(long direction
)
2252 logf("audio_initiate_track_change(%ld)", direction
);
2254 ci
.new_track
+= direction
;
2255 wps_offset
-= direction
;
2257 skipped_during_pause
= true;
2260 /* Called on manual dir skip */
2261 static void audio_initiate_dir_change(long direction
)
2264 ci
.new_track
= direction
;
2266 skipped_during_pause
= true;
2269 /* Called when PCM track change is complete */
2270 static void audio_finalise_track_change(void)
2272 logf("audio_finalise_track_change");
2277 automatic_skip
= false;
2279 /* Invalidate prevtrack_id3 */
2280 prevtrack_id3
.path
[0] = 0;
2282 if (prev_ti
&& prev_ti
->audio_hid
< 0)
2284 /* No audio left so we clear all the track info. */
2285 clear_track_info(prev_ti
);
2288 if (prev_ti
&& prev_ti
->id3_hid
>= 0)
2290 /* Reset the elapsed time to force the progressbar to be empty if
2291 the user skips back to this track */
2292 bufgetid3(prev_ti
->id3_hid
)->elapsed
= 0;
2296 send_event(PLAYBACK_EVENT_TRACK_CHANGE
, &curtrack_id3
);
2298 track_changed
= true;
2299 playlist_update_resume_info(audio_current_track());
2303 * Layout audio buffer as follows - iram buffer depends on target:
2304 * [|SWAP:iram][|TALK]|MALLOC|FILE|GUARD|PCM|[SWAP:dram[|iram]|]
2306 static void audio_reset_buffer(void)
2308 /* see audio_get_recording_buffer if this is modified */
2309 logf("audio_reset_buffer");
2311 /* If the setup of anything allocated before the file buffer is
2312 changed, do check the adjustments after the buffer_alloc call
2313 as it will likely be affected and need sliding over */
2315 /* Initially set up file buffer as all space available */
2316 malloc_buf
= audiobuf
+ talk_get_bufsize();
2317 /* Align the malloc buf to line size. Especially important to cf
2318 targets that do line reads/writes. */
2319 malloc_buf
= (unsigned char *)(((uintptr_t)malloc_buf
+ 15) & ~15);
2320 filebuf
= malloc_buf
+ MALLOC_BUFSIZE
; /* filebuf line align implied */
2321 filebuflen
= audiobufend
- filebuf
;
2325 /* Subtract whatever the pcm buffer says it used plus the guard buffer */
2326 filebuflen
-= pcmbuf_init(filebuf
+ filebuflen
) + GUARD_BUFSIZE
;
2328 /* Make sure filebuflen is a longword multiple after adjustment - filebuf
2329 will already be line aligned */
2332 buffering_reset(filebuf
, filebuflen
);
2334 /* Clear any references to the file buffer */
2335 buffer_state
= BUFFER_STATE_INITIALIZED
;
2337 #if defined(ROCKBOX_HAS_LOGF) && defined(LOGF_ENABLE)
2338 /* Make sure everything adds up - yes, some info is a bit redundant but
2339 aids viewing and the sumation of certain variables should add up to
2340 the location of others. */
2343 const unsigned char *pcmbuf
= pcmbuf_get_meminfo(&pcmbufsize
);
2344 logf("mabuf: %08X", (unsigned)malloc_buf
);
2345 logf("mabufe: %08X", (unsigned)(malloc_buf
+ MALLOC_BUFSIZE
));
2346 logf("fbuf: %08X", (unsigned)filebuf
);
2347 logf("fbufe: %08X", (unsigned)(filebuf
+ filebuflen
));
2348 logf("gbuf: %08X", (unsigned)(filebuf
+ filebuflen
));
2349 logf("gbufe: %08X", (unsigned)(filebuf
+ filebuflen
+ GUARD_BUFSIZE
));
2350 logf("pcmb: %08X", (unsigned)pcmbuf
);
2351 logf("pcmbe: %08X", (unsigned)(pcmbuf
+ pcmbufsize
));
2356 static void audio_thread(void)
2358 struct queue_event ev
;
2362 audio_thread_ready
= true;
2366 if (filling
!= STATE_FILLING
) {
2370 if (!pcmbuf_queue_scan(&ev
))
2371 queue_wait_w_tmo(&audio_queue
, &ev
, HZ
/2);
2375 case Q_AUDIO_FILL_BUFFER
:
2376 LOGFQUEUE("audio < Q_AUDIO_FILL_BUFFER %d", (int)ev
.data
);
2377 audio_fill_file_buffer((bool)ev
.data
, 0);
2380 case Q_AUDIO_FINISH_LOAD
:
2381 LOGFQUEUE("audio < Q_AUDIO_FINISH_LOAD");
2382 audio_finish_load_track();
2386 LOGFQUEUE("audio < Q_AUDIO_PLAY");
2387 if (playing
&& ev
.data
<= 0)
2388 audio_new_playlist();
2391 audio_stop_playback();
2392 audio_play_start((size_t)ev
.data
);
2397 LOGFQUEUE("audio < Q_AUDIO_STOP");
2399 audio_stop_playback();
2401 queue_clear(&audio_queue
);
2405 LOGFQUEUE("audio < Q_AUDIO_PAUSE");
2406 if (!(bool) ev
.data
&& skipped_during_pause
&& !pcmbuf_is_crossfade_active())
2407 pcmbuf_play_stop(); /* Flush old track on resume after skip */
2408 skipped_during_pause
= false;
2411 pcmbuf_pause((bool)ev
.data
);
2412 paused
= (bool)ev
.data
;
2416 LOGFQUEUE("audio < Q_AUDIO_SKIP");
2417 audio_initiate_track_change((long)ev
.data
);
2420 case Q_AUDIO_PRE_FF_REWIND
:
2421 LOGFQUEUE("audio < Q_AUDIO_PRE_FF_REWIND");
2427 case Q_AUDIO_FF_REWIND
:
2428 LOGFQUEUE("audio < Q_AUDIO_FF_REWIND");
2433 /* An automatic track skip is in progress. Finalize it,
2434 then go back to the previous track */
2435 audio_finalise_track_change();
2438 ci
.seek_time
= (long)ev
.data
+1;
2441 case Q_AUDIO_CHECK_NEW_TRACK
:
2442 LOGFQUEUE("audio < Q_AUDIO_CHECK_NEW_TRACK");
2443 queue_reply(&audio_queue
, audio_check_new_track());
2446 case Q_AUDIO_DIR_SKIP
:
2447 LOGFQUEUE("audio < Q_AUDIO_DIR_SKIP");
2448 audio_initiate_dir_change(ev
.data
);
2452 LOGFQUEUE("audio < Q_AUDIO_FLUSH");
2453 audio_invalidate_tracks();
2456 case Q_AUDIO_TRACK_CHANGED
:
2457 /* PCM track change done */
2458 LOGFQUEUE("audio < Q_AUDIO_TRACK_CHANGED");
2459 audio_finalise_track_change();
2463 case SYS_USB_CONNECTED
:
2464 LOGFQUEUE("audio < SYS_USB_CONNECTED");
2466 audio_stop_playback();
2467 #ifdef PLAYBACK_VOICE
2470 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
2471 usb_wait_for_disconnect(&audio_queue
);
2473 /* Mark all entries null. */
2474 audio_clear_track_entries();
2476 /* release tracks to make sure all handles are closed */
2477 audio_release_tracks();
2482 LOGFQUEUE_SYS_TIMEOUT("audio < SYS_TIMEOUT");
2486 LOGFQUEUE("audio < default");
2492 /* Initialize the audio system - called from init() in main.c.
2493 * Last function because of all the references to internal symbols
2495 void audio_init(void)
2497 struct thread_entry
*audio_thread_p
;
2499 /* Can never do this twice */
2500 if (audio_is_initialized
)
2502 logf("audio: already initialized");
2506 logf("audio: initializing");
2508 /* Initialize queues before giving control elsewhere in case it likes
2509 to send messages. Thread creation will be delayed however so nothing
2510 starts running until ready if something yields such as talk_init. */
2511 queue_init(&audio_queue
, true);
2512 queue_init(&codec_queue
, false);
2513 queue_init(&pcmbuf_queue
, false);
2517 /* Initialize codec api. */
2518 ci
.read_filebuf
= codec_filebuf_callback
;
2519 ci
.pcmbuf_insert
= codec_pcmbuf_insert_callback
;
2520 ci
.get_codec_memory
= codec_get_memory_callback
;
2521 ci
.request_buffer
= codec_request_buffer_callback
;
2522 ci
.advance_buffer
= codec_advance_buffer_callback
;
2523 ci
.advance_buffer_loc
= codec_advance_buffer_loc_callback
;
2524 ci
.request_next_track
= codec_request_next_track_callback
;
2525 ci
.seek_buffer
= codec_seek_buffer_callback
;
2526 ci
.seek_complete
= codec_seek_complete_callback
;
2527 ci
.set_elapsed
= codec_set_elapsed_callback
;
2528 ci
.set_offset
= codec_set_offset_callback
;
2529 ci
.configure
= codec_configure_callback
;
2530 ci
.discard_codec
= codec_discard_codec_callback
;
2531 ci
.dsp
= (struct dsp_config
*)dsp_configure(NULL
, DSP_MYDSP
,
2534 /* initialize the buffer */
2537 /* audio_reset_buffer must to know the size of voice buffer so init
2541 codec_thread_p
= create_thread(
2542 codec_thread
, codec_stack
, sizeof(codec_stack
),
2543 CREATE_THREAD_FROZEN
,
2544 codec_thread_name
IF_PRIO(, PRIORITY_PLAYBACK
)
2547 queue_enable_queue_send(&codec_queue
, &codec_queue_sender_list
,
2550 audio_thread_p
= create_thread(audio_thread
, audio_stack
,
2551 sizeof(audio_stack
), CREATE_THREAD_FROZEN
,
2552 audio_thread_name
IF_PRIO(, PRIORITY_USER_INTERFACE
)
2555 queue_enable_queue_send(&audio_queue
, &audio_queue_sender_list
,
2558 #ifdef PLAYBACK_VOICE
2559 voice_thread_init();
2562 /* Set crossfade setting for next buffer init which should be about... */
2563 pcmbuf_crossfade_enable(global_settings
.crossfade
);
2565 /* initialize the buffering system */
2568 /* ...now! Set up the buffers */
2569 audio_reset_buffer();
2572 for(i
= 0; i
< MAX_TRACK
; i
++)
2574 tracks
[i
].audio_hid
= -1;
2575 tracks
[i
].id3_hid
= -1;
2576 tracks
[i
].codec_hid
= -1;
2577 #ifdef HAVE_ALBUMART
2578 tracks
[i
].aa_hid
= -1;
2582 add_event(EVENT_HANDLE_REBUFFER
, false, buffering_handle_rebuffer_callback
);
2583 add_event(EVENT_HANDLE_FINISHED
, false, buffering_handle_finished_callback
);
2585 /* Probably safe to say */
2586 audio_is_initialized
= true;
2588 sound_settings_apply();
2589 #ifndef HAVE_FLASH_STORAGE
2590 audio_set_buffer_margin(global_settings
.buffer_margin
);
2593 /* it's safe to let the threads run now */
2594 #ifdef PLAYBACK_VOICE
2595 voice_thread_resume();
2597 thread_thaw(codec_thread_p
);
2598 thread_thaw(audio_thread_p
);
2602 bool audio_is_thread_ready(void)
2604 return audio_thread_ready
;