1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2005-2007 Miika Pekkarinen
11 * Copyright (C) 2007-2008 Nicolas Pennequin
13 * All files in this archive are subject to the GNU General Public License.
14 * See the file COPYING in the source tree root for full license agreement.
16 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
17 * KIND, either express or implied.
19 ****************************************************************************/
21 /* TODO: Pause should be handled in here, rather than PCMBUF so that voice can
22 * play whilst audio is paused */
44 #include "buffering.h"
46 #include "voice_thread.h"
47 #include "mp3_playback.h"
62 #ifdef HAVE_LCD_BITMAP
64 #include "peakmeter.h"
75 #include "ata_idle_notify.h"
78 #include "recording.h"
82 #define PLAYBACK_VOICE
84 /* default point to start buffer refill */
85 #define AUDIO_DEFAULT_WATERMARK (1024*512)
86 /* amount of guess-space to allow for codecs that must hunt and peck
87 * for their correct seeek target, 32k seems a good size */
88 #define AUDIO_REBUFFER_GUESS_SIZE (1024*32)
90 /* Define LOGF_ENABLE to enable logf output in this file */
91 /*#define LOGF_ENABLE*/
94 /* macros to enable logf for queues
95 logging on SYS_TIMEOUT can be disabled */
97 /* Define this for logf output of all queuing except SYS_TIMEOUT */
98 #define PLAYBACK_LOGQUEUES
99 /* Define this to logf SYS_TIMEOUT messages */
100 /*#define PLAYBACK_LOGQUEUES_SYS_TIMEOUT*/
103 #ifdef PLAYBACK_LOGQUEUES
104 #define LOGFQUEUE logf
106 #define LOGFQUEUE(...)
109 #ifdef PLAYBACK_LOGQUEUES_SYS_TIMEOUT
110 #define LOGFQUEUE_SYS_TIMEOUT logf
112 #define LOGFQUEUE_SYS_TIMEOUT(...)
116 /* Define one constant that includes recording related functionality */
117 #if defined(HAVE_RECORDING) && !defined(SIMULATOR)
118 #define AUDIO_HAVE_RECORDING
127 Q_AUDIO_PRE_FF_REWIND
,
129 Q_AUDIO_CHECK_NEW_TRACK
,
131 Q_AUDIO_TRACK_CHANGED
,
136 Q_CODEC_REQUEST_COMPLETE
,
137 Q_CODEC_REQUEST_FAILED
,
142 #ifdef AUDIO_HAVE_RECORDING
149 STATE_IDLE
, /* audio is stopped: nothing to do */
150 STATE_FILLING
, /* adding tracks to the buffer */
151 STATE_FULL
, /* can't add any more tracks */
152 STATE_FINISHED
, /* all remaining tracks have been added */
156 #define MAX_TRACK 128
161 #define MAX_TRACK_MASK (MAX_TRACK-1)
163 /* As defined in plugins/lib/xxx2wav.h */
165 #define MALLOC_BUFSIZE (512*1024)
166 #define GUARD_BUFSIZE (32*1024)
168 #define MALLOC_BUFSIZE (100*1024)
169 #define GUARD_BUFSIZE (8*1024)
172 /* As defined in plugin.lds */
174 #define CODEC_IRAM_ORIGIN ((unsigned char *)0x4000c000)
175 #define CODEC_IRAM_SIZE ((size_t)0xc000)
176 #elif defined(IAUDIO_X5) || defined(IAUDIO_M5)
177 #define CODEC_IRAM_ORIGIN ((unsigned char *)0x10010000)
178 #define CODEC_IRAM_SIZE ((size_t)0x10000)
180 #define CODEC_IRAM_ORIGIN ((unsigned char *)0x1000c000)
181 #define CODEC_IRAM_SIZE ((size_t)0xc000)
184 bool audio_is_initialized
= false;
185 static bool audio_thread_ready SHAREDBSS_ATTR
= false;
187 /* Variables are commented with the threads that use them: *
188 * A=audio, C=codec, V=voice. A suffix of - indicates that *
189 * the variable is read but not updated on that thread. */
190 /* TBD: Split out "audio" and "playback" (ie. calling) threads */
192 /* Main state control */
193 static volatile bool audio_codec_loaded SHAREDBSS_ATTR
= false; /* Codec loaded? (C/A-) */
194 static volatile bool playing SHAREDBSS_ATTR
= false; /* Is audio playing? (A) */
195 static volatile bool paused SHAREDBSS_ATTR
= false; /* Is audio paused? (A/C-) */
197 /* Ring buffer where compressed audio and codecs are loaded */
198 static unsigned char *filebuf
= NULL
; /* Start of buffer (A/C-) */
199 static unsigned char *malloc_buf
= NULL
; /* Start of malloc buffer (A/C-) */
200 /* FIXME: make filebuflen static */
201 size_t filebuflen
= 0; /* Size of buffer (A/C-) */
202 /* FIXME: make buf_ridx (C/A-) */
204 /* Possible arrangements of the buffer */
205 #define BUFFER_STATE_TRASHED -1 /* trashed; must be reset */
206 #define BUFFER_STATE_INITIALIZED 0 /* voice+audio OR audio-only */
207 #define BUFFER_STATE_VOICED_ONLY 1 /* voice-only */
208 static int buffer_state
= BUFFER_STATE_TRASHED
; /* Buffer state */
210 /* Used to keep the WPS up-to-date during track transtition */
211 static struct mp3entry prevtrack_id3
;
213 /* Used to provide the codec with a pointer */
214 static struct mp3entry curtrack_id3
;
216 /* Used to make next track info available while playing last track on buffer */
217 static struct mp3entry lasttrack_id3
;
219 /* Track info structure about songs in the file buffer (A/C-) */
221 int audio_hid
; /* The ID for the track's buffer handle */
222 int id3_hid
; /* The ID for the track's metadata handle */
223 int codec_hid
; /* The ID for the track's codec handle */
225 int aa_hid
; /* The ID for the track's album art handle */
228 size_t filesize
; /* File total length */
230 bool taginfo_ready
; /* Is metadata read */
233 static struct track_info tracks
[MAX_TRACK
];
234 static volatile int track_ridx
= 0; /* Track being decoded (A/C-) */
235 static int track_widx
= 0; /* Track being buffered (A) */
237 #define CUR_TI (&tracks[track_ridx]) /* Playing track info pointer (A/C-) */
238 static struct track_info
*prev_ti
= NULL
; /* Pointer to the previously played
241 /* Set by the audio thread when the current track information has updated
242 * and the WPS may need to update its cached information */
243 static bool track_changed
= false;
245 /* Information used only for filling the buffer */
246 /* Playlist steps from playing track to next track to be buffered (A) */
247 static int last_peek_offset
= 0;
249 /* Scrobbler support */
250 static unsigned long prev_track_elapsed
= 0; /* Previous track elapsed time (C/A-)*/
252 static enum filling_state filling
;
254 /* Track change controls */
255 static bool automatic_skip
= false; /* Who initiated in-progress skip? (C/A-) */
256 static bool dir_skip
= false; /* Is a directory skip pending? (A) */
257 static bool new_playlist
= false; /* Are we starting a new playlist? (A) */
258 static int wps_offset
= 0; /* Pending track change offset, to keep WPS responsive (A) */
259 static bool skipped_during_pause
= false; /* Do we need to clear the PCM buffer when playback resumes (A) */
261 static bool start_play_g
= false; /* Used by audio_load_track to notify
262 audio_finish_load_track about start_play */
264 /* Set to true if the codec thread should send an audio stop request
265 * (typically because the end of the playlist has been reached).
267 static bool codec_requested_stop
= false;
269 static size_t buffer_margin
= 0; /* Buffer margin aka anti-skip buffer (A/C-) */
271 /* Multiple threads */
272 /* Set the watermark to trigger buffer fill (A/C) FIXME */
273 static void set_filebuf_watermark(int seconds
, size_t max
);
276 static struct event_queue audio_queue SHAREDBSS_ATTR
;
277 static struct queue_sender_list audio_queue_sender_list SHAREDBSS_ATTR
;
278 static long audio_stack
[(DEFAULT_STACK_SIZE
+ 0x1000)/sizeof(long)];
279 static const char audio_thread_name
[] = "audio";
281 static void audio_thread(void);
282 static void audio_initiate_track_change(long direction
);
283 static bool audio_have_tracks(void);
284 static void audio_reset_buffer(void);
287 extern struct codec_api ci
;
288 static struct event_queue codec_queue SHAREDBSS_ATTR
;
289 static struct queue_sender_list codec_queue_sender_list
;
290 static long codec_stack
[(DEFAULT_STACK_SIZE
+ 0x2000)/sizeof(long)]
292 static const char codec_thread_name
[] = "codec";
293 struct thread_entry
*codec_thread_p
; /* For modifying thread priority later. */
295 /* PCM buffer messaging */
296 static struct event_queue pcmbuf_queue SHAREDBSS_ATTR
;
298 /* Function to be called by pcm buffer callbacks.
299 * Permissible Context(s): Audio interrupt
301 static void pcmbuf_callback_queue_post(long id
, intptr_t data
)
303 /* No lock since we're already in audio interrupt context */
304 queue_post(&pcmbuf_queue
, id
, data
);
307 /* Scan the pcmbuf queue and return true if a message pulled.
308 * Permissible Context(s): Thread
310 static bool pcmbuf_queue_scan(struct queue_event
*ev
)
312 if (!queue_empty(&pcmbuf_queue
))
314 /* Transfer message to audio queue */
316 /* Pull message - never, ever any blocking call! */
317 queue_wait_w_tmo(&pcmbuf_queue
, ev
, 0);
325 /* Clear the pcmbuf queue of messages
326 * Permissible Context(s): Thread
328 static void pcmbuf_queue_clear(void)
331 queue_clear(&pcmbuf_queue
);
335 /* --- Helper functions --- */
337 static struct mp3entry
*bufgetid3(int handle_id
)
342 struct mp3entry
*id3
;
343 ssize_t ret
= bufgetdata(handle_id
, 0, (void *)&id3
);
345 if (ret
< 0 || ret
!= sizeof(struct mp3entry
))
351 static bool clear_track_info(struct track_info
*track
)
353 /* bufclose returns true if the handle is not found, or if it is closed
354 * successfully, so these checks are safe on non-existant handles */
358 if (track
->codec_hid
>= 0) {
359 if (bufclose(track
->codec_hid
))
360 track
->codec_hid
= -1;
365 if (track
->id3_hid
>= 0) {
366 if (bufclose(track
->id3_hid
))
372 if (track
->audio_hid
>= 0) {
373 if (bufclose(track
->audio_hid
))
374 track
->audio_hid
= -1;
380 if (track
->aa_hid
>= 0) {
381 if (bufclose(track
->aa_hid
))
389 track
->taginfo_ready
= false;
394 /* --- External interfaces --- */
396 /* This sends a stop message and the audio thread will dump all it's
397 subsequenct messages */
398 void audio_hard_stop(void)
401 LOGFQUEUE("audio >| audio Q_AUDIO_STOP: 1");
402 queue_send(&audio_queue
, Q_AUDIO_STOP
, 1);
403 #ifdef PLAYBACK_VOICE
408 bool audio_restore_playback(int type
)
412 case AUDIO_WANT_PLAYBACK
:
413 if (buffer_state
!= BUFFER_STATE_INITIALIZED
)
414 audio_reset_buffer();
416 case AUDIO_WANT_VOICE
:
417 if (buffer_state
== BUFFER_STATE_TRASHED
)
418 audio_reset_buffer();
425 unsigned char *audio_get_buffer(bool talk_buf
, size_t *buffer_size
)
427 unsigned char *buf
, *end
;
429 if (audio_is_initialized
)
433 /* else buffer_state will be BUFFER_STATE_TRASHED at this point */
435 if (buffer_size
== NULL
)
437 /* Special case for talk_init to use since it already knows it's
439 buffer_state
= BUFFER_STATE_TRASHED
;
443 if (talk_buf
|| buffer_state
== BUFFER_STATE_TRASHED
444 || !talk_voice_required())
446 logf("get buffer: talk, audio");
447 /* Ok to use everything from audiobuf to audiobufend - voice is loaded,
448 the talk buffer is not needed because voice isn't being used, or
449 could be BUFFER_STATE_TRASHED already. If state is
450 BUFFER_STATE_VOICED_ONLY, no problem as long as memory isn't written
451 without the caller knowing what's going on. Changing certain settings
452 may move it to a worse condition but the memory in use by something
453 else will remain undisturbed.
455 if (buffer_state
!= BUFFER_STATE_TRASHED
)
458 buffer_state
= BUFFER_STATE_TRASHED
;
466 /* Safe to just return this if already BUFFER_STATE_VOICED_ONLY or
467 still BUFFER_STATE_INITIALIZED */
468 /* Skip talk buffer and move pcm buffer to end to maximize available
469 contiguous memory - no audio running means voice will not need the
471 logf("get buffer: audio");
472 buf
= audiobuf
+ talk_get_bufsize();
473 end
= audiobufend
- pcmbuf_init(audiobufend
);
474 buffer_state
= BUFFER_STATE_VOICED_ONLY
;
477 *buffer_size
= end
- buf
;
482 #ifdef HAVE_RECORDING
483 unsigned char *audio_get_recording_buffer(size_t *buffer_size
)
485 /* Stop audio, voice and obtain all available buffer space */
489 unsigned char *end
= audiobufend
;
490 buffer_state
= BUFFER_STATE_TRASHED
;
491 *buffer_size
= end
- audiobuf
;
493 return (unsigned char *)audiobuf
;
496 bool audio_load_encoder(int afmt
)
499 const char *enc_fn
= get_codec_filename(afmt
| CODEC_TYPE_ENCODER
);
503 audio_remove_encoder();
504 ci
.enc_codec_loaded
= 0; /* clear any previous error condition */
506 LOGFQUEUE("codec > Q_ENCODER_LOAD_DISK");
507 queue_post(&codec_queue
, Q_ENCODER_LOAD_DISK
, (intptr_t)enc_fn
);
509 while (ci
.enc_codec_loaded
== 0)
512 logf("codec loaded: %d", ci
.enc_codec_loaded
);
514 return ci
.enc_codec_loaded
> 0;
519 } /* audio_load_encoder */
521 void audio_remove_encoder(void)
524 /* force encoder codec unload (if currently loaded) */
525 if (ci
.enc_codec_loaded
<= 0)
528 ci
.stop_encoder
= true;
529 while (ci
.enc_codec_loaded
> 0)
532 } /* audio_remove_encoder */
534 #endif /* HAVE_RECORDING */
537 int audio_current_aa_hid(void)
540 int offset
= ci
.new_track
+ wps_offset
;
542 cur_idx
= track_ridx
+ offset
;
543 cur_idx
&= MAX_TRACK_MASK
;
545 return tracks
[cur_idx
].aa_hid
;
549 struct mp3entry
* audio_current_track(void)
551 const char *filename
;
553 static struct mp3entry temp_id3
;
554 struct playlist_track_info trackinfo
;
556 int offset
= ci
.new_track
+ wps_offset
;
558 cur_idx
= (track_ridx
+ offset
) & MAX_TRACK_MASK
;
560 if (cur_idx
== track_ridx
&& *curtrack_id3
.path
)
563 return &curtrack_id3
;
565 else if (automatic_skip
&& offset
== -1 && *prevtrack_id3
.path
)
567 /* We're in a track transition. The codec has moved on to the nex track,
568 but the audio being played is still the same (now previous) track.
569 prevtrack_id3.elapsed is being updated in an ISR by
570 codec_pcmbuf_position_callback */
571 return &prevtrack_id3
;
573 else if (tracks
[cur_idx
].id3_hid
>= 0)
575 /* Get the ID3 metadata from the main buffer */
576 struct mp3entry
*ret
= bufgetid3(tracks
[cur_idx
].id3_hid
);
580 /* We didn't find the ID3 metadata, so we fill temp_id3 with the little info
581 we have and return that. */
583 memset(&temp_id3
, 0, sizeof(struct mp3entry
));
585 playlist_get_track_info(NULL
, playlist_next(0)+wps_offset
, &trackinfo
);
586 filename
= trackinfo
.filename
;
588 filename
= "No file!";
590 #if defined(HAVE_TC_RAMCACHE) && defined(HAVE_DIRCACHE)
591 if (tagcache_fill_tags(&temp_id3
, filename
))
595 p
= strrchr(filename
, '/');
601 strncpy(temp_id3
.path
, p
, sizeof(temp_id3
.path
)-1);
602 temp_id3
.title
= &temp_id3
.path
[0];
607 struct mp3entry
* audio_next_track(void)
610 int offset
= ci
.new_track
+ wps_offset
;
612 if (!audio_have_tracks())
615 if (wps_offset
== -1 && *prevtrack_id3
.path
)
617 /* We're in a track transition. The next track for the WPS is the one
618 currently being decoded. */
619 return &curtrack_id3
;
622 next_idx
= (track_ridx
+ offset
+ 1) & MAX_TRACK_MASK
;
624 if (tracks
[next_idx
].id3_hid
>= 0)
625 return bufgetid3(tracks
[next_idx
].id3_hid
);
627 if (next_idx
== track_widx
)
629 /* The next track hasn't been buffered yet, so we return the static
630 version of its metadata. */
631 return &lasttrack_id3
;
637 bool audio_has_changed_track(void)
641 track_changed
= false;
648 void audio_play(long offset
)
652 #ifdef PLAYBACK_VOICE
653 /* Truncate any existing voice output so we don't have spelling
654 * etc. over the first part of the played track */
659 LOGFQUEUE("audio >| audio Q_AUDIO_PLAY: %ld", offset
);
660 /* Don't return until playback has actually started */
661 queue_send(&audio_queue
, Q_AUDIO_PLAY
, offset
);
664 void audio_stop(void)
667 LOGFQUEUE("audio >| audio Q_AUDIO_STOP");
668 /* Don't return until playback has actually stopped */
669 queue_send(&audio_queue
, Q_AUDIO_STOP
, 0);
672 void audio_pause(void)
674 LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE");
675 /* Don't return until playback has actually paused */
676 queue_send(&audio_queue
, Q_AUDIO_PAUSE
, true);
679 void audio_resume(void)
681 LOGFQUEUE("audio >| audio Q_AUDIO_PAUSE resume");
682 /* Don't return until playback has actually resumed */
683 queue_send(&audio_queue
, Q_AUDIO_PAUSE
, false);
686 static void audio_skip(int direction
)
688 if (playlist_check(ci
.new_track
+ wps_offset
+ direction
))
690 if (global_settings
.beep
)
691 pcmbuf_beep(5000, 100, 2500*global_settings
.beep
);
693 LOGFQUEUE("audio > audio Q_AUDIO_SKIP %d", direction
);
694 queue_post(&audio_queue
, Q_AUDIO_SKIP
, direction
);
695 /* Update wps while our message travels inside deep playback queues. */
696 wps_offset
+= direction
;
697 track_changed
= true;
701 /* No more tracks. */
702 if (global_settings
.beep
)
703 pcmbuf_beep(1000, 100, 1000*global_settings
.beep
);
707 void audio_next(void)
712 void audio_prev(void)
717 void audio_next_dir(void)
719 LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP 1");
720 queue_post(&audio_queue
, Q_AUDIO_DIR_SKIP
, 1);
723 void audio_prev_dir(void)
725 LOGFQUEUE("audio > audio Q_AUDIO_DIR_SKIP -1");
726 queue_post(&audio_queue
, Q_AUDIO_DIR_SKIP
, -1);
729 void audio_pre_ff_rewind(void)
731 LOGFQUEUE("audio > audio Q_AUDIO_PRE_FF_REWIND");
732 queue_post(&audio_queue
, Q_AUDIO_PRE_FF_REWIND
, 0);
735 void audio_ff_rewind(long newpos
)
737 LOGFQUEUE("audio > audio Q_AUDIO_FF_REWIND");
738 queue_post(&audio_queue
, Q_AUDIO_FF_REWIND
, newpos
);
741 void audio_flush_and_reload_tracks(void)
743 LOGFQUEUE("audio > audio Q_AUDIO_FLUSH");
744 queue_post(&audio_queue
, Q_AUDIO_FLUSH
, 0);
747 void audio_error_clear(void)
749 #ifdef AUDIO_HAVE_RECORDING
750 pcm_rec_error_clear();
754 int audio_status(void)
759 ret
|= AUDIO_STATUS_PLAY
;
762 ret
|= AUDIO_STATUS_PAUSE
;
764 #ifdef HAVE_RECORDING
765 /* Do this here for constitency with mpeg.c version */
766 ret
|= pcm_rec_status();
772 int audio_get_file_pos(void)
777 #ifndef HAVE_FLASH_STORAGE
778 void audio_set_buffer_margin(int setting
)
780 static const int lookup
[] = {5, 15, 30, 60, 120, 180, 300, 600};
781 buffer_margin
= lookup
[setting
];
782 logf("buffer margin: %ld", (long)buffer_margin
);
783 set_filebuf_watermark(buffer_margin
, 0);
787 /* Take necessary steps to enable or disable the crossfade setting */
788 void audio_set_crossfade(int enable
)
794 /* Tell it the next setting to use */
795 pcmbuf_crossfade_enable(enable
);
797 /* Return if size hasn't changed or this is too early to determine
798 which in the second case there's no way we could be playing
800 if (pcmbuf_is_same_size())
802 /* This function is a copout and just syncs some variables -
803 to be removed at a later date */
804 pcmbuf_crossfade_enable_finished();
809 was_playing
= playing
;
811 /* Playback has to be stopped before changing the buffer size */
814 /* Store the track resume position */
815 offset
= curtrack_id3
.offset
;
816 gui_syncsplash(0, str(LANG_RESTARTING_PLAYBACK
));
819 /* Blast it - audio buffer will have to be setup again next time
821 audio_get_buffer(true, &size
);
823 /* Restart playback if audio was running previously */
828 /* --- Routines called from multiple threads --- */
830 static void set_filebuf_watermark(int seconds
, size_t max
)
835 return; /* Audio buffers not yet set up */
837 bytes
= seconds
?MAX(curtrack_id3
.bitrate
* seconds
* (1000/8), max
):max
;
838 bytes
= MIN(bytes
, filebuflen
/ 2);
839 buf_set_watermark(bytes
);
842 const char *get_codec_filename(int cod_spec
)
846 #ifdef HAVE_RECORDING
847 /* Can choose decoder or encoder if one available */
848 int type
= cod_spec
& CODEC_TYPE_MASK
;
849 int afmt
= cod_spec
& CODEC_AFMT_MASK
;
851 if ((unsigned)afmt
>= AFMT_NUM_CODECS
)
852 type
= AFMT_UNKNOWN
| (type
& CODEC_TYPE_MASK
);
854 fname
= (type
== CODEC_TYPE_ENCODER
) ?
855 audio_formats
[afmt
].codec_enc_root_fn
:
856 audio_formats
[afmt
].codec_root_fn
;
859 (type
== CODEC_TYPE_ENCODER
) ? "Encoder" : "Decoder",
860 afmt
, fname
? fname
: "<unknown>");
861 #else /* !HAVE_RECORDING */
863 if ((unsigned)cod_spec
>= AFMT_NUM_CODECS
)
864 cod_spec
= AFMT_UNKNOWN
;
865 fname
= audio_formats
[cod_spec
].codec_root_fn
;
866 logf("Codec: %d - %s", cod_spec
, fname
? fname
: "<unknown>");
867 #endif /* HAVE_RECORDING */
870 } /* get_codec_filename */
872 /* --- Codec thread --- */
873 static bool codec_pcmbuf_insert_callback(
874 const void *ch1
, const void *ch2
, int count
)
876 const char *src
[2] = { ch1
, ch2
};
880 int out_count
= dsp_output_count(ci
.dsp
, count
);
884 /* Prevent audio from a previous track from playing */
885 if (ci
.new_track
|| ci
.stop_codec
)
888 while ((dest
= pcmbuf_request_buffer(&out_count
)) == NULL
)
892 if (ci
.seek_time
|| ci
.new_track
|| ci
.stop_codec
)
896 /* Get the real input_size for output_size bytes, guarding
897 * against resampling buffer overflows. */
898 inp_count
= dsp_input_count(ci
.dsp
, out_count
);
903 /* Input size has grown, no error, just don't write more than length */
904 if (inp_count
> count
)
907 out_count
= dsp_process(ci
.dsp
, dest
, src
, inp_count
);
912 pcmbuf_write_complete(out_count
);
918 } /* codec_pcmbuf_insert_callback */
920 static void* codec_get_memory_callback(size_t *size
)
922 *size
= MALLOC_BUFSIZE
;
926 /* Between the codec and PCM track change, we need to keep updating the
927 "elapsed" value of the previous (to the codec, but current to the
928 user/PCM/WPS) track, so that the progressbar reaches the end.
929 During that transition, the WPS will display prevtrack_id3. */
930 static void codec_pcmbuf_position_callback(size_t size
) ICODE_ATTR
;
931 static void codec_pcmbuf_position_callback(size_t size
)
933 /* This is called from an ISR, so be quick */
934 unsigned int time
= size
* 1000 / 4 / NATIVE_FREQUENCY
+
935 prevtrack_id3
.elapsed
;
937 if (time
>= prevtrack_id3
.length
)
939 pcmbuf_set_position_callback(NULL
);
940 prevtrack_id3
.elapsed
= prevtrack_id3
.length
;
943 prevtrack_id3
.elapsed
= time
;
946 static void codec_set_elapsed_callback(unsigned int value
)
948 unsigned int latency
;
952 #ifdef AB_REPEAT_ENABLE
953 ab_position_report(value
);
956 latency
= pcmbuf_get_latency();
958 curtrack_id3
.elapsed
= 0;
959 else if (value
- latency
> curtrack_id3
.elapsed
||
960 value
- latency
< curtrack_id3
.elapsed
- 2)
962 curtrack_id3
.elapsed
= value
- latency
;
966 static void codec_set_offset_callback(size_t value
)
968 unsigned int latency
;
973 latency
= pcmbuf_get_latency() * curtrack_id3
.bitrate
/ 8;
975 curtrack_id3
.offset
= 0;
977 curtrack_id3
.offset
= value
- latency
;
980 static void codec_advance_buffer_counters(size_t amount
)
982 bufadvance(CUR_TI
->audio_hid
, amount
);
986 /* copy up-to size bytes into ptr and return the actual size copied */
987 static size_t codec_filebuf_callback(void *ptr
, size_t size
)
991 if (ci
.stop_codec
|| !playing
)
994 copy_n
= bufread(CUR_TI
->audio_hid
, size
, ptr
);
996 /* Nothing requested OR nothing left */
1000 /* Update read and other position pointers */
1001 codec_advance_buffer_counters(copy_n
);
1003 /* Return the actual amount of data copied to the buffer */
1005 } /* codec_filebuf_callback */
1007 static void* codec_request_buffer_callback(size_t *realsize
, size_t reqsize
)
1009 size_t copy_n
= reqsize
;
1019 ret
= bufgetdata(CUR_TI
->audio_hid
, reqsize
, &ptr
);
1021 copy_n
= MIN((size_t)ret
, reqsize
);
1032 } /* codec_request_buffer_callback */
1034 static int get_codec_base_type(int type
)
1046 static void codec_advance_buffer_callback(size_t amount
)
1048 codec_advance_buffer_counters(amount
);
1049 codec_set_offset_callback(ci
.curpos
);
1052 static void codec_advance_buffer_loc_callback(void *ptr
)
1054 size_t amount
= buf_get_offset(CUR_TI
->audio_hid
, ptr
);
1055 codec_advance_buffer_callback(amount
);
1058 static void codec_seek_complete_callback(void)
1060 logf("seek_complete");
1061 if (pcm_is_paused())
1063 /* If this is not a seamless seek, clear the buffer */
1065 dsp_configure(ci
.dsp
, DSP_FLUSH
, 0);
1067 /* If playback was not 'deliberately' paused, unpause now */
1069 pcmbuf_pause(false);
1074 static bool codec_seek_buffer_callback(size_t newpos
)
1076 logf("codec_seek_buffer_callback");
1078 int ret
= bufseek(CUR_TI
->audio_hid
, newpos
);
1088 static void codec_configure_callback(int setting
, intptr_t value
)
1091 case CODEC_SET_FILEBUF_WATERMARK
:
1092 set_filebuf_watermark(buffer_margin
, value
);
1096 if (!dsp_configure(ci
.dsp
, setting
, value
))
1097 { logf("Illegal key:%d", setting
); }
1101 static void codec_track_changed(void)
1103 LOGFQUEUE("codec > audio Q_AUDIO_TRACK_CHANGED");
1104 queue_post(&audio_queue
, Q_AUDIO_TRACK_CHANGED
, 0);
1107 static void codec_pcmbuf_track_changed_callback(void)
1109 pcmbuf_set_position_callback(NULL
);
1110 pcmbuf_callback_queue_post(Q_AUDIO_TRACK_CHANGED
, 0);
1113 static void codec_discard_codec_callback(void)
1115 if (CUR_TI
->codec_hid
>= 0)
1117 bufclose(CUR_TI
->codec_hid
);
1118 CUR_TI
->codec_hid
= -1;
1122 static inline void codec_gapless_track_change(void)
1124 /* callback keeps the progress bar moving while the pcmbuf empties */
1125 pcmbuf_set_position_callback(codec_pcmbuf_position_callback
);
1126 /* set the pcmbuf callback for when the track really changes */
1127 pcmbuf_set_event_handler(codec_pcmbuf_track_changed_callback
);
1130 static inline void codec_crossfade_track_change(void)
1132 /* Initiate automatic crossfade mode */
1133 pcmbuf_crossfade_init(false);
1134 /* Notify the wps that the track change starts now */
1135 codec_track_changed();
1138 static void codec_track_skip_done(bool was_manual
)
1140 /* Manual track change (always crossfade or flush audio). */
1143 pcmbuf_crossfade_init(true);
1144 LOGFQUEUE("codec > audio Q_AUDIO_TRACK_CHANGED");
1145 queue_post(&audio_queue
, Q_AUDIO_TRACK_CHANGED
, 0);
1147 /* Automatic track change w/crossfade, if not in "Track Skip Only" mode. */
1148 else if (pcmbuf_is_crossfade_enabled() && !pcmbuf_is_crossfade_active()
1149 && global_settings
.crossfade
!= CROSSFADE_ENABLE_TRACKSKIP
)
1151 if (global_settings
.crossfade
== CROSSFADE_ENABLE_SHUFFLE_AND_TRACKSKIP
)
1153 if (global_settings
.playlist_shuffle
)
1154 /* shuffle mode is on, so crossfade: */
1155 codec_crossfade_track_change();
1157 /* shuffle mode is off, so do a gapless track change */
1158 codec_gapless_track_change();
1161 /* normal crossfade: */
1162 codec_crossfade_track_change();
1165 /* normal gapless playback. */
1166 codec_gapless_track_change();
1169 static bool codec_load_next_track(void)
1171 intptr_t result
= Q_CODEC_REQUEST_FAILED
;
1173 prev_track_elapsed
= curtrack_id3
.elapsed
;
1175 #ifdef AB_REPEAT_ENABLE
1176 ab_end_of_track_report();
1179 logf("Request new track");
1181 if (ci
.new_track
== 0)
1184 automatic_skip
= true;
1189 trigger_cpu_boost();
1190 LOGFQUEUE("codec >| audio Q_AUDIO_CHECK_NEW_TRACK");
1191 result
= queue_send(&audio_queue
, Q_AUDIO_CHECK_NEW_TRACK
, 0);
1196 case Q_CODEC_REQUEST_COMPLETE
:
1197 LOGFQUEUE("codec |< Q_CODEC_REQUEST_COMPLETE");
1198 codec_track_skip_done(!automatic_skip
);
1201 case Q_CODEC_REQUEST_FAILED
:
1202 LOGFQUEUE("codec |< Q_CODEC_REQUEST_FAILED");
1204 ci
.stop_codec
= true;
1205 codec_requested_stop
= true;
1209 LOGFQUEUE("codec |< default");
1210 ci
.stop_codec
= true;
1211 codec_requested_stop
= true;
1216 static bool codec_request_next_track_callback(void)
1220 if (ci
.stop_codec
|| !playing
)
1223 prev_codectype
= get_codec_base_type(curtrack_id3
.codectype
);
1225 if (!codec_load_next_track())
1228 /* Seek to the beginning of the new track because if the struct
1229 mp3entry was buffered, "elapsed" might not be zero (if the track has
1230 been played already but not unbuffered) */
1231 codec_seek_buffer_callback(curtrack_id3
.first_frame_offset
);
1233 /* Check if the next codec is the same file. */
1234 if (prev_codectype
== get_codec_base_type(curtrack_id3
.codectype
))
1236 logf("New track loaded");
1237 codec_discard_codec_callback();
1242 logf("New codec:%d/%d", curtrack_id3
.codectype
, prev_codectype
);
1247 static void codec_thread(void)
1249 struct queue_event ev
;
1255 if (!pcmbuf_is_crossfade_active()) {
1259 queue_wait(&codec_queue
, &ev
);
1260 codec_requested_stop
= false;
1263 case Q_CODEC_LOAD_DISK
:
1264 LOGFQUEUE("codec < Q_CODEC_LOAD_DISK");
1265 queue_reply(&codec_queue
, 1);
1266 audio_codec_loaded
= true;
1267 ci
.stop_codec
= false;
1268 status
= codec_load_file((const char *)ev
.data
, &ci
);
1272 LOGFQUEUE("codec < Q_CODEC_LOAD");
1273 if (CUR_TI
->codec_hid
< 0) {
1274 logf("Codec slot is empty!");
1275 /* Wait for the pcm buffer to go empty */
1276 while (pcm_is_playing())
1278 /* This must be set to prevent an infinite loop */
1279 ci
.stop_codec
= true;
1280 LOGFQUEUE("codec > codec Q_AUDIO_PLAY");
1281 queue_post(&codec_queue
, Q_AUDIO_PLAY
, 0);
1285 audio_codec_loaded
= true;
1286 ci
.stop_codec
= false;
1287 status
= codec_load_buf(CUR_TI
->codec_hid
, &ci
);
1290 #ifdef AUDIO_HAVE_RECORDING
1291 case Q_ENCODER_LOAD_DISK
:
1292 LOGFQUEUE("codec < Q_ENCODER_LOAD_DISK");
1293 audio_codec_loaded
= false; /* Not audio codec! */
1294 logf("loading encoder");
1295 ci
.stop_encoder
= false;
1296 status
= codec_load_file((const char *)ev
.data
, &ci
);
1297 logf("encoder stopped");
1299 #endif /* AUDIO_HAVE_RECORDING */
1302 LOGFQUEUE("codec < default");
1305 if (audio_codec_loaded
)
1314 audio_codec_loaded
= false;
1318 case Q_CODEC_LOAD_DISK
:
1320 LOGFQUEUE("codec < Q_CODEC_LOAD");
1323 if (ci
.new_track
|| status
!= CODEC_OK
)
1327 logf("Codec failure");
1328 gui_syncsplash(HZ
*2, "Codec failure");
1331 if (!codec_load_next_track())
1333 LOGFQUEUE("codec > audio Q_AUDIO_STOP");
1334 /* End of playlist */
1335 queue_post(&audio_queue
, Q_AUDIO_STOP
, 0);
1341 logf("Codec finished");
1344 /* Wait for the audio to stop playing before
1345 * triggering the WPS exit */
1346 while(pcm_is_playing())
1348 curtrack_id3
.elapsed
=
1349 curtrack_id3
.length
- pcmbuf_get_latency();
1353 if (codec_requested_stop
)
1355 LOGFQUEUE("codec > audio Q_AUDIO_STOP");
1356 queue_post(&audio_queue
, Q_AUDIO_STOP
, 0);
1362 if (CUR_TI
->codec_hid
>= 0)
1364 LOGFQUEUE("codec > codec Q_CODEC_LOAD");
1365 queue_post(&codec_queue
, Q_CODEC_LOAD
, 0);
1369 const char *codec_fn
=
1370 get_codec_filename(curtrack_id3
.codectype
);
1373 LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK");
1374 queue_post(&codec_queue
, Q_CODEC_LOAD_DISK
,
1375 (intptr_t)codec_fn
);
1381 #ifdef AUDIO_HAVE_RECORDING
1382 case Q_ENCODER_LOAD_DISK
:
1383 LOGFQUEUE("codec < Q_ENCODER_LOAD_DISK");
1385 if (status
== CODEC_OK
)
1388 logf("Encoder failure");
1389 gui_syncsplash(HZ
*2, "Encoder failure");
1391 if (ci
.enc_codec_loaded
< 0)
1394 logf("Encoder failed to load");
1395 ci
.enc_codec_loaded
= -1;
1397 #endif /* AUDIO_HAVE_RECORDING */
1400 LOGFQUEUE("codec < default");
1407 /* --- Buffering callbacks --- */
1409 static void buffering_low_buffer_callback(void *data
)
1412 logf("low buffer callback");
1414 if (filling
== STATE_FULL
) {
1415 /* force a refill */
1416 LOGFQUEUE("buffering > audio Q_AUDIO_FILL_BUFFER");
1417 queue_post(&audio_queue
, Q_AUDIO_FILL_BUFFER
, 0);
1421 static void buffering_handle_rebuffer_callback(void *data
)
1424 LOGFQUEUE("audio >| audio Q_AUDIO_FLUSH");
1425 queue_post(&audio_queue
, Q_AUDIO_FLUSH
, 0);
1428 static void buffering_handle_finished_callback(int *data
)
1430 logf("handle %d finished buffering", *data
);
1432 if (*data
== tracks
[track_widx
].id3_hid
)
1434 /* The metadata handle for the last loaded track has been buffered.
1435 We can ask the audio thread to load the rest of the track's data. */
1436 LOGFQUEUE("audio >| audio Q_AUDIO_FINISH_LOAD");
1437 queue_post(&audio_queue
, Q_AUDIO_FINISH_LOAD
, 0);
1441 /* This is most likely an audio handle, so we strip the useless
1442 trailing tags that are left. */
1448 /* --- Audio thread --- */
1450 static bool audio_have_tracks(void)
1452 return (audio_track_count() != 0);
1455 static int audio_free_track_count(void)
1457 /* Used tracks + free tracks adds up to MAX_TRACK - 1 */
1458 return MAX_TRACK
- 1 - audio_track_count();
1461 int audio_track_count(void)
1463 /* Calculate difference from track_ridx to track_widx
1464 * taking into account a possible wrap-around. */
1465 return (MAX_TRACK
+ track_widx
- track_ridx
) & MAX_TRACK_MASK
;
1468 long audio_filebufused(void)
1470 return (long) buf_used();
1473 /* Update track info after successful a codec track change */
1474 static void audio_update_trackinfo(void)
1476 /* Load the curent track's metadata into curtrack_id3 */
1477 if (CUR_TI
->id3_hid
>= 0)
1478 copy_mp3entry(&curtrack_id3
, bufgetid3(CUR_TI
->id3_hid
));
1480 /* Reset current position */
1481 curtrack_id3
.elapsed
= 0;
1482 curtrack_id3
.offset
= 0;
1484 /* Update the codec API */
1485 ci
.filesize
= CUR_TI
->filesize
;
1486 ci
.id3
= &curtrack_id3
;
1488 ci
.taginfo_ready
= &CUR_TI
->taginfo_ready
;
1491 /* Clear tracks between write and read, non inclusive */
1492 static void audio_clear_track_entries(void)
1494 int cur_idx
= track_widx
;
1496 logf("Clearing tracks:%d/%d", track_ridx
, track_widx
);
1498 /* Loop over all tracks from write-to-read */
1501 cur_idx
= (cur_idx
+ 1) & MAX_TRACK_MASK
;
1503 if (cur_idx
== track_ridx
)
1506 clear_track_info(&tracks
[cur_idx
]);
1510 /* Clear all tracks */
1511 static bool audio_release_tracks(void)
1515 logf("releasing all tracks");
1517 for(i
= 0; i
< MAX_TRACK
; i
++)
1519 cur_idx
= (track_ridx
+ i
) & MAX_TRACK_MASK
;
1520 if (!clear_track_info(&tracks
[cur_idx
]))
1527 static bool audio_loadcodec(bool start_play
)
1530 char codec_path
[MAX_PATH
]; /* Full path to codec */
1531 const struct mp3entry
*id3
, *prev_id3
;
1533 if (tracks
[track_widx
].id3_hid
< 0) {
1537 id3
= bufgetid3(tracks
[track_widx
].id3_hid
);
1541 const char *codec_fn
= get_codec_filename(id3
->codectype
);
1542 if (codec_fn
== NULL
)
1545 tracks
[track_widx
].codec_hid
= -1;
1549 /* Load the codec directly from disk and save some memory. */
1550 track_ridx
= track_widx
;
1551 ci
.filesize
= CUR_TI
->filesize
;
1552 ci
.id3
= &curtrack_id3
;
1553 ci
.taginfo_ready
= &CUR_TI
->taginfo_ready
;
1555 LOGFQUEUE("codec > codec Q_CODEC_LOAD_DISK");
1556 queue_post(&codec_queue
, Q_CODEC_LOAD_DISK
, (intptr_t)codec_fn
);
1561 /* If we already have another track than this one buffered */
1562 if (track_widx
!= track_ridx
)
1564 prev_track
= (track_widx
- 1) & MAX_TRACK_MASK
;
1566 id3
= bufgetid3(tracks
[track_widx
].id3_hid
);
1567 prev_id3
= bufgetid3(tracks
[prev_track
].id3_hid
);
1569 /* If the previous codec is the same as this one, there is no need
1570 * to put another copy of it on the file buffer */
1571 if (id3
&& prev_id3
&&
1572 get_codec_base_type(id3
->codectype
) ==
1573 get_codec_base_type(prev_id3
->codectype
)
1574 && audio_codec_loaded
)
1576 logf("Reusing prev. codec");
1582 codec_get_full_path(codec_path
, codec_fn
);
1584 tracks
[track_widx
].codec_hid
= bufopen(codec_path
, 0, TYPE_CODEC
);
1585 if (tracks
[track_widx
].codec_hid
< 0)
1588 logf("Loaded codec");
1593 /* Load metadata for the next track (with bufopen). The rest of the track
1594 loading will be handled by audio_finish_load_track once the metadata has been
1595 actually loaded by the buffering thread. */
1596 static bool audio_load_track(size_t offset
, bool start_play
)
1598 const char *trackname
;
1601 start_play_g
= start_play
; /* will be read by audio_finish_load_track */
1603 /* Stop buffer filling if there is no free track entries.
1604 Don't fill up the last track entry (we wan't to store next track
1606 if (!audio_free_track_count())
1608 logf("No free tracks");
1613 tracks
[track_widx
].taginfo_ready
= false;
1615 logf("Buffering track:%d/%d", track_widx
, track_ridx
);
1616 /* Get track name from current playlist read position. */
1617 while ((trackname
= playlist_peek(last_peek_offset
)) != NULL
)
1619 /* Handle broken playlists. */
1620 fd
= open(trackname
, O_RDONLY
);
1623 logf("Open failed");
1624 /* Skip invalid entry from playlist. */
1625 playlist_skip_entry(NULL
, last_peek_offset
);
1633 logf("End-of-playlist");
1634 memset(&lasttrack_id3
, 0, sizeof(struct mp3entry
));
1635 filling
= STATE_FINISHED
;
1639 tracks
[track_widx
].filesize
= filesize(fd
);
1641 if (offset
> tracks
[track_widx
].filesize
)
1644 /* Set default values */
1647 buf_set_watermark(AUDIO_DEFAULT_WATERMARK
);
1648 dsp_configure(ci
.dsp
, DSP_RESET
, 0);
1649 track_changed
= true;
1650 playlist_update_resume_info(audio_current_track());
1653 /* Get track metadata if we don't already have it. */
1654 if (tracks
[track_widx
].id3_hid
< 0)
1656 tracks
[track_widx
].id3_hid
= bufopen(trackname
, 0, TYPE_ID3
);
1658 if (tracks
[track_widx
].id3_hid
< 0)
1660 /* Buffer is full. */
1661 get_metadata(&lasttrack_id3
, fd
, trackname
);
1664 logf("buffer is full for now");
1665 filling
= STATE_FULL
;
1669 if (track_widx
== track_ridx
)
1671 buf_request_buffer_handle(tracks
[track_widx
].id3_hid
);
1672 copy_mp3entry(&curtrack_id3
, bufgetid3(tracks
[track_widx
].id3_hid
));
1673 curtrack_id3
.offset
= offset
;
1678 track_changed
= true;
1679 playlist_update_resume_info(audio_current_track());
1687 /* Second part of the track loading: We now have the metadata available, so we
1688 can load the codec, the album art and finally the audio data.
1689 This is called on the audio thread after the buffering thread calls the
1690 buffering_handle_finished_callback callback. */
1691 static void audio_finish_load_track(void)
1694 size_t file_offset
= 0;
1696 bool start_play
= start_play_g
;
1699 if (cuesheet_is_enabled() && tracks
[track_widx
].id3
.cuesheet_type
== 1)
1701 char cuepath
[MAX_PATH
];
1703 struct cuesheet
*cue
= start_play
? curr_cue
: temp_cue
;
1705 if (look_for_cuesheet_file(trackname
, cuepath
) &&
1706 parse_cuesheet(cuepath
, cue
))
1708 strcpy((cue
)->audio_filename
, trackname
);
1710 cue_spoof_id3(curr_cue
, &tracks
[track_widx
].id3
);
1715 if (tracks
[track_widx
].id3_hid
< 0) {
1716 logf("no metatdata");
1720 struct mp3entry
*track_id3
;
1722 if (track_widx
== track_ridx
)
1723 track_id3
= &curtrack_id3
;
1725 track_id3
= bufgetid3(tracks
[track_widx
].id3_hid
);
1727 if (track_id3
->length
== 0 && track_id3
->filesize
== 0)
1729 logf("audio_finish_load_track: invalid metadata");
1731 /* Invalid metadata */
1732 bufclose(tracks
[track_widx
].id3_hid
);
1733 tracks
[track_widx
].id3_hid
= -1;
1735 /* Skip invalid entry from playlist. */
1736 playlist_skip_entry(NULL
, last_peek_offset
--);
1738 /* load next track */
1739 LOGFQUEUE("audio > audio Q_AUDIO_FILL_BUFFER %d", (int)start_play
);
1740 queue_post(&audio_queue
, Q_AUDIO_FILL_BUFFER
, start_play
);
1745 #ifdef HAVE_ALBUMART
1746 if (tracks
[track_widx
].aa_hid
< 0 && gui_sync_wps_uses_albumart())
1748 char aa_path
[MAX_PATH
];
1749 if (find_albumart(track_id3
, aa_path
, sizeof(aa_path
)))
1750 tracks
[track_widx
].aa_hid
= bufopen(aa_path
, 0, TYPE_BITMAP
);
1754 /* Load the codec. */
1755 if (!audio_loadcodec(start_play
))
1757 if (tracks
[track_widx
].codec_hid
== ERR_BUFFER_FULL
)
1759 /* No space for codec on buffer, not an error */
1763 /* This is an error condition, either no codec was found, or reading
1764 * the codec file failed part way through, either way, skip the track */
1765 snprintf(msgbuf
, sizeof(msgbuf
)-1, "No codec for: %s", track_id3
->path
);
1766 /* We should not use gui_syncplash from audio thread! */
1767 gui_syncsplash(HZ
*2, msgbuf
);
1768 /* Skip invalid entry from playlist. */
1769 playlist_skip_entry(NULL
, last_peek_offset
);
1773 track_id3
->elapsed
= 0;
1774 offset
= track_id3
->offset
;
1776 enum data_type type
= TYPE_PACKET_AUDIO
;
1778 switch (track_id3
->codectype
) {
1783 file_offset
= offset
;
1784 track_id3
->offset
= offset
;
1790 file_offset
= offset
;
1791 track_id3
->offset
= offset
;
1792 track_id3
->elapsed
= track_id3
->length
/ 2;
1796 case AFMT_OGG_VORBIS
:
1806 track_id3
->offset
= offset
;
1812 logf("Loading atomic %d",track_id3
->codectype
);
1813 type
= TYPE_ATOMIC_AUDIO
;
1817 logf("alt:%s", track_id3
->path
);
1819 if (file_offset
> AUDIO_REBUFFER_GUESS_SIZE
)
1820 file_offset
-= AUDIO_REBUFFER_GUESS_SIZE
;
1821 else if (track_id3
->first_frame_offset
)
1822 file_offset
= track_id3
->first_frame_offset
;
1826 tracks
[track_widx
].audio_hid
= bufopen(track_id3
->path
, file_offset
, type
);
1828 if (tracks
[track_widx
].audio_hid
< 0)
1831 /* All required data is now available for the codec. */
1832 tracks
[track_widx
].taginfo_ready
= true;
1836 ci
.curpos
=file_offset
;
1837 buf_request_buffer_handle(tracks
[track_widx
].audio_hid
);
1840 track_widx
= (track_widx
+ 1) & MAX_TRACK_MASK
;
1842 send_event(PLAYBACK_EVENT_TRACK_BUFFER
, track_id3
);
1844 /* load next track */
1845 LOGFQUEUE("audio > audio Q_AUDIO_FILL_BUFFER");
1846 queue_post(&audio_queue
, Q_AUDIO_FILL_BUFFER
, 0);
1851 static void audio_fill_file_buffer(bool start_play
, size_t offset
)
1853 bool had_next_track
= audio_next_track() != NULL
;
1855 filling
= STATE_FILLING
;
1856 trigger_cpu_boost();
1858 /* No need to rebuffer if there are track skips pending. */
1859 if (ci
.new_track
!= 0)
1862 /* Must reset the buffer before use if trashed or voice only - voice
1863 file size shouldn't have changed so we can go straight from
1864 BUFFER_STATE_VOICED_ONLY to BUFFER_STATE_INITIALIZED */
1865 if (buffer_state
!= BUFFER_STATE_INITIALIZED
)
1866 audio_reset_buffer();
1868 logf("Starting buffer fill");
1871 audio_clear_track_entries();
1873 /* Save the current resume position once. */
1874 playlist_update_resume_info(audio_current_track());
1876 audio_load_track(offset
, start_play
);
1878 if (!had_next_track
&& audio_next_track())
1879 track_changed
= true;
1882 static void audio_rebuffer(void)
1884 logf("Forcing rebuffer");
1886 clear_track_info(CUR_TI
);
1888 /* Reset track pointers */
1889 track_widx
= track_ridx
;
1890 audio_clear_track_entries();
1892 /* Fill the buffer */
1893 last_peek_offset
= -1;
1896 if (!CUR_TI
->taginfo_ready
)
1897 memset(&curtrack_id3
, 0, sizeof(struct mp3entry
));
1899 audio_fill_file_buffer(false, 0);
1902 /* Called on request from the codec to get a new track. This is the codec part
1903 of the track transition. */
1904 static int audio_check_new_track(void)
1906 int track_count
= audio_track_count();
1907 int old_track_ridx
= track_ridx
;
1911 /* Now it's good time to send track finish events. */
1912 send_event(PLAYBACK_EVENT_TRACK_FINISH
, &curtrack_id3
);
1916 if (playlist_next_dir(ci
.new_track
))
1924 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1925 return Q_CODEC_REQUEST_FAILED
;
1932 /* If the playlist isn't that big */
1935 while (!playlist_check(ci
.new_track
))
1937 if (ci
.new_track
>= 0)
1939 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1940 return Q_CODEC_REQUEST_FAILED
;
1946 /* Update the playlist */
1947 last_peek_offset
-= ci
.new_track
;
1949 if (playlist_next(ci
.new_track
) < 0)
1951 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_FAILED");
1952 return Q_CODEC_REQUEST_FAILED
;
1958 new_playlist
= false;
1961 /* Save the track metadata to allow the WPS to display it
1962 while PCM finishes playing that track */
1963 copy_mp3entry(&prevtrack_id3
, &curtrack_id3
);
1965 /* Update the main buffer copy of the track metadata with the one
1966 the codec has been using (for the unbuffer callbacks) */
1967 if (CUR_TI
->id3_hid
>= 0)
1968 copy_mp3entry(bufgetid3(CUR_TI
->id3_hid
), &curtrack_id3
);
1970 /* Save a pointer to the old track to allow later clearing */
1973 for (i
= 0; i
< ci
.new_track
; i
++)
1975 idx
= (track_ridx
+ i
) & MAX_TRACK_MASK
;
1976 struct mp3entry
*id3
= bufgetid3(tracks
[idx
].id3_hid
);
1977 ssize_t offset
= buf_handle_offset(tracks
[idx
].audio_hid
);
1978 if (!id3
|| offset
< 0 || (unsigned)offset
> id3
->first_frame_offset
)
1980 /* We don't have all the audio data for that track, so clear it,
1981 but keep the metadata. */
1982 if (tracks
[idx
].audio_hid
>= 0 && bufclose(tracks
[idx
].audio_hid
))
1984 tracks
[idx
].audio_hid
= -1;
1985 tracks
[idx
].filesize
= 0;
1990 /* Move to the new track */
1991 track_ridx
= (track_ridx
+ ci
.new_track
) & MAX_TRACK_MASK
;
1993 buf_set_base_handle(CUR_TI
->audio_hid
);
1997 wps_offset
= -ci
.new_track
;
1998 track_changed
= true;
2001 /* If it is not safe to even skip this many track entries */
2002 if (ci
.new_track
>= track_count
|| ci
.new_track
<= track_count
- MAX_TRACK
)
2009 forward
= ci
.new_track
> 0;
2012 /* If the target track is clearly not in memory */
2013 if (CUR_TI
->filesize
== 0 || !CUR_TI
->taginfo_ready
)
2019 /* When skipping backwards, it is possible that we've found a track that's
2020 * buffered, but which is around the track-wrap and therefore not the track
2021 * we are looking for */
2024 int cur_idx
= track_ridx
;
2025 bool taginfo_ready
= true;
2026 /* We've wrapped the buffer backwards if new > old */
2027 bool wrap
= track_ridx
> old_track_ridx
;
2031 cur_idx
= (cur_idx
+ 1) & MAX_TRACK_MASK
;
2033 /* if we've advanced past the wrap when cur_idx is zeroed */
2037 /* if we aren't still on the wrap and we've caught the old track */
2038 if (!(wrap
|| cur_idx
< old_track_ridx
))
2041 /* If we hit a track in between without valid tag info, bail */
2042 if (!tracks
[cur_idx
].taginfo_ready
)
2044 taginfo_ready
= false;
2055 audio_update_trackinfo();
2056 LOGFQUEUE("audio >|= codec Q_CODEC_REQUEST_COMPLETE");
2057 return Q_CODEC_REQUEST_COMPLETE
;
2060 unsigned long audio_prev_elapsed(void)
2062 return prev_track_elapsed
;
2065 static void audio_stop_codec_flush(void)
2067 ci
.stop_codec
= true;
2070 while (audio_codec_loaded
)
2073 /* If the audio codec is not loaded any more, and the audio is still
2074 * playing, it is now and _only_ now safe to call this function from the
2076 if (pcm_is_playing())
2079 pcmbuf_queue_clear();
2081 pcmbuf_pause(paused
);
2084 static void audio_stop_playback(void)
2086 /* If we were playing, save resume information */
2089 struct mp3entry
*id3
= NULL
;
2093 /* Set this early, the outside code yields and may allow the codec
2094 to try to wait for a reply on a buffer wait */
2095 ci
.stop_codec
= true;
2096 id3
= audio_current_track();
2099 /* Save the current playing spot, or NULL if the playlist has ended */
2100 playlist_update_resume_info(id3
);
2102 /* TODO: Create auto bookmark too? */
2104 prev_track_elapsed
= curtrack_id3
.elapsed
;
2106 remove_event(EVENT_BUFFER_LOW
, buffering_low_buffer_callback
);
2110 audio_stop_codec_flush();
2113 filling
= STATE_IDLE
;
2115 /* Mark all entries null. */
2116 audio_clear_track_entries();
2118 /* Close all tracks */
2119 audio_release_tracks();
2121 memset(&curtrack_id3
, 0, sizeof(struct mp3entry
));
2124 static void audio_play_start(size_t offset
)
2128 #if INPUT_SRC_CAPS != 0
2129 audio_set_input_source(AUDIO_SRC_PLAYBACK
, SRCF_PLAYBACK
);
2130 audio_set_output_source(AUDIO_SRC_PLAYBACK
);
2133 /* Wait for any previously playing audio to flush - TODO: Not necessary? */
2135 audio_stop_codec_flush();
2137 track_changed
= true;
2145 sound_set_volume(global_settings
.volume
);
2146 track_widx
= track_ridx
= 0;
2148 /* Clear all track entries. */
2149 for (i
= 0; i
< MAX_TRACK
; i
++) {
2150 clear_track_info(&tracks
[i
]);
2153 last_peek_offset
= -1;
2155 /* Officially playing */
2156 queue_reply(&audio_queue
, 1);
2158 #ifndef HAVE_FLASH_STORAGE
2159 set_filebuf_watermark(buffer_margin
, 0);
2162 audio_fill_file_buffer(true, offset
);
2164 add_event(EVENT_BUFFER_LOW
, false, buffering_low_buffer_callback
);
2166 LOGFQUEUE("audio > audio Q_AUDIO_TRACK_CHANGED");
2167 queue_post(&audio_queue
, Q_AUDIO_TRACK_CHANGED
, 0);
2171 /* Invalidates all but currently playing track. */
2172 static void audio_invalidate_tracks(void)
2174 if (audio_have_tracks())
2176 last_peek_offset
= 0;
2177 track_widx
= track_ridx
;
2179 /* Mark all other entries null (also buffered wrong metadata). */
2180 audio_clear_track_entries();
2182 track_widx
= (track_widx
+ 1) & MAX_TRACK_MASK
;
2184 audio_fill_file_buffer(false, 0);
2188 static void audio_new_playlist(void)
2190 /* Prepare to start a new fill from the beginning of the playlist */
2191 last_peek_offset
= -1;
2192 if (audio_have_tracks())
2195 skipped_during_pause
= true;
2196 track_widx
= track_ridx
;
2197 audio_clear_track_entries();
2199 track_widx
= (track_widx
+ 1) & MAX_TRACK_MASK
;
2201 /* Mark the current track as invalid to prevent skipping back to it */
2202 CUR_TI
->taginfo_ready
= false;
2205 /* Signal the codec to initiate a track change forward */
2206 new_playlist
= true;
2209 /* Officially playing */
2210 queue_reply(&audio_queue
, 1);
2212 audio_fill_file_buffer(false, 0);
2215 /* Called on manual track skip */
2216 static void audio_initiate_track_change(long direction
)
2218 logf("audio_initiate_track_change(%ld)", direction
);
2220 ci
.new_track
+= direction
;
2221 wps_offset
-= direction
;
2223 skipped_during_pause
= true;
2226 /* Called on manual dir skip */
2227 static void audio_initiate_dir_change(long direction
)
2230 ci
.new_track
= direction
;
2232 skipped_during_pause
= true;
2235 /* Called when PCM track change is complete */
2236 static void audio_finalise_track_change(void)
2238 logf("audio_finalise_track_change");
2243 automatic_skip
= false;
2245 /* Invalidate prevtrack_id3 */
2246 prevtrack_id3
.path
[0] = 0;
2248 if (prev_ti
&& prev_ti
->audio_hid
< 0)
2250 /* No audio left so we clear all the track info. */
2251 clear_track_info(prev_ti
);
2254 if (prev_ti
&& prev_ti
->id3_hid
>= 0)
2256 /* Reset the elapsed time to force the progressbar to be empty if
2257 the user skips back to this track */
2258 bufgetid3(prev_ti
->id3_hid
)->elapsed
= 0;
2262 send_event(PLAYBACK_EVENT_TRACK_CHANGE
, &curtrack_id3
);
2264 track_changed
= true;
2265 playlist_update_resume_info(audio_current_track());
2269 * Layout audio buffer as follows - iram buffer depends on target:
2270 * [|SWAP:iram][|TALK]|MALLOC|FILE|GUARD|PCM|[SWAP:dram[|iram]|]
2272 static void audio_reset_buffer(void)
2274 /* see audio_get_recording_buffer if this is modified */
2275 logf("audio_reset_buffer");
2277 /* If the setup of anything allocated before the file buffer is
2278 changed, do check the adjustments after the buffer_alloc call
2279 as it will likely be affected and need sliding over */
2281 /* Initially set up file buffer as all space available */
2282 malloc_buf
= audiobuf
+ talk_get_bufsize();
2283 /* Align the malloc buf to line size. Especially important to cf
2284 targets that do line reads/writes. */
2285 malloc_buf
= (unsigned char *)(((uintptr_t)malloc_buf
+ 15) & ~15);
2286 filebuf
= malloc_buf
+ MALLOC_BUFSIZE
; /* filebuf line align implied */
2287 filebuflen
= audiobufend
- filebuf
;
2291 /* Subtract whatever the pcm buffer says it used plus the guard buffer */
2292 filebuflen
-= pcmbuf_init(filebuf
+ filebuflen
) + GUARD_BUFSIZE
;
2294 /* Make sure filebuflen is a longword multiple after adjustment - filebuf
2295 will already be line aligned */
2298 buffering_reset(filebuf
, filebuflen
);
2300 /* Clear any references to the file buffer */
2301 buffer_state
= BUFFER_STATE_INITIALIZED
;
2303 #if defined(ROCKBOX_HAS_LOGF) && defined(LOGF_ENABLE)
2304 /* Make sure everything adds up - yes, some info is a bit redundant but
2305 aids viewing and the sumation of certain variables should add up to
2306 the location of others. */
2309 const unsigned char *pcmbuf
= pcmbuf_get_meminfo(&pcmbufsize
);
2310 logf("mabuf: %08X", (unsigned)malloc_buf
);
2311 logf("mabufe: %08X", (unsigned)(malloc_buf
+ MALLOC_BUFSIZE
));
2312 logf("fbuf: %08X", (unsigned)filebuf
);
2313 logf("fbufe: %08X", (unsigned)(filebuf
+ filebuflen
));
2314 logf("gbuf: %08X", (unsigned)(filebuf
+ filebuflen
));
2315 logf("gbufe: %08X", (unsigned)(filebuf
+ filebuflen
+ GUARD_BUFSIZE
));
2316 logf("pcmb: %08X", (unsigned)pcmbuf
);
2317 logf("pcmbe: %08X", (unsigned)(pcmbuf
+ pcmbufsize
));
2322 static void audio_thread(void)
2324 struct queue_event ev
;
2328 audio_thread_ready
= true;
2332 if (filling
!= STATE_FILLING
) {
2336 if (!pcmbuf_queue_scan(&ev
))
2337 queue_wait_w_tmo(&audio_queue
, &ev
, HZ
/2);
2341 case Q_AUDIO_FILL_BUFFER
:
2342 LOGFQUEUE("audio < Q_AUDIO_FILL_BUFFER %d", (int)ev
.data
);
2343 audio_fill_file_buffer((bool)ev
.data
, 0);
2346 case Q_AUDIO_FINISH_LOAD
:
2347 LOGFQUEUE("audio < Q_AUDIO_FINISH_LOAD");
2348 audio_finish_load_track();
2352 LOGFQUEUE("audio < Q_AUDIO_PLAY");
2353 if (playing
&& ev
.data
<= 0)
2354 audio_new_playlist();
2357 audio_stop_playback();
2358 audio_play_start((size_t)ev
.data
);
2363 LOGFQUEUE("audio < Q_AUDIO_STOP");
2365 audio_stop_playback();
2367 queue_clear(&audio_queue
);
2371 LOGFQUEUE("audio < Q_AUDIO_PAUSE");
2372 if (!(bool) ev
.data
&& skipped_during_pause
&& !pcmbuf_is_crossfade_active())
2373 pcmbuf_play_stop(); /* Flush old track on resume after skip */
2374 skipped_during_pause
= false;
2377 pcmbuf_pause((bool)ev
.data
);
2378 paused
= (bool)ev
.data
;
2382 LOGFQUEUE("audio < Q_AUDIO_SKIP");
2383 audio_initiate_track_change((long)ev
.data
);
2386 case Q_AUDIO_PRE_FF_REWIND
:
2387 LOGFQUEUE("audio < Q_AUDIO_PRE_FF_REWIND");
2393 case Q_AUDIO_FF_REWIND
:
2394 LOGFQUEUE("audio < Q_AUDIO_FF_REWIND");
2399 /* An automatic track skip is in progress. Finalize it,
2400 then go back to the previous track */
2401 audio_finalise_track_change();
2404 ci
.seek_time
= (long)ev
.data
+1;
2407 case Q_AUDIO_CHECK_NEW_TRACK
:
2408 LOGFQUEUE("audio < Q_AUDIO_CHECK_NEW_TRACK");
2409 queue_reply(&audio_queue
, audio_check_new_track());
2412 case Q_AUDIO_DIR_SKIP
:
2413 LOGFQUEUE("audio < Q_AUDIO_DIR_SKIP");
2414 audio_initiate_dir_change(ev
.data
);
2418 LOGFQUEUE("audio < Q_AUDIO_FLUSH");
2419 audio_invalidate_tracks();
2422 case Q_AUDIO_TRACK_CHANGED
:
2423 /* PCM track change done */
2424 LOGFQUEUE("audio < Q_AUDIO_TRACK_CHANGED");
2425 audio_finalise_track_change();
2429 case SYS_USB_CONNECTED
:
2430 LOGFQUEUE("audio < SYS_USB_CONNECTED");
2432 audio_stop_playback();
2433 #ifdef PLAYBACK_VOICE
2436 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
2437 usb_wait_for_disconnect(&audio_queue
);
2439 /* Mark all entries null. */
2440 audio_clear_track_entries();
2442 /* release tracks to make sure all handles are closed */
2443 audio_release_tracks();
2448 LOGFQUEUE_SYS_TIMEOUT("audio < SYS_TIMEOUT");
2452 LOGFQUEUE("audio < default");
2458 /* Initialize the audio system - called from init() in main.c.
2459 * Last function because of all the references to internal symbols
2461 void audio_init(void)
2463 struct thread_entry
*audio_thread_p
;
2465 /* Can never do this twice */
2466 if (audio_is_initialized
)
2468 logf("audio: already initialized");
2472 logf("audio: initializing");
2474 /* Initialize queues before giving control elsewhere in case it likes
2475 to send messages. Thread creation will be delayed however so nothing
2476 starts running until ready if something yields such as talk_init. */
2477 queue_init(&audio_queue
, true);
2478 queue_init(&codec_queue
, false);
2479 queue_init(&pcmbuf_queue
, false);
2483 /* Initialize codec api. */
2484 ci
.read_filebuf
= codec_filebuf_callback
;
2485 ci
.pcmbuf_insert
= codec_pcmbuf_insert_callback
;
2486 ci
.get_codec_memory
= codec_get_memory_callback
;
2487 ci
.request_buffer
= codec_request_buffer_callback
;
2488 ci
.advance_buffer
= codec_advance_buffer_callback
;
2489 ci
.advance_buffer_loc
= codec_advance_buffer_loc_callback
;
2490 ci
.request_next_track
= codec_request_next_track_callback
;
2491 ci
.seek_buffer
= codec_seek_buffer_callback
;
2492 ci
.seek_complete
= codec_seek_complete_callback
;
2493 ci
.set_elapsed
= codec_set_elapsed_callback
;
2494 ci
.set_offset
= codec_set_offset_callback
;
2495 ci
.configure
= codec_configure_callback
;
2496 ci
.discard_codec
= codec_discard_codec_callback
;
2497 ci
.dsp
= (struct dsp_config
*)dsp_configure(NULL
, DSP_MYDSP
,
2500 /* initialize the buffer */
2503 /* audio_reset_buffer must to know the size of voice buffer so init
2507 codec_thread_p
= create_thread(
2508 codec_thread
, codec_stack
, sizeof(codec_stack
),
2509 CREATE_THREAD_FROZEN
,
2510 codec_thread_name
IF_PRIO(, PRIORITY_PLAYBACK
)
2513 queue_enable_queue_send(&codec_queue
, &codec_queue_sender_list
,
2516 audio_thread_p
= create_thread(audio_thread
, audio_stack
,
2517 sizeof(audio_stack
), CREATE_THREAD_FROZEN
,
2518 audio_thread_name
IF_PRIO(, PRIORITY_USER_INTERFACE
)
2521 queue_enable_queue_send(&audio_queue
, &audio_queue_sender_list
,
2524 #ifdef PLAYBACK_VOICE
2525 voice_thread_init();
2528 /* Set crossfade setting for next buffer init which should be about... */
2529 pcmbuf_crossfade_enable(global_settings
.crossfade
);
2531 /* initialize the buffering system */
2534 /* ...now! Set up the buffers */
2535 audio_reset_buffer();
2538 for(i
= 0; i
< MAX_TRACK
; i
++)
2540 tracks
[i
].audio_hid
= -1;
2541 tracks
[i
].id3_hid
= -1;
2542 tracks
[i
].codec_hid
= -1;
2543 #ifdef HAVE_ALBUMART
2544 tracks
[i
].aa_hid
= -1;
2548 add_event(EVENT_HANDLE_REBUFFER
, false, buffering_handle_rebuffer_callback
);
2549 add_event(EVENT_HANDLE_FINISHED
, false, buffering_handle_finished_callback
);
2551 /* Probably safe to say */
2552 audio_is_initialized
= true;
2554 sound_settings_apply();
2555 #ifndef HAVE_FLASH_STORAGE
2556 audio_set_buffer_margin(global_settings
.buffer_margin
);
2559 /* it's safe to let the threads run now */
2560 #ifdef PLAYBACK_VOICE
2561 voice_thread_resume();
2563 thread_thaw(codec_thread_p
);
2564 thread_thaw(audio_thread_p
);
2568 void audio_wait_for_init(void)
2570 /* audio thread will only set this once after it finished the final
2571 * audio hardware init so this little construct is safe - even
2573 while (!audio_thread_ready
)