1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2002 by Linus Nielsen Feltzing
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
25 #if CONFIG_CODEC != SWCODEC
39 #include "mp3_playback.h"
51 #endif /* !SIMULATOR */
52 #ifdef HAVE_LCD_BITMAP
57 extern unsigned long mas_version_code
;
60 #if CONFIG_CODEC == MAS3587F
61 extern enum /* from mp3_playback.c */
66 #endif /* CONFIG_CODEC == MAS3587F */
68 extern char* playlist_peek(int steps
);
69 extern bool playlist_check(int steps
);
70 extern int playlist_next(int steps
);
71 extern int playlist_amount(void);
72 extern int playlist_update_resume_info(const struct mp3entry
* id3
);
80 #define MPEG_FF_REWIND 7
81 #define MPEG_FLUSH_RELOAD 8
83 #define MPEG_INIT_RECORDING 10
84 #define MPEG_INIT_PLAYBACK 11
85 #define MPEG_NEW_FILE 12
86 #define MPEG_PAUSE_RECORDING 13
87 #define MPEG_RESUME_RECORDING 14
88 #define MPEG_NEED_DATA 100
89 #define MPEG_TRACK_CHANGE 101
90 #define MPEG_SAVE_DATA 102
91 #define MPEG_STOP_DONE 103
92 #define MPEG_PRERECORDING_TICK 104
94 /* indicator for MPEG_NEED_DATA */
95 #define GENERATE_UNBUFFER_EVENTS 1
97 /* list of tracks in memory */
98 #define MAX_TRACK_ENTRIES (1<<4) /* Must be power of 2 */
99 #define MAX_TRACK_ENTRIES_MASK (MAX_TRACK_ENTRIES - 1)
105 int load_ahead_index
;
108 static struct trackdata trackdata
[MAX_TRACK_ENTRIES
];
110 static unsigned int current_track_counter
= 0;
111 static unsigned int last_track_counter
= 0;
113 /* Play time of the previous track */
114 unsigned long prev_track_elapsed
;
117 static int track_read_idx
= 0;
118 static int track_write_idx
= 0;
119 #endif /* !SIMULATOR */
121 /* Cuesheet callback */
122 static bool (*cuesheet_callback
)(const char *filename
) = NULL
;
124 static const char mpeg_thread_name
[] = "mpeg";
125 static unsigned int mpeg_errno
;
127 static bool playing
= false; /* We are playing an MP3 stream */
128 static bool is_playing
= false; /* We are (attempting to) playing MP3 files */
129 static bool paused
; /* playback is paused */
132 static char mpeg_stack
[DEFAULT_STACK_SIZE
];
133 static struct mp3entry taginfo
;
135 #else /* !SIMULATOR */
136 static struct event_queue mpeg_queue
;
137 static long mpeg_stack
[(DEFAULT_STACK_SIZE
+ 0x1000)/sizeof(long)];
139 static int audiobuflen
;
140 static int audiobuf_write
;
141 static int audiobuf_swapwrite
;
142 static int audiobuf_read
;
144 static int mpeg_file
;
146 static bool play_pending
; /* We are about to start playing */
147 static bool play_pending_track_change
; /* When starting play we're starting a new file */
148 static bool filling
; /* We are filling the buffer with data from disk */
149 static bool dma_underrun
; /* True when the DMA has stopped because of
150 slow disk reading (read error, shaking) */
151 static bool mpeg_stop_done
;
153 static int last_dma_tick
= 0;
154 static int last_dma_chunk_size
;
156 static long low_watermark
; /* Dynamic low watermark level */
157 static long low_watermark_margin
= 0; /* Extra time in seconds for watermark */
158 static long lowest_watermark_level
; /* Debug value to observe the buffer
160 #if CONFIG_CODEC == MAS3587F
161 static char recording_filename
[MAX_PATH
]; /* argument to thread */
162 static char delayed_filename
[MAX_PATH
]; /* internal copy of above */
164 static char xing_buffer
[MAX_XING_HEADER_SIZE
];
166 static bool init_recording_done
;
167 static bool init_playback_done
;
168 static bool prerecording
; /* True if prerecording is enabled */
169 static bool is_prerecording
; /* True if we are prerecording */
170 static bool is_recording
; /* We are recording */
173 NOT_SAVING
= 0, /* reasons to save data, sorted by importance */
179 static int rec_frequency_index
; /* For create_xing_header() calls */
180 static int rec_version_index
; /* For create_xing_header() calls */
182 struct prerecord_info
{
184 unsigned long framecount
;
187 static struct prerecord_info prerecord_buffer
[MPEG_MAX_PRERECORD_SECONDS
];
188 static int prerecord_index
; /* Current index in the prerecord buffer */
189 static int prerecording_max_seconds
; /* Max number of seconds to store */
190 static int prerecord_count
; /* Number of seconds in the prerecord buffer */
191 static int prerecord_timeout
; /* The tick count of the next prerecord data
194 unsigned long record_start_time
; /* Value of current_tick when recording
196 unsigned long pause_start_time
; /* Value of current_tick when pause was
198 static unsigned long last_rec_time
;
199 static unsigned long num_rec_bytes
;
200 static unsigned long last_rec_bytes
;
201 static unsigned long frame_count_start
;
202 static unsigned long frame_count_end
;
203 static unsigned long saved_header
= 0;
205 /* Shadow MAS registers */
206 unsigned long shadow_encoder_control
= 0;
207 #endif /* CONFIG_CODEC == MAS3587F */
209 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
210 unsigned long shadow_io_control_main
= 0;
211 unsigned long shadow_soft_mute
= 0;
212 unsigned shadow_codec_reg0
;
213 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */
215 #ifdef HAVE_RECORDING
216 static const unsigned char empty_id3_header
[] =
218 'I', 'D', '3', 0x03, 0x00, 0x00,
219 0x00, 0x00, 0x1f, 0x76 /* Size is 4096 minus 10 bytes for the header */
221 #endif /* HAVE_RECORDING */
224 static int get_unplayed_space(void);
225 static int get_playable_space(void);
226 static int get_unswapped_space(void);
227 #endif /* !SIMULATOR */
229 #if (CONFIG_CODEC == MAS3587F) && !defined(SIMULATOR)
230 static void init_recording(void);
231 static void prepend_header(void);
232 static void update_header(void);
233 static void start_prerecording(void);
234 static void start_recording(void);
235 static void stop_recording(void);
236 static int get_unsaved_space(void);
237 static void pause_recording(void);
238 static void resume_recording(void);
239 #endif /* (CONFIG_CODEC == MAS3587F) && !defined(SIMULATOR) */
243 static int num_tracks_in_memory(void)
245 return (track_write_idx
- track_read_idx
) & MAX_TRACK_ENTRIES_MASK
;
249 static void debug_tags(void)
253 for(i
= 0;i
< MAX_TRACK_ENTRIES
;i
++)
255 DEBUGF("%d - %s\n", i
, trackdata
[i
].id3
.path
);
257 DEBUGF("read: %d, write :%d\n", track_read_idx
, track_write_idx
);
258 DEBUGF("num_tracks_in_memory: %d\n", num_tracks_in_memory());
260 #else /* !DEBUG_TAGS */
262 #endif /* !DEBUG_TAGS */
264 static void remove_current_tag(void)
266 if(num_tracks_in_memory() > 0)
268 /* First move the index, so nobody tries to access the tag */
269 track_read_idx
= (track_read_idx
+1) & MAX_TRACK_ENTRIES_MASK
;
274 DEBUGF("remove_current_tag: no tracks to remove\n");
278 static void remove_all_non_current_tags(void)
280 track_write_idx
= (track_read_idx
+1) & MAX_TRACK_ENTRIES_MASK
;
284 static void remove_all_tags(void)
286 track_write_idx
= track_read_idx
;
291 static struct trackdata
*get_trackdata(int offset
)
293 if(offset
>= num_tracks_in_memory())
296 return &trackdata
[(track_read_idx
+ offset
) & MAX_TRACK_ENTRIES_MASK
];
298 #endif /* !SIMULATOR */
300 /***********************************************************************/
301 /* audio event handling */
303 #define MAX_EVENT_HANDLERS 10
304 struct event_handlers_table
306 AUDIO_EVENT_HANDLER handler
;
309 static struct event_handlers_table event_handlers
[MAX_EVENT_HANDLERS
];
310 static int event_handlers_count
= 0;
312 void audio_register_event_handler(AUDIO_EVENT_HANDLER handler
, unsigned short mask
)
314 if (event_handlers_count
< MAX_EVENT_HANDLERS
)
316 event_handlers
[event_handlers_count
].handler
= handler
;
317 event_handlers
[event_handlers_count
].mask
= mask
;
318 event_handlers_count
++;
322 /* dispatch calls each handler in the order registered and returns after some
323 handler actually handles the event (the event is assumed to no longer be valid
324 after this, due to the handler changing some condition); returns true if someone
325 handled the event, which is expected to cause the caller to skip its own handling
328 static bool audio_dispatch_event(unsigned short event
, unsigned long data
)
331 for(i
=0; i
< event_handlers_count
; i
++)
333 if ( event_handlers
[i
].mask
& event
)
335 int rc
= event_handlers
[i
].handler(event
, data
);
336 if ( rc
== AUDIO_EVENT_RC_HANDLED
)
344 /***********************************************************************/
346 static void set_elapsed(struct mp3entry
* id3
)
349 if ( id3
->has_toc
) {
350 /* calculate elapsed time using TOC */
352 unsigned int remainder
, plen
, relpos
, nextpos
;
354 /* find wich percent we're at */
355 for (i
=0; i
<100; i
++ )
357 if ( id3
->offset
< id3
->toc
[i
] * (id3
->filesize
/ 256) )
367 relpos
= id3
->toc
[i
];
371 nextpos
= id3
->toc
[i
+1];
378 remainder
= id3
->offset
- (relpos
* (id3
->filesize
/ 256));
380 /* set time for this percent (divide before multiply to prevent
381 overflow on long files. loss of precision is negligible on
383 id3
->elapsed
= i
* (id3
->length
/ 100);
385 /* calculate remainder time */
386 plen
= (nextpos
- relpos
) * (id3
->filesize
/ 256);
387 id3
->elapsed
+= (((remainder
* 100) / plen
) *
388 (id3
->length
/ 10000));
391 /* no TOC exists. set a rough estimate using average bitrate */
392 int tpk
= id3
->length
/ (id3
->filesize
/ 1024);
393 id3
->elapsed
= id3
->offset
/ 1024 * tpk
;
397 /* constant bitrate, use exact calculation */
398 id3
->elapsed
= id3
->offset
/ (id3
->bitrate
/ 8);
401 int audio_get_file_pos(void)
404 struct mp3entry
*id3
= audio_current_track();
410 /* Use the TOC to find the new position */
411 unsigned int percent
, remainder
;
412 int curtoc
, nexttoc
, plen
;
414 percent
= (id3
->elapsed
*100)/id3
->length
;
418 curtoc
= id3
->toc
[percent
];
421 nexttoc
= id3
->toc
[percent
+1];
425 pos
= (id3
->filesize
/256)*curtoc
;
427 /* Use the remainder to get a more accurate position */
428 remainder
= (id3
->elapsed
*100)%id3
->length
;
429 remainder
= (remainder
*100)/id3
->length
;
430 plen
= (nexttoc
- curtoc
)*(id3
->filesize
/256);
431 pos
+= (plen
/100)*remainder
;
435 /* No TOC exists, estimate the new position */
436 pos
= (id3
->filesize
/ (id3
->length
/ 1000)) *
437 (id3
->elapsed
/ 1000);
440 else if (id3
->bitrate
)
441 pos
= id3
->elapsed
* (id3
->bitrate
/ 8);
447 if (pos
>= (int)(id3
->filesize
- id3
->id3v1len
))
449 /* Don't seek right to the end of the file so that we can
450 transition properly to the next song */
451 pos
= id3
->filesize
- id3
->id3v1len
- 1;
453 else if (pos
< (int)id3
->first_frame_offset
)
455 /* skip past id3v2 tag and other leading garbage */
456 pos
= id3
->first_frame_offset
;
461 unsigned long mpeg_get_last_header(void)
465 #else /* !SIMULATOR */
466 unsigned long tmp
[2];
468 /* Read the frame data from the MAS and reconstruct it with the
469 frame sync and all */
470 mas_readmem(MAS_BANK_D0
, MAS_D0_MPEG_STATUS_1
, tmp
, 2);
471 return 0xffe00000 | ((tmp
[0] & 0x7c00) << 6) | (tmp
[1] & 0xffff);
472 #endif /* !SIMULATOR */
475 void audio_set_cuesheet_callback(bool (*handler
)(const char *filename
))
477 cuesheet_callback
= handler
;
481 /* Send callback events to notify about removing old tracks. */
482 static void generate_unbuffer_events(void)
485 int numentries
= MAX_TRACK_ENTRIES
- num_tracks_in_memory();
486 int cur_idx
= track_write_idx
;
488 for (i
= 0; i
< numentries
; i
++)
490 /* Send an event to notify that track has finished. */
491 send_event(PLAYBACK_EVENT_TRACK_FINISH
, &trackdata
[cur_idx
].id3
);
492 cur_idx
= (cur_idx
+ 1) & MAX_TRACK_ENTRIES_MASK
;
496 /* Send callback events to notify about new tracks. */
497 static void generate_postbuffer_events(void)
500 int numentries
= num_tracks_in_memory();
501 int cur_idx
= track_read_idx
;
503 for (i
= 0; i
< numentries
; i
++)
505 send_event(PLAYBACK_EVENT_TRACK_BUFFER
, &trackdata
[cur_idx
].id3
);
506 cur_idx
= (cur_idx
+ 1) & MAX_TRACK_ENTRIES_MASK
;
510 static void recalculate_watermark(int bitrate
)
513 int time
= ata_spinup_time
;
515 /* A bitrate of 0 probably means empty VBR header. We play safe
516 and set a high threshold */
520 bytes_per_sec
= bitrate
* 1000 / 8;
524 /* No drive spins up faster than 3.5s */
529 low_watermark
= ((low_watermark_margin
* HZ
+ time
) *
534 low_watermark
= MPEG_LOW_WATER
;
538 #ifndef HAVE_FLASH_STORAGE
539 void audio_set_buffer_margin(int seconds
)
541 low_watermark_margin
= seconds
;
545 void audio_get_debugdata(struct audio_debug
*dbgdata
)
547 dbgdata
->audiobuflen
= audiobuflen
;
548 dbgdata
->audiobuf_write
= audiobuf_write
;
549 dbgdata
->audiobuf_swapwrite
= audiobuf_swapwrite
;
550 dbgdata
->audiobuf_read
= audiobuf_read
;
552 dbgdata
->last_dma_chunk_size
= last_dma_chunk_size
;
554 #if CONFIG_CPU == SH7034
555 dbgdata
->dma_on
= (SCR0
& 0x80) != 0;
557 dbgdata
->playing
= playing
;
558 dbgdata
->play_pending
= play_pending
;
559 dbgdata
->is_playing
= is_playing
;
560 dbgdata
->filling
= filling
;
561 dbgdata
->dma_underrun
= dma_underrun
;
563 dbgdata
->unplayed_space
= get_unplayed_space();
564 dbgdata
->playable_space
= get_playable_space();
565 dbgdata
->unswapped_space
= get_unswapped_space();
567 dbgdata
->low_watermark_level
= low_watermark
;
568 dbgdata
->lowest_watermark_level
= lowest_watermark_level
;
572 static void dbg_timer_start(void)
574 /* We are using timer 2 */
576 TSTR
&= ~0x04; /* Stop the timer */
577 TSNC
&= ~0x04; /* No synchronization */
578 TMDR
&= ~0x44; /* Operate normally */
580 TCNT2
= 0; /* Start counting at 0 */
581 TCR2
= 0x03; /* Sysclock/8 */
583 TSTR
|= 0x04; /* Start timer 2 */
586 static int dbg_cnt2us(unsigned int cnt
)
588 return (cnt
* 10000) / (FREQ
/800);
592 static int get_unplayed_space(void)
594 int space
= audiobuf_write
- audiobuf_read
;
596 space
+= audiobuflen
;
600 static int get_playable_space(void)
602 int space
= audiobuf_swapwrite
- audiobuf_read
;
604 space
+= audiobuflen
;
608 static int get_unplayed_space_current_song(void)
612 if (num_tracks_in_memory() > 1)
614 space
= get_trackdata(1)->mempos
- audiobuf_read
;
618 space
= audiobuf_write
- audiobuf_read
;
622 space
+= audiobuflen
;
627 static int get_unswapped_space(void)
629 int space
= audiobuf_write
- audiobuf_swapwrite
;
631 space
+= audiobuflen
;
635 #if CONFIG_CODEC == MAS3587F
636 static int get_unsaved_space(void)
638 int space
= audiobuf_write
- audiobuf_read
;
640 space
+= audiobuflen
;
644 static void drain_dma_buffer(void)
650 while (PBDRH
& 0x80);
654 while (!(PBDRH
& 0x80));
659 static long timing_info_index
= 0;
660 static long timing_info
[1024];
663 void rec_tick (void) __attribute__ ((section (".icode")));
670 if(is_recording
&& (PBDRH
& 0x40))
673 timing_info
[timing_info_index
++] = current_tick
;
676 /* Note: Although this loop is run in interrupt context, further
677 * optimisation will do no good. The MAS would then deliver bad
678 * frames occasionally, as observed in extended experiments. */
680 while (PBDRH
& 0x40) /* We try to read as long as EOD is high */
682 xor_b(0x08, &PADRH
); /* Set PR active, independent of polarity */
685 while (PBDRH
& 0x80) /* Wait until /RTW becomes active */
687 if (--delay
<= 0) /* Bail out if we have to wait too long */
688 { /* i.e. the MAS doesn't want to talk to us */
689 xor_b(0x08, &PADRH
); /* Set PR inactive */
690 goto transfer_end
; /* and get out of here */
694 data
= *(unsigned char *)0x04000000; /* read data byte */
696 xor_b(0x08, &PADRH
); /* Set PR inactive */
698 audiobuf
[audiobuf_write
++] = data
;
700 if (audiobuf_write
>= audiobuflen
)
708 timing_info
[timing_info_index
++] = TCNT2
+ (i
<< 16);
709 timing_info_index
&= 0x3ff;
716 if(TIME_AFTER(current_tick
, prerecord_timeout
))
718 prerecord_timeout
= current_tick
+ HZ
;
719 queue_post(&mpeg_queue
, MPEG_PRERECORDING_TICK
, 0);
724 /* Signal to save the data if we are running out of buffer
726 if (audiobuflen
- get_unsaved_space() < MPEG_RECORDING_LOW_WATER
727 && saving_status
== NOT_SAVING
)
729 saving_status
= BUFFER_FULL
;
730 queue_post(&mpeg_queue
, MPEG_SAVE_DATA
, 0);
735 #endif /* CONFIG_CODEC == MAS3587F */
737 void playback_tick(void)
739 struct trackdata
*ptd
= get_trackdata(0);
742 ptd
->id3
.elapsed
+= (current_tick
- last_dma_tick
) * 1000 / HZ
;
743 last_dma_tick
= current_tick
;
744 audio_dispatch_event(AUDIO_EVENT_POS_REPORT
,
745 (unsigned long)ptd
->id3
.elapsed
);
749 static void reset_mp3_buffer(void)
753 audiobuf_swapwrite
= 0;
754 lowest_watermark_level
= audiobuflen
;
757 /* DMA transfer end interrupt callback */
758 static void transfer_end(unsigned char** ppbuf
, size_t* psize
)
760 if(playing
&& !paused
)
762 int unplayed_space_left
;
763 int space_until_end_of_buffer
;
764 int track_offset
= 1;
765 struct trackdata
*track
;
767 audiobuf_read
+= last_dma_chunk_size
;
768 if(audiobuf_read
>= audiobuflen
)
771 /* First, check if we are on a track boundary */
772 if (num_tracks_in_memory() > 1)
774 if (audiobuf_read
== get_trackdata(track_offset
)->mempos
)
776 if ( ! audio_dispatch_event(AUDIO_EVENT_END_OF_TRACK
, 0) )
778 queue_post(&mpeg_queue
, MPEG_TRACK_CHANGE
, 0);
784 unplayed_space_left
= get_unplayed_space();
786 space_until_end_of_buffer
= audiobuflen
- audiobuf_read
;
788 if(!filling
&& unplayed_space_left
< low_watermark
)
791 queue_post(&mpeg_queue
, MPEG_NEED_DATA
, GENERATE_UNBUFFER_EVENTS
);
794 if(unplayed_space_left
)
796 last_dma_chunk_size
= MIN(0x2000, unplayed_space_left
);
797 last_dma_chunk_size
= MIN(last_dma_chunk_size
,
798 space_until_end_of_buffer
);
800 /* several tracks loaded? */
801 track
= get_trackdata(track_offset
);
804 /* will we move across the track boundary? */
805 if (( audiobuf_read
< track
->mempos
) &&
806 ((audiobuf_read
+last_dma_chunk_size
) >
809 /* Make sure that we end exactly on the boundary */
810 last_dma_chunk_size
= track
->mempos
- audiobuf_read
;
814 *psize
= last_dma_chunk_size
& 0xffff;
815 *ppbuf
= audiobuf
+ audiobuf_read
;
816 track
= get_trackdata(0);
818 track
->id3
.offset
+= last_dma_chunk_size
;
820 /* Update the watermark debug level */
821 if(unplayed_space_left
< lowest_watermark_level
)
822 lowest_watermark_level
= unplayed_space_left
;
826 /* Check if the end of data is because of a hard disk error.
827 If there is an open file handle, we are still playing music.
828 If not, the last file has been loaded, and the file handle is
832 /* Update the watermark debug level */
833 if(unplayed_space_left
< lowest_watermark_level
)
834 lowest_watermark_level
= unplayed_space_left
;
836 DEBUGF("DMA underrun.\n");
841 if ( ! audio_dispatch_event(AUDIO_EVENT_END_OF_TRACK
, 0) )
843 DEBUGF("No more MP3 data. Stopping.\n");
844 queue_post(&mpeg_queue
, MPEG_TRACK_CHANGE
, 0);
848 *psize
= 0; /* no more transfer */
853 static struct trackdata
*add_track_to_tag_list(const char *filename
)
855 struct trackdata
*track
;
857 if(num_tracks_in_memory() >= MAX_TRACK_ENTRIES
)
859 DEBUGF("Tag memory is full\n");
863 track
= &trackdata
[track_write_idx
];
865 /* grab id3 tag of new file and
866 remember where in memory it starts */
867 if(mp3info(&track
->id3
, filename
))
872 track
->mempos
= audiobuf_write
;
873 track
->id3
.elapsed
= 0;
874 #ifdef HAVE_LCD_BITMAP
875 if (track
->id3
.title
)
876 lcd_getstringsize(track
->id3
.title
, NULL
, NULL
);
877 if (track
->id3
.artist
)
878 lcd_getstringsize(track
->id3
.artist
, NULL
, NULL
);
879 if (track
->id3
.album
)
880 lcd_getstringsize(track
->id3
.album
, NULL
, NULL
);
882 if (cuesheet_callback
)
883 if (cuesheet_callback(filename
))
884 track
->id3
.cuesheet_type
= 1;
886 track_write_idx
= (track_write_idx
+1) & MAX_TRACK_ENTRIES_MASK
;
891 static int new_file(int steps
)
893 int max_steps
= playlist_amount();
896 struct trackdata
*track
;
898 /* Find out how many steps to advance. The load_ahead_index field tells
899 us how many playlist entries it had to skip to get to a valid one.
900 We add those together to find out where to start. */
901 if(steps
> 0 && num_tracks_in_memory() > 1)
903 /* Begin with the song after the currently playing one */
905 while((track
= get_trackdata(i
++)))
907 start
+= track
->load_ahead_index
;
914 trackname
= playlist_peek( start
+ steps
);
918 DEBUGF("Loading %s\n", trackname
);
920 mpeg_file
= open(trackname
, O_RDONLY
);
922 DEBUGF("Couldn't open file: %s\n",trackname
);
930 struct trackdata
*track
= add_track_to_tag_list(trackname
);
944 /* skip past id3v2 tag */
946 track
->id3
.first_frame_offset
,
948 track
->id3
.index
= steps
;
949 track
->load_ahead_index
= steps
;
950 track
->id3
.offset
= 0;
953 /* Average bitrate * 1.5 */
954 recalculate_watermark(
955 (track
->id3
.bitrate
* 3) / 2);
957 recalculate_watermark(
963 /* Bail out if no file could be opened */
964 if(abs(steps
) > max_steps
)
966 } while ( mpeg_file
< 0 );
971 static void stop_playing(void)
973 struct trackdata
*track
;
975 /* Stop the current stream */
980 track
= get_trackdata(0);
982 prev_track_elapsed
= track
->id3
.elapsed
;
988 generate_unbuffer_events();
992 static void end_current_track(void) {
993 struct trackdata
*track
;
995 play_pending
= false;
997 mp3_play_pause(false);
999 track
= get_trackdata(0);
1001 prev_track_elapsed
= track
->id3
.elapsed
;
1005 generate_unbuffer_events();
1011 /* Is this a really the end of playback or is a new playlist starting */
1012 static void check_playlist_end(int direction
)
1014 /* Use the largest possible step size to account for skipped tracks */
1015 int steps
= playlist_amount();
1020 if (playlist_next(steps
) < 0)
1024 static void update_playlist(void)
1026 if (num_tracks_in_memory() > 0)
1028 struct trackdata
*track
= get_trackdata(0);
1029 track
->id3
.index
= playlist_next(track
->id3
.index
);
1033 /* End of playlist? */
1034 check_playlist_end(1);
1037 playlist_update_resume_info(audio_current_track());
1040 static void track_change(void)
1042 DEBUGF("Track change\n");
1044 struct trackdata
*track
= get_trackdata(0);
1045 prev_track_elapsed
= track
->id3
.elapsed
;
1047 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
1050 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */
1052 if (num_tracks_in_memory() > 0)
1054 remove_current_tag();
1055 send_event(PLAYBACK_EVENT_TRACK_CHANGE
, audio_current_track());
1059 current_track_counter
++;
1062 unsigned long audio_prev_elapsed(void)
1064 return prev_track_elapsed
;
1068 void hexdump(const unsigned char *buf
, int len
)
1072 for(i
= 0;i
< len
;i
++)
1074 if(i
&& (i
& 15) == 0)
1078 DEBUGF("%02x ", buf
[i
]);
1084 static void start_playback_if_ready(void)
1088 playable_space
= audiobuf_swapwrite
- audiobuf_read
;
1089 if(playable_space
< 0)
1090 playable_space
+= audiobuflen
;
1092 /* See if we have started playing yet. If not, do it. */
1093 if(play_pending
|| dma_underrun
)
1095 /* If the filling has stopped, and we still haven't reached
1096 the watermark, the file must be smaller than the
1097 watermark. We must still play it. */
1098 if((playable_space
>= MPEG_PLAY_PENDING_THRESHOLD
) ||
1099 !filling
|| dma_underrun
)
1102 if (play_pending
) /* don't do this when recovering from DMA underrun */
1104 generate_postbuffer_events(); /* signal first track as buffered */
1105 if (play_pending_track_change
)
1107 play_pending_track_change
= false;
1108 send_event(PLAYBACK_EVENT_TRACK_CHANGE
, audio_current_track());
1110 play_pending
= false;
1114 last_dma_chunk_size
= MIN(0x2000, get_unplayed_space_current_song());
1115 mp3_play_data(audiobuf
+ audiobuf_read
, last_dma_chunk_size
, transfer_end
);
1116 dma_underrun
= false;
1120 last_dma_tick
= current_tick
;
1121 mp3_play_pause(true);
1124 /* Tell ourselves that we need more data */
1125 queue_post(&mpeg_queue
, MPEG_NEED_DATA
, 0);
1130 static bool swap_one_chunk(void)
1132 int free_space_left
;
1135 free_space_left
= get_unswapped_space();
1137 if(free_space_left
== 0 && !play_pending
)
1140 /* Swap in larger chunks when the user is waiting for the playback
1141 to start, or when there is dangerously little playable data left */
1143 amount_to_swap
= MIN(MPEG_PLAY_PENDING_SWAPSIZE
, free_space_left
);
1146 if(get_playable_space() < low_watermark
)
1147 amount_to_swap
= MIN(MPEG_LOW_WATER_SWAP_CHUNKSIZE
,
1150 amount_to_swap
= MIN(MPEG_SWAP_CHUNKSIZE
, free_space_left
);
1153 if(audiobuf_write
< audiobuf_swapwrite
)
1154 amount_to_swap
= MIN(audiobuflen
- audiobuf_swapwrite
,
1157 amount_to_swap
= MIN(audiobuf_write
- audiobuf_swapwrite
,
1160 bitswap(audiobuf
+ audiobuf_swapwrite
, amount_to_swap
);
1162 audiobuf_swapwrite
+= amount_to_swap
;
1163 if(audiobuf_swapwrite
>= audiobuflen
)
1165 audiobuf_swapwrite
= 0;
1171 static void mpeg_thread(void)
1173 static int pause_tick
= 0;
1174 static unsigned int pause_track
= 0;
1175 struct queue_event ev
;
1177 int free_space_left
;
1178 int unplayed_space_left
;
1182 #if CONFIG_CODEC == MAS3587F
1184 int save_endpos
= 0;
1188 #endif /* CONFIG_CODEC == MAS3587F */
1191 play_pending
= false;
1197 #if CONFIG_CODEC == MAS3587F
1198 if(mpeg_mode
== MPEG_DECODER
)
1200 #endif /* CONFIG_CODEC == MAS3587F */
1203 /* Swap if necessary, and don't block on the queue_wait() */
1204 if(swap_one_chunk())
1206 queue_wait_w_tmo(&mpeg_queue
, &ev
, 0);
1210 /* periodically update resume info */
1211 queue_wait_w_tmo(&mpeg_queue
, &ev
, HZ
/2);
1215 DEBUGF("S R:%x W:%x SW:%x\n",
1216 audiobuf_read
, audiobuf_write
, audiobuf_swapwrite
);
1217 queue_wait(&mpeg_queue
, &ev
);
1220 start_playback_if_ready();
1225 DEBUGF("MPEG_PLAY\n");
1228 /* Silence the A/D input, it may be on because the radio
1230 mas_codec_writereg(6, 0x0000);
1231 #endif /* CONFIG_TUNER */
1233 /* Stop the current stream */
1235 end_current_track();
1237 if ( new_file(0) == -1 )
1244 start_offset
= (int)ev
.data
;
1246 /* mid-song resume? */
1248 struct mp3entry
* id3
= &get_trackdata(0)->id3
;
1249 lseek(mpeg_file
, start_offset
, SEEK_SET
);
1250 id3
->offset
= start_offset
;
1254 /* skip past id3v2 tag */
1256 get_trackdata(0)->id3
.first_frame_offset
,
1261 /* Make it read more data */
1263 queue_post(&mpeg_queue
, MPEG_NEED_DATA
, 0);
1265 /* Tell the file loading code that we want to start playing
1266 as soon as we have some data */
1267 play_pending
= true;
1268 play_pending_track_change
= true;
1271 current_track_counter
++;
1275 DEBUGF("MPEG_STOP\n");
1280 playlist_update_resume_info(audio_current_track());
1283 mpeg_stop_done
= true;
1287 DEBUGF("MPEG_PAUSE\n");
1288 /* Stop the current stream */
1290 playlist_update_resume_info(audio_current_track());
1293 pause_tick
= current_tick
;
1294 pause_track
= current_track_counter
;
1295 mp3_play_pause(false);
1299 DEBUGF("MPEG_RESUME\n");
1300 /* Continue the current stream */
1305 if ( current_track_counter
== pause_track
)
1306 last_dma_tick
+= current_tick
- pause_tick
;
1308 last_dma_tick
= current_tick
;
1310 mp3_play_pause(true);
1315 DEBUGF("MPEG_NEXT\n");
1316 /* is next track in ram? */
1317 if ( num_tracks_in_memory() > 1 ) {
1318 int unplayed_space_left
, unswapped_space_left
;
1320 /* stop the current stream */
1321 play_pending
= false;
1323 mp3_play_pause(false);
1326 audiobuf_read
= get_trackdata(0)->mempos
;
1327 last_dma_chunk_size
= MIN(0x2000, get_unplayed_space_current_song());
1328 mp3_play_data(audiobuf
+ audiobuf_read
, last_dma_chunk_size
, transfer_end
);
1329 dma_underrun
= false;
1330 last_dma_tick
= current_tick
;
1332 unplayed_space_left
= get_unplayed_space();
1333 unswapped_space_left
= get_unswapped_space();
1335 /* should we start reading more data? */
1336 if(!filling
&& (unplayed_space_left
< low_watermark
)) {
1338 queue_post(&mpeg_queue
, MPEG_NEED_DATA
, GENERATE_UNBUFFER_EVENTS
);
1339 play_pending
= true;
1340 } else if(unswapped_space_left
&&
1341 unswapped_space_left
> unplayed_space_left
) {
1342 /* Stop swapping the data from the previous file */
1343 audiobuf_swapwrite
= audiobuf_read
;
1344 play_pending
= true;
1348 mp3_play_pause(true);
1352 if (!playlist_check(1))
1355 /* stop the current stream */
1356 end_current_track();
1358 if (new_file(1) < 0) {
1359 DEBUGF("No more files to play\n");
1362 check_playlist_end(1);
1363 current_track_counter
++;
1365 /* Make it read more data */
1367 queue_post(&mpeg_queue
, MPEG_NEED_DATA
, 0);
1369 /* Tell the file loading code that we want
1370 to start playing as soon as we have some data */
1371 play_pending
= true;
1372 play_pending_track_change
= true;
1375 current_track_counter
++;
1381 DEBUGF("MPEG_PREV\n");
1383 if (!playlist_check(-1))
1386 /* stop the current stream */
1387 end_current_track();
1389 /* Open the next file */
1390 if (new_file(-1) < 0) {
1391 DEBUGF("No more files to play\n");
1394 check_playlist_end(-1);
1395 current_track_counter
++;
1397 /* Make it read more data */
1399 queue_post(&mpeg_queue
, MPEG_NEED_DATA
, 0);
1401 /* Tell the file loading code that we want to
1402 start playing as soon as we have some data */
1403 play_pending
= true;
1404 play_pending_track_change
= true;
1407 current_track_counter
++;
1412 case MPEG_FF_REWIND
: {
1413 struct mp3entry
*id3
= audio_current_track();
1414 unsigned int oldtime
= id3
->elapsed
;
1415 unsigned int newtime
= (unsigned int)ev
.data
;
1416 int curpos
, newpos
, diffpos
;
1417 DEBUGF("MPEG_FF_REWIND\n");
1419 id3
->elapsed
= newtime
;
1421 newpos
= audio_get_file_pos();
1424 id3
->elapsed
= oldtime
;
1429 curpos
= lseek(mpeg_file
, 0, SEEK_CUR
);
1431 curpos
= id3
->filesize
;
1433 if (num_tracks_in_memory() > 1)
1435 /* We have started loading other tracks that need to be
1437 struct trackdata
*track
;
1440 while((track
= get_trackdata(i
++)))
1442 curpos
+= track
->id3
.filesize
;
1446 diffpos
= curpos
- newpos
;
1448 if(!filling
&& diffpos
>= 0 && diffpos
< audiobuflen
)
1450 int unplayed_space_left
, unswapped_space_left
;
1452 /* We are changing to a position that's already in
1453 memory, so we just move the DMA read pointer. */
1454 audiobuf_read
= audiobuf_write
- diffpos
;
1455 if (audiobuf_read
< 0)
1457 audiobuf_read
+= audiobuflen
;
1460 unplayed_space_left
= get_unplayed_space();
1461 unswapped_space_left
= get_unswapped_space();
1463 /* If unswapped_space_left is larger than
1464 unplayed_space_left, it means that the swapwrite pointer
1465 hasn't yet advanced up to the new location of the read
1466 pointer. We just move it, there is no need to swap
1467 data that won't be played anyway. */
1469 if (unswapped_space_left
> unplayed_space_left
)
1471 DEBUGF("Moved swapwrite\n");
1472 audiobuf_swapwrite
= audiobuf_read
;
1473 play_pending
= true;
1476 if (mpeg_file
>=0 && unplayed_space_left
< low_watermark
)
1478 /* We need to load more data before starting */
1480 queue_post(&mpeg_queue
, MPEG_NEED_DATA
, GENERATE_UNBUFFER_EVENTS
);
1481 play_pending
= true;
1485 /* resume will start at new position */
1486 last_dma_chunk_size
=
1487 MIN(0x2000, get_unplayed_space_current_song());
1488 mp3_play_data(audiobuf
+ audiobuf_read
,
1489 last_dma_chunk_size
, transfer_end
);
1490 dma_underrun
= false;
1495 /* Move to the new position in the file and start
1499 if (num_tracks_in_memory() > 1)
1501 /* We have to reload the current track */
1503 remove_all_non_current_tags();
1504 generate_unbuffer_events();
1510 mpeg_file
= open(id3
->path
, O_RDONLY
);
1513 id3
->elapsed
= oldtime
;
1518 if(-1 == lseek(mpeg_file
, newpos
, SEEK_SET
))
1520 id3
->elapsed
= oldtime
;
1525 queue_post(&mpeg_queue
, MPEG_NEED_DATA
, 0);
1527 /* Tell the file loading code that we want to start playing
1528 as soon as we have some data */
1529 play_pending
= true;
1532 id3
->offset
= newpos
;
1537 case MPEG_FLUSH_RELOAD
: {
1538 int numtracks
= num_tracks_in_memory();
1539 bool reload_track
= false;
1543 /* Reset the buffer */
1544 audiobuf_write
= get_trackdata(1)->mempos
;
1546 /* Reset swapwrite unless we're still swapping current
1548 if (get_unplayed_space() <= get_playable_space())
1549 audiobuf_swapwrite
= audiobuf_write
;
1552 remove_all_non_current_tags();
1553 generate_unbuffer_events();
1555 reload_track
= true;
1557 else if (numtracks
== 1 && mpeg_file
< 0)
1559 reload_track
= true;
1562 if(reload_track
&& new_file(1) >= 0)
1564 /* Tell ourselves that we want more data */
1566 queue_post(&mpeg_queue
, MPEG_NEED_DATA
, 0);
1572 case MPEG_NEED_DATA
:
1573 free_space_left
= audiobuf_read
- audiobuf_write
;
1575 /* We interpret 0 as "empty buffer" */
1576 if(free_space_left
<= 0)
1577 free_space_left
+= audiobuflen
;
1579 unplayed_space_left
= audiobuflen
- free_space_left
;
1581 /* Make sure that we don't fill the entire buffer */
1582 free_space_left
-= MPEG_HIGH_WATER
;
1584 if (ev
.data
== GENERATE_UNBUFFER_EVENTS
)
1585 generate_unbuffer_events();
1587 /* do we have any more buffer space to fill? */
1588 if(free_space_left
<= 0)
1592 generate_postbuffer_events();
1597 /* Read small chunks while we are below the low water mark */
1598 if(unplayed_space_left
< low_watermark
)
1599 amount_to_read
= MIN(MPEG_LOW_WATER_CHUNKSIZE
,
1602 amount_to_read
= free_space_left
;
1604 /* Don't read more than until the end of the buffer */
1605 amount_to_read
= MIN(audiobuflen
- audiobuf_write
,
1607 #ifdef HAVE_MMC /* MMC is slow, so don't read too large chunks */
1608 amount_to_read
= MIN(0x40000, amount_to_read
);
1610 amount_to_read
= MIN(0x100000, amount_to_read
);
1613 /* Read as much mpeg data as we can fit in the buffer */
1618 len
= read(mpeg_file
, audiobuf
+ audiobuf_write
,
1623 DEBUGF("time: %d\n", t2
- t1
);
1624 DEBUGF("R: %x\n", len
);
1626 /* Now make sure that we don't feed the MAS with ID3V1
1628 if (len
< amount_to_read
)
1631 static const unsigned char tag
[] = "TAG";
1633 int tagptr
= audiobuf_write
+ len
- 128;
1635 /* Really rare case: entire potential tag wasn't
1636 read in this call AND audiobuf_write < 128 */
1638 tagptr
+= audiobuflen
;
1640 for(i
= 0;i
< 3;i
++)
1642 if(tagptr
>= audiobuflen
)
1643 tagptr
-= audiobuflen
;
1645 if(audiobuf
[tagptr
] != tag
[i
])
1656 /* Skip id3v1 tag */
1657 DEBUGF("Skipping ID3v1 tag\n");
1660 /* In the very rare case when the entire tag
1661 wasn't read in this read() len will be < 0.
1662 Take care of this when changing the write
1667 audiobuf_write
+= len
;
1669 if (audiobuf_write
< 0)
1670 audiobuf_write
+= audiobuflen
;
1672 if(audiobuf_write
>= audiobuflen
)
1678 /* Tell ourselves that we want more data */
1679 queue_post(&mpeg_queue
, MPEG_NEED_DATA
, 0);
1685 DEBUGF("MPEG read error\n");
1693 /* No more data to play */
1694 DEBUGF("No more files to play\n");
1699 /* Tell ourselves that we want more data */
1700 queue_post(&mpeg_queue
, MPEG_NEED_DATA
, 0);
1706 case MPEG_TRACK_CHANGE
:
1711 case SYS_USB_CONNECTED
:
1716 /* Tell the USB thread that we are safe */
1717 DEBUGF("mpeg_thread got SYS_USB_CONNECTED\n");
1718 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
1720 /* Wait until the USB cable is extracted again */
1721 usb_wait_for_disconnect(&mpeg_queue
);
1723 #endif /* !USB_NONE */
1725 #if CONFIG_CODEC == MAS3587F
1726 case MPEG_INIT_RECORDING
:
1728 init_recording_done
= true;
1730 #endif /* CONFIG_CODEC == MAS3587F */
1734 playlist_update_resume_info(audio_current_track());
1737 #if CONFIG_CODEC == MAS3587F
1741 queue_wait(&mpeg_queue
, &ev
);
1745 if (is_prerecording
)
1749 /* Go back prerecord_count seconds in the buffer */
1750 startpos
= prerecord_index
- prerecord_count
;
1752 startpos
+= prerecording_max_seconds
;
1754 /* Read the position data from the prerecord buffer */
1755 frame_count_start
= prerecord_buffer
[startpos
].framecount
;
1756 startpos
= prerecord_buffer
[startpos
].mempos
;
1758 DEBUGF("Start looking at address %x (%x)\n",
1759 audiobuf
+startpos
, startpos
);
1761 saved_header
= mpeg_get_last_header();
1763 mem_find_next_frame(startpos
, &offset
, 1800,
1766 audiobuf_read
= startpos
+ offset
;
1767 if(audiobuf_read
>= audiobuflen
)
1768 audiobuf_read
-= audiobuflen
;
1770 DEBUGF("New audiobuf_read address: %x (%x)\n",
1771 audiobuf
+audiobuf_read
, audiobuf_read
);
1773 level
= disable_irq_save();
1774 num_rec_bytes
= get_unsaved_space();
1779 frame_count_start
= 0;
1781 audiobuf_read
= MPEG_RESERVED_HEADER_SPACE
;
1782 audiobuf_write
= MPEG_RESERVED_HEADER_SPACE
;
1786 DEBUGF("Recording...\n");
1789 /* Wait until at least one frame is encoded and get the
1790 frame header, for later use by the Xing header
1793 saved_header
= mpeg_get_last_header();
1795 /* delayed until buffer is saved, don't open yet */
1796 strcpy(delayed_filename
, recording_filename
);
1802 DEBUGF("MPEG_STOP\n");
1806 /* Save the remaining data in the buffer */
1807 save_endpos
= audiobuf_write
;
1808 saving_status
= STOP_RECORDING
;
1809 queue_post(&mpeg_queue
, MPEG_SAVE_DATA
, 0);
1812 case MPEG_STOP_DONE
:
1813 DEBUGF("MPEG_STOP_DONE\n");
1823 for(i
= 0;i
< 512;i
++)
1825 DEBUGF("%d - %d us (%d bytes)\n",
1827 (timing_info
[i
*2+1] & 0xffff) *
1829 timing_info
[i
*2+1] >> 16);
1836 start_prerecording();
1838 mpeg_stop_done
= true;
1842 /* Bail out when a more important save is happening */
1843 if (saving_status
> NEW_FILE
)
1846 /* Make sure we have at least one complete frame
1847 in the buffer. If we haven't recorded a single
1848 frame within 200ms, the MAS is probably not recording
1849 anything, and we bail out. */
1850 amount_to_save
= get_unsaved_space();
1851 if (amount_to_save
< 1800)
1854 amount_to_save
= get_unsaved_space();
1857 mas_readmem(MAS_BANK_D0
, MAS_D0_MPEG_FRAME_COUNT
,
1858 &frame_count_end
, 1);
1860 last_rec_time
= current_tick
- record_start_time
;
1861 record_start_time
= current_tick
;
1863 pause_start_time
= record_start_time
;
1865 /* capture all values at one point */
1866 level
= disable_irq_save();
1867 save_endpos
= audiobuf_write
;
1868 last_rec_bytes
= num_rec_bytes
;
1872 if (amount_to_save
>= 1800)
1874 /* Now find a frame boundary to split at */
1875 save_endpos
-= 1800;
1876 if (save_endpos
< 0)
1877 save_endpos
+= audiobuflen
;
1879 rc
= mem_find_next_frame(save_endpos
, &offset
, 1800,
1881 if (!rc
) /* No header found, save whole buffer */
1884 save_endpos
+= offset
;
1885 if (save_endpos
>= audiobuflen
)
1886 save_endpos
-= audiobuflen
;
1888 last_rec_bytes
+= offset
- 1800;
1889 level
= disable_irq_save();
1890 num_rec_bytes
+= 1800 - offset
;
1894 saving_status
= NEW_FILE
;
1895 queue_post(&mpeg_queue
, MPEG_SAVE_DATA
, 0);
1898 case MPEG_SAVE_DATA
:
1899 if (saving_status
== BUFFER_FULL
)
1900 save_endpos
= audiobuf_write
;
1902 if (mpeg_file
< 0) /* delayed file open */
1904 mpeg_file
= open(delayed_filename
, O_WRONLY
|O_CREAT
);
1907 panicf("recfile: %d", mpeg_file
);
1910 amount_to_save
= save_endpos
- audiobuf_read
;
1911 if (amount_to_save
< 0)
1912 amount_to_save
+= audiobuflen
;
1914 amount_to_save
= MIN(amount_to_save
,
1915 audiobuflen
- audiobuf_read
);
1916 #ifdef HAVE_MMC /* MMC is slow, so don't save too large chunks at once */
1917 amount_to_save
= MIN(0x40000, amount_to_save
);
1919 amount_to_save
= MIN(0x100000, amount_to_save
);
1921 rc
= write(mpeg_file
, audiobuf
+ audiobuf_read
,
1925 if (errno
== ENOSPC
)
1927 mpeg_errno
= AUDIOERR_DISK_FULL
;
1929 queue_post(&mpeg_queue
, MPEG_STOP_DONE
, 0);
1930 /* will close the file */
1934 panicf("rec wrt: %d", rc
);
1937 audiobuf_read
+= amount_to_save
;
1938 if (audiobuf_read
>= audiobuflen
)
1941 if (audiobuf_read
== save_endpos
) /* all saved */
1943 switch (saving_status
)
1946 rc
= fsync(mpeg_file
);
1948 panicf("rec fls: %d", rc
);
1953 /* Close the current file */
1954 rc
= close(mpeg_file
);
1956 panicf("rec cls: %d", rc
);
1961 /* copy new filename */
1962 strcpy(delayed_filename
, recording_filename
);
1964 frame_count_start
= frame_count_end
;
1967 case STOP_RECORDING
:
1968 queue_post(&mpeg_queue
, MPEG_STOP_DONE
, 0);
1969 /* will close the file */
1975 saving_status
= NOT_SAVING
;
1977 else /* tell ourselves to save the next chunk */
1978 queue_post(&mpeg_queue
, MPEG_SAVE_DATA
, 0);
1982 case MPEG_PRERECORDING_TICK
:
1983 if(!is_prerecording
)
1986 /* Store the write pointer every second */
1987 prerecord_buffer
[prerecord_index
].mempos
= audiobuf_write
;
1988 mas_readmem(MAS_BANK_D0
, MAS_D0_MPEG_FRAME_COUNT
,
1989 &prerecord_buffer
[prerecord_index
].framecount
, 1);
1991 /* Wrap if necessary */
1992 if(++prerecord_index
== prerecording_max_seconds
)
1993 prerecord_index
= 0;
1995 /* Update the number of seconds recorded */
1996 if(prerecord_count
< prerecording_max_seconds
)
2000 case MPEG_INIT_PLAYBACK
:
2001 /* Stop the prerecording */
2005 init_playback_done
= true;
2008 case MPEG_PAUSE_RECORDING
:
2012 case MPEG_RESUME_RECORDING
:
2016 case SYS_USB_CONNECTED
:
2017 /* We can safely go to USB mode if no recording
2019 if((!is_recording
|| is_prerecording
) && mpeg_stop_done
)
2021 /* Even if we aren't recording, we still call this
2022 function, to put the MAS in monitoring mode,
2026 /* Tell the USB thread that we are safe */
2027 DEBUGF("mpeg_thread got SYS_USB_CONNECTED\n");
2028 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
2030 /* Wait until the USB cable is extracted again */
2031 usb_wait_for_disconnect(&mpeg_queue
);
2036 #endif /* CONFIG_CODEC == MAS3587F */
2039 #endif /* !SIMULATOR */
2041 struct mp3entry
* audio_current_track()
2045 #else /* !SIMULATOR */
2046 if(num_tracks_in_memory())
2047 return &get_trackdata(0)->id3
;
2050 #endif /* !SIMULATOR */
2053 struct mp3entry
* audio_next_track()
2057 #else /* !SIMULATOR */
2058 if(num_tracks_in_memory() > 1)
2059 return &get_trackdata(1)->id3
;
2062 #endif /* !SIMULATOR */
2065 bool audio_has_changed_track(void)
2067 if(last_track_counter
!= current_track_counter
)
2069 last_track_counter
= current_track_counter
;
2075 #if CONFIG_CODEC == MAS3587F
2077 void audio_init_playback(void)
2079 init_playback_done
= false;
2080 queue_post(&mpeg_queue
, MPEG_INIT_PLAYBACK
, 0);
2082 while(!init_playback_done
)
2087 /****************************************************************************
2088 * Recording functions
2089 ***************************************************************************/
2090 void audio_init_recording(unsigned int buffer_offset
)
2092 buffer_offset
= buffer_offset
;
2093 init_recording_done
= false;
2094 queue_post(&mpeg_queue
, MPEG_INIT_RECORDING
, 0);
2096 while(!init_recording_done
)
2100 static void init_recording(void)
2112 /* Init the recording variables */
2113 is_recording
= false;
2114 is_prerecording
= false;
2116 mpeg_stop_done
= true;
2120 /* Enable the audio CODEC and the DSP core, max analog voltage range */
2121 rc
= mas_direct_config_write(MAS_CONTROL
, 0x8c00);
2123 panicf("mas_ctrl_w: %d", rc
);
2125 /* Stop the current application */
2127 mas_writemem(MAS_BANK_D0
, MAS_D0_APP_SELECT
, &val
, 1);
2130 mas_readmem(MAS_BANK_D0
, MAS_D0_APP_RUNNING
, &val
, 1);
2133 /* Perform black magic as described by the data sheet */
2134 if((mas_version_code
& 0x0fff) == 0x0102)
2136 DEBUGF("Performing MAS black magic for B2 version\n");
2137 mas_writereg(0xa3, 0x98);
2138 mas_writereg(0x94, 0xfffff);
2140 mas_writemem(MAS_BANK_D1
, 0, &val
, 1);
2141 mas_writereg(0xa3, 0x90);
2144 /* Enable A/D Converters */
2145 shadow_codec_reg0
= 0xcccd;
2146 mas_codec_writereg(0x0, shadow_codec_reg0
);
2148 /* Copy left channel to right (mono mode) */
2149 mas_codec_writereg(8, 0x8000);
2151 /* ADC scale 0%, DSP scale 100%
2152 We use the DSP output for monitoring, because it works with all
2153 sources including S/PDIF */
2154 mas_codec_writereg(6, 0x0000);
2155 mas_codec_writereg(7, 0x4000);
2158 shadow_soft_mute
= 0;
2159 mas_writemem(MAS_BANK_D0
, MAS_D0_SOFT_MUTE
, &shadow_soft_mute
, 1);
2161 #ifdef HAVE_SPDIF_OUT
2162 val
= 0x09; /* Disable SDO and SDI, low impedance S/PDIF outputs */
2164 val
= 0x2d; /* Disable SDO and SDI, disable S/PDIF output */
2166 mas_writemem(MAS_BANK_D0
, MAS_D0_INTERFACE_CONTROL
, &val
, 1);
2168 /* Set Demand mode, monitoring OFF and validate all settings */
2169 shadow_io_control_main
= 0x125;
2170 mas_writemem(MAS_BANK_D0
, MAS_D0_IO_CONTROL_MAIN
, &shadow_io_control_main
, 1);
2172 /* Start the encoder application */
2174 mas_writemem(MAS_BANK_D0
, MAS_D0_APP_SELECT
, &val
, 1);
2177 mas_readmem(MAS_BANK_D0
, MAS_D0_APP_RUNNING
, &val
, 1);
2178 } while(!(val
& 0x40));
2180 /* We have started the recording application with monitoring OFF.
2181 This is because we want to record at least one frame to fill the DMA
2182 buffer, because the silly MAS will not negate EOD until at least one
2183 DMA transfer has taken place.
2184 Now let's wait for some data to be encoded. */
2187 /* Now set it to Monitoring mode as default, saves power */
2188 shadow_io_control_main
= 0x525;
2189 mas_writemem(MAS_BANK_D0
, MAS_D0_IO_CONTROL_MAIN
, &shadow_io_control_main
, 1);
2191 /* Wait until the DSP has accepted the settings */
2194 mas_readmem(MAS_BANK_D0
, MAS_D0_IO_CONTROL_MAIN
, &val
,1);
2198 mpeg_mode
= MPEG_ENCODER
;
2200 DEBUGF("MAS Recording application started\n");
2202 /* At this point, all settings are the reset MAS defaults, next thing is to
2203 call mpeg_set_recording_options(). */
2206 void audio_record(const char *filename
)
2210 strncpy(recording_filename
, filename
, MAX_PATH
- 1);
2211 recording_filename
[MAX_PATH
- 1] = 0;
2213 queue_post(&mpeg_queue
, MPEG_RECORD
, 0);
2216 void audio_pause_recording(void)
2218 queue_post(&mpeg_queue
, MPEG_PAUSE_RECORDING
, 0);
2221 void audio_resume_recording(void)
2223 queue_post(&mpeg_queue
, MPEG_RESUME_RECORDING
, 0);
2226 static void prepend_header(void)
2231 /* Make room for header */
2232 audiobuf_read
-= MPEG_RESERVED_HEADER_SPACE
;
2233 if(audiobuf_read
< 0)
2235 /* Clear the bottom half */
2236 memset(audiobuf
, 0, audiobuf_read
+ MPEG_RESERVED_HEADER_SPACE
);
2238 /* And the top half */
2239 audiobuf_read
+= audiobuflen
;
2240 memset(audiobuf
+ audiobuf_read
, 0, audiobuflen
- audiobuf_read
);
2244 memset(audiobuf
+ audiobuf_read
, 0, MPEG_RESERVED_HEADER_SPACE
);
2246 /* Copy the empty ID3 header */
2247 startpos
= audiobuf_read
;
2248 for(i
= 0; i
< sizeof(empty_id3_header
); i
++)
2250 audiobuf
[startpos
++] = empty_id3_header
[i
];
2251 if(startpos
== audiobuflen
)
2256 static void update_header(void)
2259 unsigned long frames
;
2261 if (last_rec_bytes
> 0)
2263 /* Create the Xing header */
2264 fd
= open(delayed_filename
, O_RDWR
);
2266 panicf("rec upd: %d (%s)", fd
, recording_filename
);
2268 frames
= frame_count_end
- frame_count_start
;
2269 /* If the number of recorded frames has reached 0x7ffff,
2270 we can no longer trust it */
2271 if (frame_count_end
== 0x7ffff)
2274 /* saved_header is saved right before stopping the MAS */
2275 framelen
= create_xing_header(fd
, 0, last_rec_bytes
, xing_buffer
,
2276 frames
, last_rec_time
* (1000/HZ
),
2277 saved_header
, NULL
, false);
2279 lseek(fd
, MPEG_RESERVED_HEADER_SPACE
- framelen
, SEEK_SET
);
2280 write(fd
, xing_buffer
, framelen
);
2285 static void start_prerecording(void)
2289 DEBUGF("Starting prerecording\n");
2291 prerecord_index
= 0;
2292 prerecord_count
= 0;
2293 prerecord_timeout
= current_tick
+ HZ
;
2294 memset(prerecord_buffer
, 0, sizeof(prerecord_buffer
));
2297 is_prerecording
= true;
2299 /* Stop monitoring and start the encoder */
2300 shadow_io_control_main
&= ~(1 << 10);
2301 mas_writemem(MAS_BANK_D0
, MAS_D0_IO_CONTROL_MAIN
, &shadow_io_control_main
, 1);
2302 DEBUGF("mas_writemem(MAS_BANK_D0, IO_CONTROL_MAIN, %x)\n", shadow_io_control_main
);
2304 /* Wait until the DSP has accepted the settings */
2307 mas_readmem(MAS_BANK_D0
, MAS_D0_IO_CONTROL_MAIN
, &val
,1);
2310 is_recording
= true;
2311 saving_status
= NOT_SAVING
;
2313 demand_irq_enable(true);
2316 static void start_recording(void)
2322 /* This will make the IRQ handler start recording
2323 for real, i.e send MPEG_SAVE_DATA messages when
2324 the buffer is full */
2325 is_prerecording
= false;
2329 /* If prerecording is off, we need to stop the monitoring
2330 and start the encoder */
2331 shadow_io_control_main
&= ~(1 << 10);
2332 mas_writemem(MAS_BANK_D0
, MAS_D0_IO_CONTROL_MAIN
, &shadow_io_control_main
, 1);
2333 DEBUGF("mas_writemem(MAS_BANK_D0, IO_CONTROL_MAIN, %x)\n", shadow_io_control_main
);
2335 /* Wait until the DSP has accepted the settings */
2338 mas_readmem(MAS_BANK_D0
, MAS_D0_IO_CONTROL_MAIN
, &val
,1);
2342 is_recording
= true;
2343 saving_status
= NOT_SAVING
;
2346 /* Store the current time */
2348 record_start_time
= current_tick
- prerecord_count
* HZ
;
2350 record_start_time
= current_tick
;
2352 pause_start_time
= 0;
2354 demand_irq_enable(true);
2357 static void pause_recording(void)
2359 pause_start_time
= current_tick
;
2361 /* Set the pause bit */
2362 shadow_soft_mute
|= 2;
2363 mas_writemem(MAS_BANK_D0
, MAS_D0_SOFT_MUTE
, &shadow_soft_mute
, 1);
2368 static void resume_recording(void)
2372 /* Clear the pause bit */
2373 shadow_soft_mute
&= ~2;
2374 mas_writemem(MAS_BANK_D0
, MAS_D0_SOFT_MUTE
, &shadow_soft_mute
, 1);
2376 /* Compensate for the time we have been paused */
2377 if(pause_start_time
)
2380 current_tick
- (pause_start_time
- record_start_time
);
2381 pause_start_time
= 0;
2385 static void stop_recording(void)
2389 /* Let it finish the last frame */
2394 demand_irq_enable(false);
2396 is_recording
= false;
2397 is_prerecording
= false;
2399 last_rec_bytes
= num_rec_bytes
;
2400 mas_readmem(MAS_BANK_D0
, MAS_D0_MPEG_FRAME_COUNT
, &frame_count_end
, 1);
2401 last_rec_time
= current_tick
- record_start_time
;
2403 /* Start monitoring */
2404 shadow_io_control_main
|= (1 << 10);
2405 mas_writemem(MAS_BANK_D0
, MAS_D0_IO_CONTROL_MAIN
, &shadow_io_control_main
, 1);
2406 DEBUGF("mas_writemem(MAS_BANK_D0, IO_CONTROL_MAIN, %x)\n", shadow_io_control_main
);
2408 /* Wait until the DSP has accepted the settings */
2411 mas_readmem(MAS_BANK_D0
, MAS_D0_IO_CONTROL_MAIN
, &val
,1);
2417 void audio_set_recording_options(struct audio_recording_options
*options
)
2421 is_mpeg1
= (options
->rec_frequency
< 3)?true:false;
2423 rec_version_index
= is_mpeg1
?3:2;
2424 rec_frequency_index
= options
->rec_frequency
% 3;
2426 shadow_encoder_control
= (options
->rec_quality
<< 17) |
2427 (rec_frequency_index
<< 10) |
2428 ((is_mpeg1
?1:0) << 9) |
2429 (((options
->rec_channels
* 2 + 1) & 3) << 6) |
2430 (1 << 5) /* MS-stereo */ |
2431 (1 << 2) /* Is an original */;
2432 mas_writemem(MAS_BANK_D0
, MAS_D0_ENCODER_CONTROL
, &shadow_encoder_control
,1);
2434 DEBUGF("mas_writemem(MAS_BANK_D0, ENCODER_CONTROL, %x)\n", shadow_encoder_control
);
2436 shadow_soft_mute
= options
->rec_editable
?4:0;
2437 mas_writemem(MAS_BANK_D0
, MAS_D0_SOFT_MUTE
, &shadow_soft_mute
,1);
2439 DEBUGF("mas_writemem(MAS_BANK_D0, SOFT_MUTE, %x)\n", shadow_soft_mute
);
2441 shadow_io_control_main
= ((1 << 10) | /* Monitoring ON */
2442 ((options
->rec_source
< 2)?1:2) << 8) | /* Input select */
2443 (1 << 5) | /* SDO strobe invert */
2444 ((is_mpeg1
?0:1) << 3) |
2445 (1 << 2) | /* Inverted SIBC clock signal */
2447 mas_writemem(MAS_BANK_D0
, MAS_D0_IO_CONTROL_MAIN
, &shadow_io_control_main
,1);
2449 DEBUGF("mas_writemem(MAS_BANK_D0, IO_CONTROL_MAIN, %x)\n", shadow_io_control_main
);
2451 if(options
->rec_source
== AUDIO_SRC_MIC
)
2453 /* Copy left channel to right (mono mode) */
2454 mas_codec_writereg(8, 0x8000);
2458 /* Stereo input mode */
2459 mas_codec_writereg(8, 0);
2462 prerecording_max_seconds
= options
->rec_prerecord_time
;
2463 if(prerecording_max_seconds
)
2465 prerecording
= true;
2466 start_prerecording();
2470 prerecording
= false;
2471 is_prerecording
= false;
2472 is_recording
= false;
2476 /* If use_mic is true, the left gain is used */
2477 void audio_set_recording_gain(int left
, int right
, int type
)
2479 /* Enable both left and right A/D */
2480 shadow_codec_reg0
= (left
<< 12) |
2483 (type
==AUDIO_GAIN_MIC
?0x0008:0) | /* Connect left A/D to mic */
2485 mas_codec_writereg(0x0, shadow_codec_reg0
);
2488 #if CONFIG_TUNER & S1A0903X01
2489 /* Get the (unpitched) MAS PLL frequency, for avoiding FM interference with the
2490 * Samsung tuner. Zero means unknown. Currently handles recording from analog
2492 int mpeg_get_mas_pllfreq(void)
2494 if (mpeg_mode
!= MPEG_ENCODER
)
2497 if (rec_frequency_index
== 0) /* 44.1 kHz / 22.05 kHz */
2502 #endif /* CONFIG_TUNER & S1A0903X01 */
2504 /* try to make some kind of beep, also in recording mode */
2505 void audio_beep(int duration
)
2507 long starttick
= current_tick
;
2509 { /* toggle bit 0 of codec register 0, toggling the DAC off & on.
2510 * While this is still audible even without an external signal,
2511 * it doesn't affect the (pre-)recording. */
2512 mas_codec_writereg(0, shadow_codec_reg0
^ 1);
2513 mas_codec_writereg(0, shadow_codec_reg0
);
2516 while (current_tick
- starttick
< duration
);
2519 void audio_new_file(const char *filename
)
2523 strncpy(recording_filename
, filename
, MAX_PATH
- 1);
2524 recording_filename
[MAX_PATH
- 1] = 0;
2526 queue_post(&mpeg_queue
, MPEG_NEW_FILE
, 0);
2529 unsigned long audio_recorded_time(void)
2532 return prerecord_count
* HZ
;
2537 return pause_start_time
- record_start_time
;
2539 return current_tick
- record_start_time
;
2545 unsigned long audio_num_recorded_bytes(void)
2554 index
= prerecord_index
- prerecord_count
;
2556 index
+= prerecording_max_seconds
;
2558 num_bytes
= audiobuf_write
- prerecord_buffer
[index
].mempos
;
2560 num_bytes
+= audiobuflen
;
2565 return num_rec_bytes
;
2571 #else /* SIMULATOR */
2573 /* dummies coming up */
2575 void audio_init_playback(void)
2579 unsigned long audio_recorded_time(void)
2584 void audio_beep(int duration
)
2589 void audio_pause_recording(void)
2593 void audio_resume_recording(void)
2597 unsigned long audio_num_recorded_bytes(void)
2602 void audio_record(const char *filename
)
2607 void audio_new_file(const char *filename
)
2613 void audio_set_recording_gain(int left
, int right
, int type
)
2620 void audio_init_recording(unsigned int buffer_offset
)
2623 (void)buffer_offset
;
2625 void audio_set_recording_options(struct audio_recording_options
*options
)
2630 #endif /* SIMULATOR */
2631 #endif /* CONFIG_CODEC == MAS3587F */
2633 void audio_play(long offset
)
2642 trackname
= playlist_peek( steps
);
2645 if(mp3info(&taginfo
, trackname
)) {
2646 /* bad mp3, move on */
2647 if(++steps
> playlist_amount())
2651 #ifdef HAVE_MPEG_PLAY
2652 real_mpeg_play(trackname
);
2654 playlist_next(steps
);
2655 taginfo
.offset
= offset
;
2656 set_elapsed(&taginfo
);
2661 #else /* !SIMULATOR */
2664 queue_post(&mpeg_queue
, MPEG_PLAY
, offset
);
2665 #endif /* !SIMULATOR */
2670 void audio_stop(void)
2675 struct trackdata
*track
= get_trackdata(0);
2676 prev_track_elapsed
= track
->id3
.elapsed
;
2678 mpeg_stop_done
= false;
2679 queue_post(&mpeg_queue
, MPEG_STOP
, 0);
2680 while(!mpeg_stop_done
)
2682 #else /* SIMULATOR */
2686 #endif /* SIMULATOR */
2690 void audio_stop_recording(void)
2695 void audio_pause(void)
2698 queue_post(&mpeg_queue
, MPEG_PAUSE
, 0);
2699 #else /* SIMULATOR */
2703 #endif /* SIMULATOR */
2706 void audio_resume(void)
2709 queue_post(&mpeg_queue
, MPEG_RESUME
, 0);
2710 #else /* SIMULATOR */
2714 #endif /* SIMULATOR */
2717 void audio_next(void)
2720 queue_remove_from_head(&mpeg_queue
, MPEG_NEED_DATA
);
2721 queue_post(&mpeg_queue
, MPEG_NEXT
, 0);
2722 #else /* SIMULATOR */
2728 file
= playlist_peek(steps
);
2731 if(mp3info(&taginfo
, file
)) {
2732 if(++steps
> playlist_amount())
2736 index
= playlist_next(steps
);
2737 taginfo
.index
= index
;
2738 current_track_counter
++;
2743 #endif /* SIMULATOR */
2746 void audio_prev(void)
2749 queue_remove_from_head(&mpeg_queue
, MPEG_NEED_DATA
);
2750 queue_post(&mpeg_queue
, MPEG_PREV
, 0);
2751 #else /* SIMULATOR */
2757 file
= playlist_peek(steps
);
2760 if(mp3info(&taginfo
, file
)) {
2764 index
= playlist_next(steps
);
2765 taginfo
.index
= index
;
2766 current_track_counter
++;
2771 #endif /* SIMULATOR */
2774 void audio_ff_rewind(long newtime
)
2777 queue_post(&mpeg_queue
, MPEG_FF_REWIND
, newtime
);
2778 #else /* SIMULATOR */
2780 #endif /* SIMULATOR */
2783 void audio_flush_and_reload_tracks(void)
2786 queue_post(&mpeg_queue
, MPEG_FLUSH_RELOAD
, 0);
2787 #endif /* !SIMULATOR*/
2790 int audio_status(void)
2795 ret
|= AUDIO_STATUS_PLAY
;
2798 ret
|= AUDIO_STATUS_PAUSE
;
2800 #if (CONFIG_CODEC == MAS3587F) && !defined(SIMULATOR)
2801 if(is_recording
&& !is_prerecording
)
2802 ret
|= AUDIO_STATUS_RECORD
;
2805 ret
|= AUDIO_STATUS_PRERECORD
;
2806 #endif /* CONFIG_CODEC == MAS3587F */
2809 ret
|= AUDIO_STATUS_ERROR
;
2814 unsigned int audio_error(void)
2819 void audio_error_clear(void)
2825 static void mpeg_thread(void)
2827 struct mp3entry
* id3
;
2830 id3
= audio_current_track();
2836 if (id3
->elapsed
>=id3
->length
)
2842 #endif /* SIMULATOR */
2844 void audio_init(void)
2849 audiobuflen
= audiobufend
- audiobuf
;
2850 queue_init(&mpeg_queue
, true);
2851 #endif /* !SIMULATOR */
2852 create_thread(mpeg_thread
, mpeg_stack
,
2853 sizeof(mpeg_stack
), 0, mpeg_thread_name
2854 IF_PRIO(, PRIORITY_SYSTEM
)
2857 memset(trackdata
, sizeof(trackdata
), 0);
2859 #if (CONFIG_CODEC == MAS3587F) && !defined(SIMULATOR)
2860 if (HW_MASK
& PR_ACTIVE_HIGH
)
2861 and_b(~0x08, &PADRH
);
2864 #endif /* CONFIG_CODEC == MAS3587F */
2872 #endif /* CONFIG_CODEC != SWCODEC */