?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tree browser: return native path delimiters in returned path
[Rockbox.git] / firmware / mpeg.c
blob278eea475829cf7d50ce9f00f2594796abd8a81b
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2002 by Linus Nielsen Feltzing
11 *
12 * All files in this archive are subject to the GNU General Public License.
13 * See the file COPYING in the source tree root for full license agreement.
14 *
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
17 *
18 ****************************************************************************/
19 #include <stdbool.h>
20 #include <stdlib.h>
21 #include "config.h"
22
23 #if CONFIG_CODEC != SWCODEC
24
25 #include "debug.h"
26 #include "panic.h"
27 #include "id3.h"
28 #include "mpeg.h"
29 #include "audio.h"
30 #include "ata.h"
31 #include "string.h"
32 #include <kernel.h>
33 #include "thread.h"
34 #include "errno.h"
35 #include "mp3data.h"
36 #include "buffer.h"
37 #include "mp3_playback.h"
38 #include "sound.h"
39 #include "bitswap.h"
40 #ifndef SIMULATOR
41 #include "i2c.h"
42 #include "mas.h"
43 #include "dac.h"
44 #include "system.h"
45 #include "usb.h"
46 #include "file.h"
47 #include "hwcompat.h"
48 #endif /* !SIMULATOR */
49 #ifdef HAVE_LCD_BITMAP
50 #include "lcd.h"
51 #endif
52
53 #ifndef SIMULATOR
54 extern unsigned long mas_version_code;
55 #endif
56
57 #if CONFIG_CODEC == MAS3587F
58 extern enum /* from mp3_playback.c */
59 {
60 MPEG_DECODER,
61 MPEG_ENCODER
62 } mpeg_mode;
63 #endif /* CONFIG_CODEC == MAS3587F */
64
65 extern char* playlist_peek(int steps);
66 extern bool playlist_check(int steps);
67 extern int playlist_next(int steps);
68 extern int playlist_amount(void);
69 extern int playlist_update_resume_info(const struct mp3entry* id3);
70
71 #define MPEG_PLAY 1
72 #define MPEG_STOP 2
73 #define MPEG_PAUSE 3
74 #define MPEG_RESUME 4
75 #define MPEG_NEXT 5
76 #define MPEG_PREV 6
77 #define MPEG_FF_REWIND 7
78 #define MPEG_FLUSH_RELOAD 8
79 #define MPEG_RECORD 9
80 #define MPEG_INIT_RECORDING 10
81 #define MPEG_INIT_PLAYBACK 11
82 #define MPEG_NEW_FILE 12
83 #define MPEG_PAUSE_RECORDING 13
84 #define MPEG_RESUME_RECORDING 14
85 #define MPEG_NEED_DATA 100
86 #define MPEG_TRACK_CHANGE 101
87 #define MPEG_SAVE_DATA 102
88 #define MPEG_STOP_DONE 103
89 #define MPEG_PRERECORDING_TICK 104
90
91 /* indicator for MPEG_NEED_DATA */
92 #define GENERATE_UNBUFFER_EVENTS 1
93
94 /* list of tracks in memory */
95 #define MAX_TRACK_ENTRIES (1<<4) /* Must be power of 2 */
96 #define MAX_TRACK_ENTRIES_MASK (MAX_TRACK_ENTRIES - 1)
97
98 struct trackdata
99 {
100 struct mp3entry id3;
101 int mempos;
102 int load_ahead_index;
103 bool event_sent;
104 };
105
106 static struct trackdata trackdata[MAX_TRACK_ENTRIES];
107
108 static unsigned int current_track_counter = 0;
109 static unsigned int last_track_counter = 0;
110
111 /* Play time of the previous track */
112 unsigned long prev_track_elapsed;
113
114 #ifndef SIMULATOR
115 static int track_read_idx = 0;
116 static int track_write_idx = 0;
117 #endif /* !SIMULATOR */
118
119 /* Callback function to call when current track has really changed. */
120 void (*track_changed_callback)(struct mp3entry *id3);
121 void (*track_buffer_callback)(struct mp3entry *id3, bool last_track);
122 void (*track_unbuffer_callback)(struct mp3entry *id3, bool last_track);
123
124 /* Cuesheet callback */
125 static bool (*cuesheet_callback)(const char *filename) = NULL;
126
127 static const char mpeg_thread_name[] = "mpeg";
128 static unsigned int mpeg_errno;
129
130 static bool v1first = false;
131
132 static bool playing = false; /* We are playing an MP3 stream */
133 static bool is_playing = false; /* We are (attempting to) playing MP3 files */
134 static bool paused; /* playback is paused */
135
136 #ifdef SIMULATOR
137 static char mpeg_stack[DEFAULT_STACK_SIZE];
138 static struct mp3entry taginfo;
139
140 #else /* !SIMULATOR */
141 static struct event_queue mpeg_queue;
142 static long mpeg_stack[(DEFAULT_STACK_SIZE + 0x1000)/sizeof(long)];
143
144 static int audiobuflen;
145 static int audiobuf_write;
146 static int audiobuf_swapwrite;
147 static int audiobuf_read;
148
149 static int mpeg_file;
150
151 static bool play_pending; /* We are about to start playing */
152 static bool filling; /* We are filling the buffer with data from disk */
153 static bool dma_underrun; /* True when the DMA has stopped because of
154 slow disk reading (read error, shaking) */
155 static bool mpeg_stop_done;
156
157 static int last_dma_tick = 0;
158 static int last_dma_chunk_size;
159
160 static long low_watermark; /* Dynamic low watermark level */
161 static long low_watermark_margin = 0; /* Extra time in seconds for watermark */
162 static long lowest_watermark_level; /* Debug value to observe the buffer
163 usage */
164 #if CONFIG_CODEC == MAS3587F
165 static char recording_filename[MAX_PATH]; /* argument to thread */
166 static char delayed_filename[MAX_PATH]; /* internal copy of above */
167
168 static char xing_buffer[MAX_XING_HEADER_SIZE];
169
170 static bool init_recording_done;
171 static bool init_playback_done;
172 static bool prerecording; /* True if prerecording is enabled */
173 static bool is_prerecording; /* True if we are prerecording */
174 static bool is_recording; /* We are recording */
175
176 static enum {
177 NOT_SAVING = 0, /* reasons to save data, sorted by importance */
178 BUFFER_FULL,
179 NEW_FILE,
180 STOP_RECORDING
181 } saving_status;
182
183 static int rec_frequency_index; /* For create_xing_header() calls */
184 static int rec_version_index; /* For create_xing_header() calls */
185
186 struct prerecord_info {
187 int mempos;
188 unsigned long framecount;
189 };
190
191 static struct prerecord_info prerecord_buffer[MPEG_MAX_PRERECORD_SECONDS];
192 static int prerecord_index; /* Current index in the prerecord buffer */
193 static int prerecording_max_seconds; /* Max number of seconds to store */
194 static int prerecord_count; /* Number of seconds in the prerecord buffer */
195 static int prerecord_timeout; /* The tick count of the next prerecord data
196 store */
197
198 unsigned long record_start_time; /* Value of current_tick when recording
199 was started */
200 unsigned long pause_start_time; /* Value of current_tick when pause was
201 started */
202 static unsigned long last_rec_time;
203 static unsigned long num_rec_bytes;
204 static unsigned long last_rec_bytes;
205 static unsigned long frame_count_start;
206 static unsigned long frame_count_end;
207 static unsigned long saved_header = 0;
208
209 /* Shadow MAS registers */
210 unsigned long shadow_encoder_control = 0;
211 #endif /* CONFIG_CODEC == MAS3587F */
212
213 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
214 unsigned long shadow_io_control_main = 0;
215 unsigned long shadow_soft_mute = 0;
216 unsigned shadow_codec_reg0;
217 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */
218
219 #ifdef HAVE_RECORDING
220 const unsigned char empty_id3_header[] =
221 {
222 'I', 'D', '3', 0x03, 0x00, 0x00,
223 0x00, 0x00, 0x1f, 0x76 /* Size is 4096 minus 10 bytes for the header */
224 };
225 #endif /* HAVE_RECORDING */
226
227
228 static int get_unplayed_space(void);
229 static int get_playable_space(void);
230 static int get_unswapped_space(void);
231 #endif /* !SIMULATOR */
232
233 #if (CONFIG_CODEC == MAS3587F) && !defined(SIMULATOR)
234 static void init_recording(void);
235 static void prepend_header(void);
236 static void update_header(void);
237 static void start_prerecording(void);
238 static void start_recording(void);
239 static void stop_recording(void);
240 static int get_unsaved_space(void);
241 static void pause_recording(void);
242 static void resume_recording(void);
243 #endif /* (CONFIG_CODEC == MAS3587F) && !defined(SIMULATOR) */
244
245
246 #ifndef SIMULATOR
247 static int num_tracks_in_memory(void)
248 {
249 return (track_write_idx - track_read_idx) & MAX_TRACK_ENTRIES_MASK;
250 }
251
252 #ifdef DEBUG_TAGS
253 static void debug_tags(void)
254 {
255 int i;
256
257 for(i = 0;i < MAX_TRACK_ENTRIES;i++)
258 {
259 DEBUGF("%d - %s\n", i, trackdata[i].id3.path);
260 }
261 DEBUGF("read: %d, write :%d\n", track_read_idx, track_write_idx);
262 DEBUGF("num_tracks_in_memory: %d\n", num_tracks_in_memory());
263 }
264 #else /* !DEBUG_TAGS */
265 #define debug_tags()
266 #endif /* !DEBUG_TAGS */
267
268 static void remove_current_tag(void)
269 {
270 if(num_tracks_in_memory() > 0)
271 {
272 /* First move the index, so nobody tries to access the tag */
273 track_read_idx = (track_read_idx+1) & MAX_TRACK_ENTRIES_MASK;
274 debug_tags();
275 }
276 else
277 {
278 DEBUGF("remove_current_tag: no tracks to remove\n");
279 }
280 }
281
282 static void remove_all_non_current_tags(void)
283 {
284 track_write_idx = (track_read_idx+1) & MAX_TRACK_ENTRIES_MASK;
285 debug_tags();
286 }
287
288 static void remove_all_tags(void)
289 {
290 track_write_idx = track_read_idx;
291
292 debug_tags();
293 }
294
295 static struct trackdata *get_trackdata(int offset)
296 {
297 if(offset >= num_tracks_in_memory())
298 return NULL;
299 else
300 return &trackdata[(track_read_idx + offset) & MAX_TRACK_ENTRIES_MASK];
301 }
302 #endif /* !SIMULATOR */
303
304 /***********************************************************************/
305 /* audio event handling */
306
307 #define MAX_EVENT_HANDLERS 10
308 struct event_handlers_table
309 {
310 AUDIO_EVENT_HANDLER handler;
311 unsigned short mask;
312 };
313 static struct event_handlers_table event_handlers[MAX_EVENT_HANDLERS];
314 static int event_handlers_count = 0;
315
316 void audio_register_event_handler(AUDIO_EVENT_HANDLER handler, unsigned short mask)
317 {
318 if (event_handlers_count < MAX_EVENT_HANDLERS)
319 {
320 event_handlers[event_handlers_count].handler = handler;
321 event_handlers[event_handlers_count].mask = mask;
322 event_handlers_count++;
323 }
324 }
325
326 /* dispatch calls each handler in the order registered and returns after some
327 handler actually handles the event (the event is assumed to no longer be valid
328 after this, due to the handler changing some condition); returns true if someone
329 handled the event, which is expected to cause the caller to skip its own handling
330 of the event */
331 #ifndef SIMULATOR
332 static bool audio_dispatch_event(unsigned short event, unsigned long data)
333 {
334 int i = 0;
335 for(i=0; i < event_handlers_count; i++)
336 {
337 if ( event_handlers[i].mask & event )
338 {
339 int rc = event_handlers[i].handler(event, data);
340 if ( rc == AUDIO_EVENT_RC_HANDLED )
341 return true;
342 }
343 }
344 return false;
345 }
346 #endif
347
348 /***********************************************************************/
349
350 static void set_elapsed(struct mp3entry* id3)
351 {
352 if ( id3->vbr ) {
353 if ( id3->has_toc ) {
354 /* calculate elapsed time using TOC */
355 int i;
356 unsigned int remainder, plen, relpos, nextpos;
357
358 /* find wich percent we're at */
359 for (i=0; i<100; i++ )
360 {
361 if ( id3->offset < id3->toc[i] * (id3->filesize / 256) )
362 {
363 break;
364 }
365 }
366
367 i--;
368 if (i < 0)
369 i = 0;
370
371 relpos = id3->toc[i];
372
373 if (i < 99)
374 {
375 nextpos = id3->toc[i+1];
376 }
377 else
378 {
379 nextpos = 256;
380 }
381
382 remainder = id3->offset - (relpos * (id3->filesize / 256));
383
384 /* set time for this percent (divide before multiply to prevent
385 overflow on long files. loss of precision is negligible on
386 short files) */
387 id3->elapsed = i * (id3->length / 100);
388
389 /* calculate remainder time */
390 plen = (nextpos - relpos) * (id3->filesize / 256);
391 id3->elapsed += (((remainder * 100) / plen) *
392 (id3->length / 10000));
393 }
394 else {
395 /* no TOC exists. set a rough estimate using average bitrate */
396 int tpk = id3->length / (id3->filesize / 1024);
397 id3->elapsed = id3->offset / 1024 * tpk;
398 }
399 }
400 else
401 /* constant bitrate, use exact calculation */
402 id3->elapsed = id3->offset / (id3->bitrate / 8);
403 }
404
405 int audio_get_file_pos(void)
406 {
407 int pos = -1;
408 struct mp3entry *id3 = audio_current_track();
409
410 if (id3->vbr)
411 {
412 if (id3->has_toc)
413 {
414 /* Use the TOC to find the new position */
415 unsigned int percent, remainder;
416 int curtoc, nexttoc, plen;
417
418 percent = (id3->elapsed*100)/id3->length;
419 if (percent > 99)
420 percent = 99;
421
422 curtoc = id3->toc[percent];
423
424 if (percent < 99)
425 nexttoc = id3->toc[percent+1];
426 else
427 nexttoc = 256;
428
429 pos = (id3->filesize/256)*curtoc;
430
431 /* Use the remainder to get a more accurate position */
432 remainder = (id3->elapsed*100)%id3->length;
433 remainder = (remainder*100)/id3->length;
434 plen = (nexttoc - curtoc)*(id3->filesize/256);
435 pos += (plen/100)*remainder;
436 }
437 else
438 {
439 /* No TOC exists, estimate the new position */
440 pos = (id3->filesize / (id3->length / 1000)) *
441 (id3->elapsed / 1000);
442 }
443 }
444 else if (id3->bitrate)
445 pos = id3->elapsed * (id3->bitrate / 8);
446 else
447 {
448 return -1;
449 }
450
451 if (pos >= (int)(id3->filesize - id3->id3v1len))
452 {
453 /* Don't seek right to the end of the file so that we can
454 transition properly to the next song */
455 pos = id3->filesize - id3->id3v1len - 1;
456 }
457 else if (pos < (int)id3->first_frame_offset)
458 {
459 /* skip past id3v2 tag and other leading garbage */
460 pos = id3->first_frame_offset;
461 }
462 return pos;
463 }
464
465 unsigned long mpeg_get_last_header(void)
466 {
467 #ifdef SIMULATOR
468 return 0;
469 #else /* !SIMULATOR */
470 unsigned long tmp[2];
471
472 /* Read the frame data from the MAS and reconstruct it with the
473 frame sync and all */
474 mas_readmem(MAS_BANK_D0, MAS_D0_MPEG_STATUS_1, tmp, 2);
475 return 0xffe00000 | ((tmp[0] & 0x7c00) << 6) | (tmp[1] & 0xffff);
476 #endif /* !SIMULATOR */
477 }
478
479 void audio_set_track_buffer_event(void (*handler)(struct mp3entry *id3,
480 bool last_track))
481 {
482 track_buffer_callback = handler;
483 }
484
485 void audio_set_track_unbuffer_event(void (*handler)(struct mp3entry *id3,
486 bool last_track))
487 {
488 track_unbuffer_callback = handler;
489 }
490
491 void audio_set_track_changed_event(void (*handler)(struct mp3entry *id3))
492 {
493 track_changed_callback = handler;
494 }
495
496 void audio_set_cuesheet_callback(bool (*handler)(const char *filename))
497 {
498 cuesheet_callback = handler;
499 }
500
501 #ifndef SIMULATOR
502 /* Send callback events to notify about removing old tracks. */
503 static void generate_unbuffer_events(void)
504 {
505 int i;
506 int event_count = 0;
507 int numentries = MAX_TRACK_ENTRIES - num_tracks_in_memory();
508 int cur_idx = track_write_idx;
509
510 for (i = 0; i < numentries; i++)
511 {
512 if (trackdata[cur_idx].event_sent)
513 event_count++;
514
515 cur_idx = (cur_idx + 1) & MAX_TRACK_ENTRIES_MASK;
516 }
517
518 cur_idx = track_write_idx;
519
520 for (i = 0; i < numentries; i++)
521 {
522 /* Send an event to notify that track has finished. */
523 if (trackdata[cur_idx].event_sent)
524 {
525 event_count--;
526 if (track_unbuffer_callback)
527 track_unbuffer_callback(&trackdata[cur_idx].id3,
528 event_count == 0);
529 trackdata[cur_idx].event_sent = false;
530 }
531 cur_idx = (cur_idx + 1) & MAX_TRACK_ENTRIES_MASK;
532 }
533 }
534
535 /* Send callback events to notify about new tracks. */
536 static void generate_postbuffer_events(void)
537 {
538 int i;
539 int event_count = 0;
540 int numentries = num_tracks_in_memory();
541 int cur_idx = track_read_idx;
542
543 for (i = 0; i < numentries; i++)
544 {
545 if (!trackdata[cur_idx].event_sent)
546 event_count++;
547
548 cur_idx = (cur_idx + 1) & MAX_TRACK_ENTRIES_MASK;
549 }
550
551 cur_idx = track_read_idx;
552
553 for (i = 0; i < numentries; i++)
554 {
555 if (!trackdata[cur_idx].event_sent)
556 {
557 event_count--;
558 if (track_buffer_callback)
559 track_buffer_callback(&trackdata[cur_idx].id3,
560 event_count == 0);
561 trackdata[cur_idx].event_sent = true;
562 }
563 cur_idx = (cur_idx + 1) & MAX_TRACK_ENTRIES_MASK;
564 }
565 }
566
567 static void recalculate_watermark(int bitrate)
568 {
569 int bytes_per_sec;
570 int time = ata_spinup_time;
571
572 /* A bitrate of 0 probably means empty VBR header. We play safe
573 and set a high threshold */
574 if(bitrate == 0)
575 bitrate = 320;
576
577 bytes_per_sec = bitrate * 1000 / 8;
578
579 if(time)
580 {
581 /* No drive spins up faster than 3.5s */
582 if(time < 350)
583 time = 350;
584
585 time = time * 3;
586 low_watermark = ((low_watermark_margin * HZ + time) *
587 bytes_per_sec) / HZ;
588 }
589 else
590 {
591 low_watermark = MPEG_LOW_WATER;
592 }
593 }
594
595 #ifndef HAVE_FLASH_STORAGE
596 void audio_set_buffer_margin(int seconds)
597 {
598 low_watermark_margin = seconds;
599 }
600 #endif
601
602 void audio_get_debugdata(struct audio_debug *dbgdata)
603 {
604 dbgdata->audiobuflen = audiobuflen;
605 dbgdata->audiobuf_write = audiobuf_write;
606 dbgdata->audiobuf_swapwrite = audiobuf_swapwrite;
607 dbgdata->audiobuf_read = audiobuf_read;
608
609 dbgdata->last_dma_chunk_size = last_dma_chunk_size;
610
611 #if CONFIG_CPU == SH7034
612 dbgdata->dma_on = (SCR0 & 0x80) != 0;
613 #endif
614 dbgdata->playing = playing;
615 dbgdata->play_pending = play_pending;
616 dbgdata->is_playing = is_playing;
617 dbgdata->filling = filling;
618 dbgdata->dma_underrun = dma_underrun;
619
620 dbgdata->unplayed_space = get_unplayed_space();
621 dbgdata->playable_space = get_playable_space();
622 dbgdata->unswapped_space = get_unswapped_space();
623
624 dbgdata->low_watermark_level = low_watermark;
625 dbgdata->lowest_watermark_level = lowest_watermark_level;
626 }
627
628 #ifdef DEBUG
629 static void dbg_timer_start(void)
630 {
631 /* We are using timer 2 */
632
633 TSTR &= ~0x04; /* Stop the timer */
634 TSNC &= ~0x04; /* No synchronization */
635 TMDR &= ~0x44; /* Operate normally */
636
637 TCNT2 = 0; /* Start counting at 0 */
638 TCR2 = 0x03; /* Sysclock/8 */
639
640 TSTR |= 0x04; /* Start timer 2 */
641 }
642
643 static int dbg_cnt2us(unsigned int cnt)
644 {
645 return (cnt * 10000) / (FREQ/800);
646 }
647 #endif /* DEBUG */
648
649 static int get_unplayed_space(void)
650 {
651 int space = audiobuf_write - audiobuf_read;
652 if (space < 0)
653 space += audiobuflen;
654 return space;
655 }
656
657 static int get_playable_space(void)
658 {
659 int space = audiobuf_swapwrite - audiobuf_read;
660 if (space < 0)
661 space += audiobuflen;
662 return space;
663 }
664
665 static int get_unplayed_space_current_song(void)
666 {
667 int space;
668
669 if (num_tracks_in_memory() > 1)
670 {
671 space = get_trackdata(1)->mempos - audiobuf_read;
672 }
673 else
674 {
675 space = audiobuf_write - audiobuf_read;
676 }
677
678 if (space < 0)
679 space += audiobuflen;
680
681 return space;
682 }
683
684 static int get_unswapped_space(void)
685 {
686 int space = audiobuf_write - audiobuf_swapwrite;
687 if (space < 0)
688 space += audiobuflen;
689 return space;
690 }
691
692 #if CONFIG_CODEC == MAS3587F
693 static int get_unsaved_space(void)
694 {
695 int space = audiobuf_write - audiobuf_read;
696 if (space < 0)
697 space += audiobuflen;
698 return space;
699 }
700
701 static void drain_dma_buffer(void)
702 {
703 while (PBDRH & 0x40)
704 {
705 xor_b(0x08, &PADRH);
706
707 while (PBDRH & 0x80);
708
709 xor_b(0x08, &PADRH);
710
711 while (!(PBDRH & 0x80));
712 }
713 }
714
715 #ifdef DEBUG
716 static long timing_info_index = 0;
717 static long timing_info[1024];
718 #endif /* DEBUG */
719
720 void rec_tick (void) __attribute__ ((section (".icode")));
721 void rec_tick(void)
722 {
723 int i;
724 int delay;
725 char data;
726
727 if(is_recording && (PBDRH & 0x40))
728 {
729 #ifdef DEBUG
730 timing_info[timing_info_index++] = current_tick;
731 TCNT2 = 0;
732 #endif /* DEBUG */
733 /* Note: Although this loop is run in interrupt context, further
734 * optimisation will do no good. The MAS would then deliver bad
735 * frames occasionally, as observed in extended experiments. */
736 i = 0;
737 while (PBDRH & 0x40) /* We try to read as long as EOD is high */
738 {
739 xor_b(0x08, &PADRH); /* Set PR active, independent of polarity */
740
741 delay = 100;
742 while (PBDRH & 0x80) /* Wait until /RTW becomes active */
743 {
744 if (--delay <= 0) /* Bail out if we have to wait too long */
745 { /* i.e. the MAS doesn't want to talk to us */
746 xor_b(0x08, &PADRH); /* Set PR inactive */
747 goto transfer_end; /* and get out of here */
748 }
749 }
750
751 data = *(unsigned char *)0x04000000; /* read data byte */
752
753 xor_b(0x08, &PADRH); /* Set PR inactive */
754
755 audiobuf[audiobuf_write++] = data;
756
757 if (audiobuf_write >= audiobuflen)
758 audiobuf_write = 0;
759
760 i++;
761 }
762 transfer_end:
763
764 #ifdef DEBUG
765 timing_info[timing_info_index++] = TCNT2 + (i << 16);
766 timing_info_index &= 0x3ff;
767 #endif /* DEBUG */
768
769 num_rec_bytes += i;
770
771 if(is_prerecording)
772 {
773 if(TIME_AFTER(current_tick, prerecord_timeout))
774 {
775 prerecord_timeout = current_tick + HZ;
776 queue_post(&mpeg_queue, MPEG_PRERECORDING_TICK, 0);
777 }
778 }
779 else
780 {
781 /* Signal to save the data if we are running out of buffer
782 space */
783 if (audiobuflen - get_unsaved_space() < MPEG_RECORDING_LOW_WATER
784 && saving_status == NOT_SAVING)
785 {
786 saving_status = BUFFER_FULL;
787 queue_post(&mpeg_queue, MPEG_SAVE_DATA, 0);
788 }
789 }
790 }
791 }
792 #endif /* CONFIG_CODEC == MAS3587F */
793
794 void playback_tick(void)
795 {
796 struct trackdata *ptd = get_trackdata(0);
797 if(ptd)
798 {
799 ptd->id3.elapsed += (current_tick - last_dma_tick) * 1000 / HZ;
800 last_dma_tick = current_tick;
801 audio_dispatch_event(AUDIO_EVENT_POS_REPORT,
802 (unsigned long)ptd->id3.elapsed);
803 }
804 }
805
806 static void reset_mp3_buffer(void)
807 {
808 audiobuf_read = 0;
809 audiobuf_write = 0;
810 audiobuf_swapwrite = 0;
811 lowest_watermark_level = audiobuflen;
812 }
813
814 /* DMA transfer end interrupt callback */
815 static void transfer_end(unsigned char** ppbuf, size_t* psize)
816 {
817 if(playing && !paused)
818 {
819 int unplayed_space_left;
820 int space_until_end_of_buffer;
821 int track_offset = 1;
822 struct trackdata *track;
823
824 audiobuf_read += last_dma_chunk_size;
825 if(audiobuf_read >= audiobuflen)
826 audiobuf_read = 0;
827
828 /* First, check if we are on a track boundary */
829 if (num_tracks_in_memory() > 1)
830 {
831 if (audiobuf_read == get_trackdata(track_offset)->mempos)
832 {
833 if ( ! audio_dispatch_event(AUDIO_EVENT_END_OF_TRACK, 0) )
834 {
835 queue_post(&mpeg_queue, MPEG_TRACK_CHANGE, 0);
836 track_offset++;
837 }
838 }
839 }
840
841 unplayed_space_left = get_unplayed_space();
842
843 space_until_end_of_buffer = audiobuflen - audiobuf_read;
844
845 if(!filling && unplayed_space_left < low_watermark)
846 {
847 filling = true;
848 queue_post(&mpeg_queue, MPEG_NEED_DATA, GENERATE_UNBUFFER_EVENTS);
849 }
850
851 if(unplayed_space_left)
852 {
853 last_dma_chunk_size = MIN(0x2000, unplayed_space_left);
854 last_dma_chunk_size = MIN(last_dma_chunk_size,
855 space_until_end_of_buffer);
856
857 /* several tracks loaded? */
858 track = get_trackdata(track_offset);
859 if(track)
860 {
861 /* will we move across the track boundary? */
862 if (( audiobuf_read < track->mempos ) &&
863 ((audiobuf_read+last_dma_chunk_size) >
864 track->mempos ))
865 {
866 /* Make sure that we end exactly on the boundary */
867 last_dma_chunk_size = track->mempos - audiobuf_read;
868 }
869 }
870
871 *psize = last_dma_chunk_size & 0xffff;
872 *ppbuf = audiobuf + audiobuf_read;
873 track = get_trackdata(0);
874 if(track)
875 track->id3.offset += last_dma_chunk_size;
876
877 /* Update the watermark debug level */
878 if(unplayed_space_left < lowest_watermark_level)
879 lowest_watermark_level = unplayed_space_left;
880 }
881 else
882 {
883 /* Check if the end of data is because of a hard disk error.
884 If there is an open file handle, we are still playing music.
885 If not, the last file has been loaded, and the file handle is
886 closed. */
887 if(mpeg_file >= 0)
888 {
889 /* Update the watermark debug level */
890 if(unplayed_space_left < lowest_watermark_level)
891 lowest_watermark_level = unplayed_space_left;
892
893 DEBUGF("DMA underrun.\n");
894 dma_underrun = true;
895 }
896 else
897 {
898 if ( ! audio_dispatch_event(AUDIO_EVENT_END_OF_TRACK, 0) )
899 {
900 DEBUGF("No more MP3 data. Stopping.\n");
901 queue_post(&mpeg_queue, MPEG_TRACK_CHANGE, 0);
902 playing = false;
903 }
904 }
905 *psize = 0; /* no more transfer */
906 }
907 }
908 }
909
910 static struct trackdata *add_track_to_tag_list(const char *filename)
911 {
912 struct trackdata *track;
913
914 if(num_tracks_in_memory() >= MAX_TRACK_ENTRIES)
915 {
916 DEBUGF("Tag memory is full\n");
917 return NULL;
918 }
919
920 track = &trackdata[track_write_idx];
921
922 /* grab id3 tag of new file and
923 remember where in memory it starts */
924 if(mp3info(&track->id3, filename, v1first))
925 {
926 DEBUGF("Bad mp3\n");
927 return NULL;
928 }
929 track->mempos = audiobuf_write;
930 track->id3.elapsed = 0;
931 #ifdef HAVE_LCD_BITMAP
932 if (track->id3.title)
933 lcd_getstringsize(track->id3.title, NULL, NULL);
934 if (track->id3.artist)
935 lcd_getstringsize(track->id3.artist, NULL, NULL);
936 if (track->id3.album)
937 lcd_getstringsize(track->id3.album, NULL, NULL);
938 #endif
939 if (cuesheet_callback)
940 if (cuesheet_callback(filename))
941 track->id3.cuesheet_type = 1;
942
943 track_write_idx = (track_write_idx+1) & MAX_TRACK_ENTRIES_MASK;
944 debug_tags();
945 return track;
946 }
947
948 static int new_file(int steps)
949 {
950 int max_steps = playlist_amount();
951 int start = 0;
952 int i;
953 struct trackdata *track;
954
955 /* Find out how many steps to advance. The load_ahead_index field tells
956 us how many playlist entries it had to skip to get to a valid one.
957 We add those together to find out where to start. */
958 if(steps > 0 && num_tracks_in_memory() > 1)
959 {
960 /* Begin with the song after the currently playing one */
961 i = 1;
962 while((track = get_trackdata(i++)))
963 {
964 start += track->load_ahead_index;
965 }
966 }
967
968 do {
969 char *trackname;
970
971 trackname = playlist_peek( start + steps );
972 if ( !trackname )
973 return -1;
974
975 DEBUGF("Loading %s\n", trackname);
976
977 mpeg_file = open(trackname, O_RDONLY);
978 if(mpeg_file < 0) {
979 DEBUGF("Couldn't open file: %s\n",trackname);
980 if(steps < 0)
981 steps--;
982 else
983 steps++;
984 }
985 else
986 {
987 struct trackdata *track = add_track_to_tag_list(trackname);
988
989 if(!track)
990 {
991 /* Bad mp3 file */
992 if(steps < 0)
993 steps--;
994 else
995 steps++;
996 close(mpeg_file);
997 mpeg_file = -1;
998 }
999 else
1000 {
1001 /* skip past id3v2 tag */
1002 lseek(mpeg_file,
1003 track->id3.first_frame_offset,
1004 SEEK_SET);
1005 track->id3.index = steps;
1006 track->load_ahead_index = steps;
1007 track->id3.offset = 0;
1008
1009 if(track->id3.vbr)
1010 /* Average bitrate * 1.5 */
1011 recalculate_watermark(
1012 (track->id3.bitrate * 3) / 2);
1013 else
1014 recalculate_watermark(
1015 track->id3.bitrate);
1016
1017 }
1018 }
1019
1020 /* Bail out if no file could be opened */
1021 if(abs(steps) > max_steps)
1022 return -1;
1023 } while ( mpeg_file < 0 );
1024
1025 return 0;
1026 }
1027
1028 static void stop_playing(void)
1029 {
1030 /* Stop the current stream */
1031 mp3_play_stop();
1032 playing = false;
1033 filling = false;
1034 if(mpeg_file >= 0)
1035 close(mpeg_file);
1036 mpeg_file = -1;
1037 remove_all_tags();
1038 generate_unbuffer_events();
1039 reset_mp3_buffer();
1040 }
1041
1042 /* Is this a really the end of playback or is a new playlist starting */
1043 static void check_playlist_end(int direction)
1044 {
1045 /* Use the largest possible step size to account for skipped tracks */
1046 int steps = playlist_amount();
1047
1048 if (direction < 0)
1049 steps = -steps;
1050
1051 if (playlist_next(steps) < 0)
1052 is_playing = false;
1053 }
1054
1055 static void update_playlist(void)
1056 {
1057 if (num_tracks_in_memory() > 0)
1058 {
1059 struct trackdata *track = get_trackdata(0);
1060 track->id3.index = playlist_next(track->id3.index);
1061 }
1062 else
1063 {
1064 /* End of playlist? */
1065 check_playlist_end(1);
1066 }
1067
1068 playlist_update_resume_info(audio_current_track());
1069 }
1070
1071 static void track_change(void)
1072 {
1073 DEBUGF("Track change\n");
1074
1075 struct trackdata *track = get_trackdata(0);
1076 prev_track_elapsed = track->id3.elapsed;
1077
1078 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
1079 /* Reset the AVC */
1080 sound_set_avc(-1);
1081 #endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */
1082
1083 if (num_tracks_in_memory() > 0)
1084 {
1085 remove_current_tag();
1086 if (track_changed_callback)
1087 track_changed_callback(audio_current_track());
1088 update_playlist();
1089 }
1090
1091 current_track_counter++;
1092 }
1093
1094 unsigned long audio_prev_elapsed(void)
1095 {
1096 return prev_track_elapsed;
1097 }
1098
1099 #ifdef DEBUG
1100 void hexdump(const unsigned char *buf, int len)
1101 {
1102 int i;
1103
1104 for(i = 0;i < len;i++)
1105 {
1106 if(i && (i & 15) == 0)
1107 {
1108 DEBUGF("\n");
1109 }
1110 DEBUGF("%02x ", buf[i]);
1111 }
1112 DEBUGF("\n");
1113 }
1114 #endif /* DEBUG */
1115
1116 static void start_playback_if_ready(void)
1117 {
1118 int playable_space;
1119
1120 playable_space = audiobuf_swapwrite - audiobuf_read;
1121 if(playable_space < 0)
1122 playable_space += audiobuflen;
1123
1124 /* See if we have started playing yet. If not, do it. */
1125 if(play_pending || dma_underrun)
1126 {
1127 /* If the filling has stopped, and we still haven't reached
1128 the watermark, the file must be smaller than the
1129 watermark. We must still play it. */
1130 if((playable_space >= MPEG_PLAY_PENDING_THRESHOLD) ||
1131 !filling || dma_underrun)
1132 {
1133 DEBUGF("P\n");
1134 if (play_pending) /* don't do this when recovering from DMA underrun */
1135 {
1136 generate_postbuffer_events(); /* signal first track as buffered */
1137 if (track_changed_callback)
1138 track_changed_callback(audio_current_track());
1139 play_pending = false;
1140 }
1141 playing = true;
1142
1143 last_dma_chunk_size = MIN(0x2000, get_unplayed_space_current_song());
1144 mp3_play_data(audiobuf + audiobuf_read, last_dma_chunk_size, transfer_end);
1145 dma_underrun = false;
1146
1147 if (!paused)
1148 {
1149 last_dma_tick = current_tick;
1150 mp3_play_pause(true);
1151 }
1152
1153 /* Tell ourselves that we need more data */
1154 queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
1155 }
1156 }
1157 }
1158
1159 static bool swap_one_chunk(void)
1160 {
1161 int free_space_left;
1162 int amount_to_swap;
1163
1164 free_space_left = get_unswapped_space();
1165
1166 if(free_space_left == 0 && !play_pending)
1167 return false;
1168
1169 /* Swap in larger chunks when the user is waiting for the playback
1170 to start, or when there is dangerously little playable data left */
1171 if(play_pending)
1172 amount_to_swap = MIN(MPEG_PLAY_PENDING_SWAPSIZE, free_space_left);
1173 else
1174 {
1175 if(get_playable_space() < low_watermark)
1176 amount_to_swap = MIN(MPEG_LOW_WATER_SWAP_CHUNKSIZE,
1177 free_space_left);
1178 else
1179 amount_to_swap = MIN(MPEG_SWAP_CHUNKSIZE, free_space_left);
1180 }
1181
1182 if(audiobuf_write < audiobuf_swapwrite)
1183 amount_to_swap = MIN(audiobuflen - audiobuf_swapwrite,
1184 amount_to_swap);
1185 else
1186 amount_to_swap = MIN(audiobuf_write - audiobuf_swapwrite,
1187 amount_to_swap);
1188
1189 bitswap(audiobuf + audiobuf_swapwrite, amount_to_swap);
1190
1191 audiobuf_swapwrite += amount_to_swap;
1192 if(audiobuf_swapwrite >= audiobuflen)
1193 {
1194 audiobuf_swapwrite = 0;
1195 }
1196
1197 return true;
1198 }
1199
1200 static void mpeg_thread(void)
1201 {
1202 static int pause_tick = 0;
1203 static unsigned int pause_track = 0;
1204 struct event ev;
1205 int len;
1206 int free_space_left;
1207 int unplayed_space_left;
1208 int amount_to_read;
1209 int t1, t2;
1210 int start_offset;
1211 #if CONFIG_CODEC == MAS3587F
1212 int amount_to_save;
1213 int save_endpos = 0;
1214 int rc;
1215 int level;
1216 long offset;
1217 #endif /* CONFIG_CODEC == MAS3587F */
1218
1219 is_playing = false;
1220 play_pending = false;
1221 playing = false;
1222 mpeg_file = -1;
1223
1224 while(1)
1225 {
1226 #if CONFIG_CODEC == MAS3587F
1227 if(mpeg_mode == MPEG_DECODER)
1228 {
1229 #endif /* CONFIG_CODEC == MAS3587F */
1230 yield();
1231
1232 /* Swap if necessary, and don't block on the queue_wait() */
1233 if(swap_one_chunk())
1234 {
1235 queue_wait_w_tmo(&mpeg_queue, &ev, 0);
1236 }
1237 else if (playing)
1238 {
1239 /* periodically update resume info */
1240 queue_wait_w_tmo(&mpeg_queue, &ev, HZ/2);
1241 }
1242 else
1243 {
1244 DEBUGF("S R:%x W:%x SW:%x\n",
1245 audiobuf_read, audiobuf_write, audiobuf_swapwrite);
1246 queue_wait(&mpeg_queue, &ev);
1247 }
1248
1249 start_playback_if_ready();
1250
1251 switch(ev.id)
1252 {
1253 case MPEG_PLAY:
1254 DEBUGF("MPEG_PLAY\n");
1255
1256 #if CONFIG_TUNER
1257 /* Silence the A/D input, it may be on because the radio
1258 may be playing */
1259 mas_codec_writereg(6, 0x0000);
1260 #endif /* CONFIG_TUNER */
1261
1262 /* Stop the current stream */
1263 play_pending = false;
1264 playing = false;
1265 paused = false;
1266 mp3_play_pause(false);
1267
1268 reset_mp3_buffer();
1269 remove_all_tags();
1270 generate_unbuffer_events();
1271
1272 if(mpeg_file >= 0)
1273 close(mpeg_file);
1274
1275 if ( new_file(0) == -1 )
1276 {
1277 is_playing = false;
1278 track_change();
1279 break;
1280 }
1281
1282 start_offset = (int)ev.data;
1283
1284 /* mid-song resume? */
1285 if (start_offset) {
1286 struct mp3entry* id3 = &get_trackdata(0)->id3;
1287 lseek(mpeg_file, start_offset, SEEK_SET);
1288 id3->offset = start_offset;
1289 set_elapsed(id3);
1290 }
1291 else {
1292 /* skip past id3v2 tag */
1293 lseek(mpeg_file,
1294 get_trackdata(0)->id3.first_frame_offset,
1295 SEEK_SET);
1296
1297 }
1298
1299 /* Make it read more data */
1300 filling = true;
1301 queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
1302
1303 /* Tell the file loading code that we want to start playing
1304 as soon as we have some data */
1305 play_pending = true;
1306
1307 update_playlist();
1308 current_track_counter++;
1309 break;
1310
1311 case MPEG_STOP:
1312 DEBUGF("MPEG_STOP\n");
1313 is_playing = false;
1314 paused = false;
1315
1316 if (playing)
1317 playlist_update_resume_info(audio_current_track());
1318
1319 stop_playing();
1320 mpeg_stop_done = true;
1321 break;
1322
1323 case MPEG_PAUSE:
1324 DEBUGF("MPEG_PAUSE\n");
1325 /* Stop the current stream */
1326 if (playing)
1327 playlist_update_resume_info(audio_current_track());
1328 paused = true;
1329 playing = false;
1330 pause_tick = current_tick;
1331 pause_track = current_track_counter;
1332 mp3_play_pause(false);
1333 break;
1334
1335 case MPEG_RESUME:
1336 DEBUGF("MPEG_RESUME\n");
1337 /* Continue the current stream */
1338 paused = false;
1339 if (!play_pending)
1340 {
1341 playing = true;
1342 if ( current_track_counter == pause_track )
1343 last_dma_tick += current_tick - pause_tick;
1344 else
1345 last_dma_tick = current_tick;
1346 pause_tick = 0;
1347 mp3_play_pause(true);
1348 }
1349 break;
1350
1351 case MPEG_NEXT:
1352 DEBUGF("MPEG_NEXT\n");
1353 /* is next track in ram? */
1354 if ( num_tracks_in_memory() > 1 ) {
1355 int unplayed_space_left, unswapped_space_left;
1356
1357 /* stop the current stream */
1358 play_pending = false;
1359 playing = false;
1360 mp3_play_pause(false);
1361
1362 track_change();
1363 audiobuf_read = get_trackdata(0)->mempos;
1364 last_dma_chunk_size = MIN(0x2000, get_unplayed_space_current_song());
1365 mp3_play_data(audiobuf + audiobuf_read, last_dma_chunk_size, transfer_end);
1366 dma_underrun = false;
1367 last_dma_tick = current_tick;
1368
1369 unplayed_space_left = get_unplayed_space();
1370 unswapped_space_left = get_unswapped_space();
1371
1372 /* should we start reading more data? */
1373 if(!filling && (unplayed_space_left < low_watermark)) {
1374 filling = true;
1375 queue_post(&mpeg_queue, MPEG_NEED_DATA, GENERATE_UNBUFFER_EVENTS);
1376 play_pending = true;
1377 } else if(unswapped_space_left &&
1378 unswapped_space_left > unplayed_space_left) {
1379 /* Stop swapping the data from the previous file */
1380 audiobuf_swapwrite = audiobuf_read;
1381 play_pending = true;
1382 } else {
1383 playing = true;
1384 if (!paused)
1385 mp3_play_pause(true);
1386 }
1387 }
1388 else {
1389 if (!playlist_check(1))
1390 break;
1391
1392 /* stop the current stream */
1393 play_pending = false;
1394 playing = false;
1395 mp3_play_pause(false);
1396
1397 reset_mp3_buffer();
1398 remove_all_tags();
1399 generate_unbuffer_events();
1400
1401 /* Open the next file */
1402 if (mpeg_file >= 0)
1403 close(mpeg_file);
1404
1405 if (new_file(1) < 0) {
1406 DEBUGF("No more files to play\n");
1407 filling = false;
1408
1409 check_playlist_end(1);
1410 current_track_counter++;
1411 } else {
1412 /* Make it read more data */
1413 filling = true;
1414 queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
1415
1416 /* Tell the file loading code that we want
1417 to start playing as soon as we have some data */
1418 play_pending = true;
1419
1420 update_playlist();
1421 current_track_counter++;
1422 }
1423 }
1424 break;
1425
1426 case MPEG_PREV: {
1427 DEBUGF("MPEG_PREV\n");
1428
1429 if (!playlist_check(-1))
1430 break;
1431
1432 /* stop the current stream */
1433 play_pending = false;
1434 playing = false;
1435 mp3_play_pause(false);
1436
1437 reset_mp3_buffer();
1438 remove_all_tags();
1439 generate_unbuffer_events();
1440
1441 /* Open the next file */
1442 if (mpeg_file >= 0)
1443 close(mpeg_file);
1444
1445 if (new_file(-1) < 0) {
1446 DEBUGF("No more files to play\n");
1447 filling = false;
1448
1449 check_playlist_end(-1);
1450 current_track_counter++;
1451 } else {
1452 /* Make it read more data */
1453 filling = true;
1454 queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
1455
1456 /* Tell the file loading code that we want to
1457 start playing as soon as we have some data */
1458 play_pending = true;
1459
1460 update_playlist();
1461 current_track_counter++;
1462 }
1463 break;
1464 }
1465
1466 case MPEG_FF_REWIND: {
1467 struct mp3entry *id3 = audio_current_track();
1468 unsigned int oldtime = id3->elapsed;
1469 unsigned int newtime = (unsigned int)ev.data;
1470 int curpos, newpos, diffpos;
1471 DEBUGF("MPEG_FF_REWIND\n");
1472
1473 id3->elapsed = newtime;
1474
1475 newpos = audio_get_file_pos();
1476 if(newpos < 0)
1477 {
1478 id3->elapsed = oldtime;
1479 break;
1480 }
1481
1482 if (mpeg_file >= 0)
1483 curpos = lseek(mpeg_file, 0, SEEK_CUR);
1484 else
1485 curpos = id3->filesize;
1486
1487 if (num_tracks_in_memory() > 1)
1488 {
1489 /* We have started loading other tracks that need to be
1490 accounted for */
1491 struct trackdata *track;
1492 int i = 0;
1493
1494 while((track = get_trackdata(i++)))
1495 {
1496 curpos += track->id3.filesize;
1497 }
1498 }
1499
1500 diffpos = curpos - newpos;
1501
1502 if(!filling && diffpos >= 0 && diffpos < audiobuflen)
1503 {
1504 int unplayed_space_left, unswapped_space_left;
1505
1506 /* We are changing to a position that's already in
1507 memory, so we just move the DMA read pointer. */
1508 audiobuf_read = audiobuf_write - diffpos;
1509 if (audiobuf_read < 0)
1510 {
1511 audiobuf_read += audiobuflen;
1512 }
1513
1514 unplayed_space_left = get_unplayed_space();
1515 unswapped_space_left = get_unswapped_space();
1516
1517 /* If unswapped_space_left is larger than
1518 unplayed_space_left, it means that the swapwrite pointer
1519 hasn't yet advanced up to the new location of the read
1520 pointer. We just move it, there is no need to swap
1521 data that won't be played anyway. */
1522
1523 if (unswapped_space_left > unplayed_space_left)
1524 {
1525 DEBUGF("Moved swapwrite\n");
1526 audiobuf_swapwrite = audiobuf_read;
1527 play_pending = true;
1528 }
1529
1530 if (mpeg_file>=0 && unplayed_space_left < low_watermark)
1531 {
1532 /* We need to load more data before starting */
1533 filling = true;
1534 queue_post(&mpeg_queue, MPEG_NEED_DATA, GENERATE_UNBUFFER_EVENTS);
1535 play_pending = true;
1536 }
1537 else
1538 {
1539 /* resume will start at new position */
1540 last_dma_chunk_size =
1541 MIN(0x2000, get_unplayed_space_current_song());
1542 mp3_play_data(audiobuf + audiobuf_read,
1543 last_dma_chunk_size, transfer_end);
1544 dma_underrun = false;
1545 }
1546 }
1547 else
1548 {
1549 /* Move to the new position in the file and start
1550 loading data */
1551 reset_mp3_buffer();
1552
1553 if (num_tracks_in_memory() > 1)
1554 {
1555 /* We have to reload the current track */
1556 close(mpeg_file);
1557 remove_all_non_current_tags();
1558 generate_unbuffer_events();
1559 mpeg_file = -1;
1560 }
1561
1562 if (mpeg_file < 0)
1563 {
1564 mpeg_file = open(id3->path, O_RDONLY);
1565 if (mpeg_file < 0)
1566 {
1567 id3->elapsed = oldtime;
1568 break;
1569 }
1570 }
1571
1572 if(-1 == lseek(mpeg_file, newpos, SEEK_SET))
1573 {
1574 id3->elapsed = oldtime;
1575 break;
1576 }
1577
1578 filling = true;
1579 queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
1580
1581 /* Tell the file loading code that we want to start playing
1582 as soon as we have some data */
1583 play_pending = true;
1584 }
1585
1586 id3->offset = newpos;
1587
1588 break;
1589 }
1590
1591 case MPEG_FLUSH_RELOAD: {
1592 int numtracks = num_tracks_in_memory();
1593 bool reload_track = false;
1594
1595 if (numtracks > 1)
1596 {
1597 /* Reset the buffer */
1598 audiobuf_write = get_trackdata(1)->mempos;
1599
1600 /* Reset swapwrite unless we're still swapping current
1601 track */
1602 if (get_unplayed_space() <= get_playable_space())
1603 audiobuf_swapwrite = audiobuf_write;
1604
1605 close(mpeg_file);
1606 remove_all_non_current_tags();
1607 generate_unbuffer_events();
1608 mpeg_file = -1;
1609 reload_track = true;
1610 }
1611 else if (numtracks == 1 && mpeg_file < 0)
1612 {
1613 reload_track = true;
1614 }
1615
1616 if(reload_track && new_file(1) >= 0)
1617 {
1618 /* Tell ourselves that we want more data */
1619 filling = true;
1620 queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
1621 }
1622
1623 break;
1624 }
1625
1626 case MPEG_NEED_DATA:
1627 free_space_left = audiobuf_read - audiobuf_write;
1628
1629 /* We interpret 0 as "empty buffer" */
1630 if(free_space_left <= 0)
1631 free_space_left += audiobuflen;
1632
1633 unplayed_space_left = audiobuflen - free_space_left;
1634
1635 /* Make sure that we don't fill the entire buffer */
1636 free_space_left -= MPEG_HIGH_WATER;
1637
1638 if (ev.data == GENERATE_UNBUFFER_EVENTS)
1639 generate_unbuffer_events();
1640
1641 /* do we have any more buffer space to fill? */
1642 if(free_space_left <= 0)
1643 {
1644 DEBUGF("0\n");
1645 filling = false;
1646 generate_postbuffer_events();
1647 ata_sleep();
1648 break;
1649 }
1650
1651 /* Read small chunks while we are below the low water mark */
1652 if(unplayed_space_left < low_watermark)
1653 amount_to_read = MIN(MPEG_LOW_WATER_CHUNKSIZE,
1654 free_space_left);
1655 else
1656 amount_to_read = free_space_left;
1657
1658 /* Don't read more than until the end of the buffer */
1659 amount_to_read = MIN(audiobuflen - audiobuf_write,
1660 amount_to_read);
1661 #ifdef HAVE_MMC /* MMC is slow, so don't read too large chunks */
1662 amount_to_read = MIN(0x40000, amount_to_read);
1663 #elif MEM == 8
1664 amount_to_read = MIN(0x100000, amount_to_read);
1665 #endif
1666
1667 /* Read as much mpeg data as we can fit in the buffer */
1668 if(mpeg_file >= 0)
1669 {
1670 DEBUGF("R\n");
1671 t1 = current_tick;
1672 len = read(mpeg_file, audiobuf + audiobuf_write,
1673 amount_to_read);
1674 if(len > 0)
1675 {
1676 t2 = current_tick;
1677 DEBUGF("time: %d\n", t2 - t1);
1678 DEBUGF("R: %x\n", len);
1679
1680 /* Now make sure that we don't feed the MAS with ID3V1
1681 data */
1682 if (len < amount_to_read)
1683 {
1684 int i;
1685 static const unsigned char tag[] = "TAG";
1686 int taglen = 128;
1687 int tagptr = audiobuf_write + len - 128;
1688
1689 /* Really rare case: entire potential tag wasn't
1690 read in this call AND audiobuf_write < 128 */
1691 if (tagptr < 0)
1692 tagptr += audiobuflen;
1693
1694 for(i = 0;i < 3;i++)
1695 {
1696 if(tagptr >= audiobuflen)
1697 tagptr -= audiobuflen;
1698
1699 if(audiobuf[tagptr] != tag[i])
1700 {
1701 taglen = 0;
1702 break;
1703 }
1704
1705 tagptr++;
1706 }
1707
1708 if(taglen)
1709 {
1710 /* Skip id3v1 tag */
1711 DEBUGF("Skipping ID3v1 tag\n");
1712 len -= taglen;
1713
1714 /* In the very rare case when the entire tag
1715 wasn't read in this read() len will be < 0.
1716 Take care of this when changing the write
1717 pointer. */
1718 }
1719 }
1720
1721 audiobuf_write += len;
1722
1723 if (audiobuf_write < 0)
1724 audiobuf_write += audiobuflen;
1725
1726 if(audiobuf_write >= audiobuflen)
1727 {
1728 audiobuf_write = 0;
1729 DEBUGF("W\n");
1730 }
1731
1732 /* Tell ourselves that we want more data */
1733 queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
1734 }
1735 else
1736 {
1737 if(len < 0)
1738 {
1739 DEBUGF("MPEG read error\n");
1740 }
1741
1742 close(mpeg_file);
1743 mpeg_file = -1;
1744
1745 if(new_file(1) < 0)
1746 {
1747 /* No more data to play */
1748 DEBUGF("No more files to play\n");
1749 filling = false;
1750 }
1751 else
1752 {
1753 /* Tell ourselves that we want more data */
1754 queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
1755 }
1756 }
1757 }
1758 break;
1759
1760 case MPEG_TRACK_CHANGE:
1761 track_change();
1762 break;
1763
1764 #ifndef USB_NONE
1765 case SYS_USB_CONNECTED:
1766 is_playing = false;
1767 paused = false;
1768 stop_playing();
1769
1770 /* Tell the USB thread that we are safe */
1771 DEBUGF("mpeg_thread got SYS_USB_CONNECTED\n");
1772 usb_acknowledge(SYS_USB_CONNECTED_ACK);
1773
1774 /* Wait until the USB cable is extracted again */
1775 usb_wait_for_disconnect(&mpeg_queue);
1776 break;
1777 #endif /* !USB_NONE */
1778
1779 #if CONFIG_CODEC == MAS3587F
1780 case MPEG_INIT_RECORDING:
1781 init_recording();
1782 init_recording_done = true;
1783 break;
1784 #endif /* CONFIG_CODEC == MAS3587F */
1785
1786 case SYS_TIMEOUT:
1787 if (playing)
1788 playlist_update_resume_info(audio_current_track());
1789 break;
1790 }
1791 #if CONFIG_CODEC == MAS3587F
1792 }
1793 else
1794 {
1795 queue_wait(&mpeg_queue, &ev);
1796 switch(ev.id)
1797 {
1798 case MPEG_RECORD:
1799 if (is_prerecording)
1800 {
1801 int startpos;
1802
1803 /* Go back prerecord_count seconds in the buffer */
1804 startpos = prerecord_index - prerecord_count;
1805 if(startpos < 0)
1806 startpos += prerecording_max_seconds;
1807
1808 /* Read the position data from the prerecord buffer */
1809 frame_count_start = prerecord_buffer[startpos].framecount;
1810 startpos = prerecord_buffer[startpos].mempos;
1811
1812 DEBUGF("Start looking at address %x (%x)\n",
1813 audiobuf+startpos, startpos);
1814
1815 saved_header = mpeg_get_last_header();
1816
1817 mem_find_next_frame(startpos, &offset, 1800,
1818 saved_header);
1819
1820 audiobuf_read = startpos + offset;
1821 if(audiobuf_read >= audiobuflen)
1822 audiobuf_read -= audiobuflen;
1823
1824 DEBUGF("New audiobuf_read address: %x (%x)\n",
1825 audiobuf+audiobuf_read, audiobuf_read);
1826
1827 level = set_irq_level(HIGHEST_IRQ_LEVEL);
1828 num_rec_bytes = get_unsaved_space();
1829 set_irq_level(level);
1830 }
1831 else
1832 {
1833 frame_count_start = 0;
1834 num_rec_bytes = 0;
1835 audiobuf_read = MPEG_RESERVED_HEADER_SPACE;
1836 audiobuf_write = MPEG_RESERVED_HEADER_SPACE;
1837 }
1838
1839 prepend_header();
1840 DEBUGF("Recording...\n");
1841 start_recording();
1842
1843 /* Wait until at least one frame is encoded and get the
1844 frame header, for later use by the Xing header
1845 generation */
1846 sleep(HZ/5);
1847 saved_header = mpeg_get_last_header();
1848
1849 /* delayed until buffer is saved, don't open yet */
1850 strcpy(delayed_filename, recording_filename);
1851 mpeg_file = -1;
1852
1853 break;
1854
1855 case MPEG_STOP:
1856 DEBUGF("MPEG_STOP\n");
1857
1858 stop_recording();
1859
1860 /* Save the remaining data in the buffer */
1861 save_endpos = audiobuf_write;
1862 saving_status = STOP_RECORDING;
1863 queue_post(&mpeg_queue, MPEG_SAVE_DATA, 0);
1864 break;
1865
1866 case MPEG_STOP_DONE:
1867 DEBUGF("MPEG_STOP_DONE\n");
1868
1869 if (mpeg_file >= 0)
1870 close(mpeg_file);
1871 mpeg_file = -1;
1872
1873 update_header();
1874 #ifdef DEBUG1
1875 {
1876 int i;
1877 for(i = 0;i < 512;i++)
1878 {
1879 DEBUGF("%d - %d us (%d bytes)\n",
1880 timing_info[i*2],
1881 (timing_info[i*2+1] & 0xffff) *
1882 10000 / 13824,
1883 timing_info[i*2+1] >> 16);
1884 }
1885 }
1886 #endif /* DEBUG1 */
1887
1888 if (prerecording)
1889 {
1890 start_prerecording();
1891 }
1892 mpeg_stop_done = true;
1893 break;
1894
1895 case MPEG_NEW_FILE:
1896 /* Bail out when a more important save is happening */
1897 if (saving_status > NEW_FILE)
1898 break;
1899
1900 /* Make sure we have at least one complete frame
1901 in the buffer. If we haven't recorded a single
1902 frame within 200ms, the MAS is probably not recording
1903 anything, and we bail out. */
1904 amount_to_save = get_unsaved_space();
1905 if (amount_to_save < 1800)
1906 {
1907 sleep(HZ/5);
1908 amount_to_save = get_unsaved_space();
1909 }
1910
1911 mas_readmem(MAS_BANK_D0, MAS_D0_MPEG_FRAME_COUNT,
1912 &frame_count_end, 1);
1913
1914 last_rec_time = current_tick - record_start_time;
1915 record_start_time = current_tick;
1916 if (paused)
1917 pause_start_time = record_start_time;
1918
1919 /* capture all values at one point */
1920 level = set_irq_level(HIGHEST_IRQ_LEVEL);
1921 save_endpos = audiobuf_write;
1922 last_rec_bytes = num_rec_bytes;
1923 num_rec_bytes = 0;
1924 set_irq_level(level);
1925
1926 if (amount_to_save >= 1800)
1927 {
1928 /* Now find a frame boundary to split at */
1929 save_endpos -= 1800;
1930 if (save_endpos < 0)
1931 save_endpos += audiobuflen;
1932
1933 rc = mem_find_next_frame(save_endpos, &offset, 1800,
1934 saved_header);
1935 if (!rc) /* No header found, save whole buffer */
1936 offset = 1800;
1937
1938 save_endpos += offset;
1939 if (save_endpos >= audiobuflen)
1940 save_endpos -= audiobuflen;
1941
1942 last_rec_bytes += offset - 1800;
1943 level = set_irq_level(HIGHEST_IRQ_LEVEL);
1944 num_rec_bytes += 1800 - offset;
1945 set_irq_level(level);
1946 }
1947
1948 saving_status = NEW_FILE;
1949 queue_post(&mpeg_queue, MPEG_SAVE_DATA, 0);
1950 break;
1951
1952 case MPEG_SAVE_DATA:
1953 if (saving_status == BUFFER_FULL)
1954 save_endpos = audiobuf_write;
1955
1956 if (mpeg_file < 0) /* delayed file open */
1957 {
1958 mpeg_file = open(delayed_filename, O_WRONLY|O_CREAT);
1959
1960 if (mpeg_file < 0)
1961 panicf("recfile: %d", mpeg_file);
1962 }
1963
1964 amount_to_save = save_endpos - audiobuf_read;
1965 if (amount_to_save < 0)
1966 amount_to_save += audiobuflen;
1967
1968 amount_to_save = MIN(amount_to_save,
1969 audiobuflen - audiobuf_read);
1970 #ifdef HAVE_MMC /* MMC is slow, so don't save too large chunks at once */
1971 amount_to_save = MIN(0x40000, amount_to_save);
1972 #elif MEM == 8
1973 amount_to_save = MIN(0x100000, amount_to_save);
1974 #endif
1975 rc = write(mpeg_file, audiobuf + audiobuf_read,
1976 amount_to_save);
1977 if (rc < 0)
1978 {
1979 if (errno == ENOSPC)
1980 {
1981 mpeg_errno = AUDIOERR_DISK_FULL;
1982 stop_recording();
1983 queue_post(&mpeg_queue, MPEG_STOP_DONE, 0);
1984 /* will close the file */
1985 break;
1986 }
1987 else
1988 panicf("rec wrt: %d", rc);
1989 }
1990
1991 audiobuf_read += amount_to_save;
1992 if (audiobuf_read >= audiobuflen)
1993 audiobuf_read = 0;
1994
1995 if (audiobuf_read == save_endpos) /* all saved */
1996 {
1997 switch (saving_status)
1998 {
1999 case BUFFER_FULL:
2000 rc = fsync(mpeg_file);
2001 if (rc < 0)
2002 panicf("rec fls: %d", rc);
2003 ata_sleep();
2004 break;
2005
2006 case NEW_FILE:
2007 /* Close the current file */
2008 rc = close(mpeg_file);
2009 if (rc < 0)
2010 panicf("rec cls: %d", rc);
2011 mpeg_file = -1;
2012 update_header();
2013 ata_sleep();
2014
2015 /* copy new filename */
2016 strcpy(delayed_filename, recording_filename);
2017 prepend_header();
2018 frame_count_start = frame_count_end;
2019 break;
2020
2021 case STOP_RECORDING:
2022 queue_post(&mpeg_queue, MPEG_STOP_DONE, 0);
2023 /* will close the file */
2024 break;
2025
2026 default:
2027 break;
2028 }
2029 saving_status = NOT_SAVING;
2030 }
2031 else /* tell ourselves to save the next chunk */
2032 queue_post(&mpeg_queue, MPEG_SAVE_DATA, 0);
2033
2034 break;
2035
2036 case MPEG_PRERECORDING_TICK:
2037 if(!is_prerecording)
2038 break;
2039
2040 /* Store the write pointer every second */
2041 prerecord_buffer[prerecord_index].mempos = audiobuf_write;
2042 mas_readmem(MAS_BANK_D0, MAS_D0_MPEG_FRAME_COUNT,
2043 &prerecord_buffer[prerecord_index].framecount, 1);
2044
2045 /* Wrap if necessary */
2046 if(++prerecord_index == prerecording_max_seconds)
2047 prerecord_index = 0;
2048
2049 /* Update the number of seconds recorded */
2050 if(prerecord_count < prerecording_max_seconds)
2051 prerecord_count++;
2052 break;
2053
2054 case MPEG_INIT_PLAYBACK:
2055 /* Stop the prerecording */
2056 stop_recording();
2057 reset_mp3_buffer();
2058 mp3_play_init();
2059 init_playback_done = true;
2060 break;
2061
2062 case MPEG_PAUSE_RECORDING:
2063 pause_recording();
2064 break;
2065
2066 case MPEG_RESUME_RECORDING:
2067 resume_recording();
2068 break;
2069
2070 case SYS_USB_CONNECTED:
2071 /* We can safely go to USB mode if no recording
2072 is taking place */
2073 if((!is_recording || is_prerecording) && mpeg_stop_done)
2074 {
2075 /* Even if we aren't recording, we still call this
2076 function, to put the MAS in monitoring mode,
2077 to save power. */
2078 stop_recording();
2079
2080 /* Tell the USB thread that we are safe */
2081 DEBUGF("mpeg_thread got SYS_USB_CONNECTED\n");
2082 usb_acknowledge(SYS_USB_CONNECTED_ACK);
2083
2084 /* Wait until the USB cable is extracted again */
2085 usb_wait_for_disconnect(&mpeg_queue);
2086 }
2087 break;
2088 }
2089 }
2090 #endif /* CONFIG_CODEC == MAS3587F */
2091 }
2092 }
2093 #endif /* !SIMULATOR */
2094
2095 void mpeg_id3_options(bool _v1first)
2096 {
2097 v1first = _v1first;
2098 }
2099
2100 struct mp3entry* audio_current_track()
2101 {
2102 #ifdef SIMULATOR
2103 return &taginfo;
2104 #else /* !SIMULATOR */
2105 if(num_tracks_in_memory())
2106 return &get_trackdata(0)->id3;
2107 else
2108 return NULL;
2109 #endif /* !SIMULATOR */
2110 }
2111
2112 struct mp3entry* audio_next_track()
2113 {
2114 #ifdef SIMULATOR
2115 return &taginfo;
2116 #else /* !SIMULATOR */
2117 if(num_tracks_in_memory() > 1)
2118 return &get_trackdata(1)->id3;
2119 else
2120 return NULL;
2121 #endif /* !SIMULATOR */
2122 }
2123
2124 bool audio_has_changed_track(void)
2125 {
2126 if(last_track_counter != current_track_counter)
2127 {
2128 last_track_counter = current_track_counter;
2129 return true;
2130 }
2131 return false;
2132 }
2133
2134 #if CONFIG_CODEC == MAS3587F
2135 #ifndef SIMULATOR
2136 void audio_init_playback(void)
2137 {
2138 init_playback_done = false;
2139 queue_post(&mpeg_queue, MPEG_INIT_PLAYBACK, 0);
2140
2141 while(!init_playback_done)
2142 sleep_thread(1);
2143 }
2144
2145
2146 /****************************************************************************
2147 * Recording functions
2148 ***************************************************************************/
2149 void audio_init_recording(unsigned int buffer_offset)
2150 {
2151 buffer_offset = buffer_offset;
2152 init_recording_done = false;
2153 queue_post(&mpeg_queue, MPEG_INIT_RECORDING, 0);
2154
2155 while(!init_recording_done)
2156 sleep_thread(1);
2157 }
2158
2159 static void init_recording(void)
2160 {
2161 unsigned long val;
2162 int rc;
2163
2164 /* Disable IRQ6 */
2165 IPRB &= 0xff0f;
2166
2167 stop_playing();
2168 is_playing = false;
2169 paused = false;
2170
2171 /* Init the recording variables */
2172 is_recording = false;
2173 is_prerecording = false;
2174
2175 mpeg_stop_done = true;
2176
2177 mas_reset();
2178
2179 /* Enable the audio CODEC and the DSP core, max analog voltage range */
2180 rc = mas_direct_config_write(MAS_CONTROL, 0x8c00);
2181 if(rc < 0)
2182 panicf("mas_ctrl_w: %d", rc);
2183
2184 /* Stop the current application */
2185 val = 0;
2186 mas_writemem(MAS_BANK_D0, MAS_D0_APP_SELECT, &val, 1);
2187 do
2188 {
2189 mas_readmem(MAS_BANK_D0, MAS_D0_APP_RUNNING, &val, 1);
2190 } while(val);
2191
2192 /* Perform black magic as described by the data sheet */
2193 if((mas_version_code & 0x0fff) == 0x0102)
2194 {
2195 DEBUGF("Performing MAS black magic for B2 version\n");
2196 mas_writereg(0xa3, 0x98);
2197 mas_writereg(0x94, 0xfffff);
2198 val = 0;
2199 mas_writemem(MAS_BANK_D1, 0, &val, 1);
2200 mas_writereg(0xa3, 0x90);
2201 }
2202
2203 /* Enable A/D Converters */
2204 shadow_codec_reg0 = 0xcccd;
2205 mas_codec_writereg(0x0, shadow_codec_reg0);
2206
2207 /* Copy left channel to right (mono mode) */
2208 mas_codec_writereg(8, 0x8000);
2209
2210 /* ADC scale 0%, DSP scale 100%
2211 We use the DSP output for monitoring, because it works with all
2212 sources including S/PDIF */
2213 mas_codec_writereg(6, 0x0000);
2214 mas_codec_writereg(7, 0x4000);
2215
2216 /* No mute */
2217 shadow_soft_mute = 0;
2218 mas_writemem(MAS_BANK_D0, MAS_D0_SOFT_MUTE, &shadow_soft_mute, 1);
2219
2220 #ifdef HAVE_SPDIF_OUT
2221 val = 0x09; /* Disable SDO and SDI, low impedance S/PDIF outputs */
2222 #else
2223 val = 0x2d; /* Disable SDO and SDI, disable S/PDIF output */
2224 #endif
2225 mas_writemem(MAS_BANK_D0, MAS_D0_INTERFACE_CONTROL, &val, 1);
2226
2227 /* Set Demand mode, monitoring OFF and validate all settings */
2228 shadow_io_control_main = 0x125;
2229 mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main, 1);
2230
2231 /* Start the encoder application */
2232 val = 0x40;
2233 mas_writemem(MAS_BANK_D0, MAS_D0_APP_SELECT, &val, 1);
2234 do
2235 {
2236 mas_readmem(MAS_BANK_D0, MAS_D0_APP_RUNNING, &val, 1);
2237 } while(!(val & 0x40));
2238
2239 /* We have started the recording application with monitoring OFF.
2240 This is because we want to record at least one frame to fill the DMA
2241 buffer, because the silly MAS will not negate EOD until at least one
2242 DMA transfer has taken place.
2243 Now let's wait for some data to be encoded. */
2244 sleep(HZ/5);
2245
2246 /* Now set it to Monitoring mode as default, saves power */
2247 shadow_io_control_main = 0x525;
2248 mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main, 1);
2249
2250 /* Wait until the DSP has accepted the settings */
2251 do
2252 {
2253 mas_readmem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &val,1);
2254 } while(val & 1);
2255
2256 drain_dma_buffer();
2257 mpeg_mode = MPEG_ENCODER;
2258
2259 DEBUGF("MAS Recording application started\n");
2260
2261 /* At this point, all settings are the reset MAS defaults, next thing is to
2262 call mpeg_set_recording_options(). */
2263 }
2264
2265 void audio_record(const char *filename)
2266 {
2267 mpeg_errno = 0;
2268
2269 strncpy(recording_filename, filename, MAX_PATH - 1);
2270 recording_filename[MAX_PATH - 1] = 0;
2271
2272 queue_post(&mpeg_queue, MPEG_RECORD, 0);
2273 }
2274
2275 void audio_pause_recording(void)
2276 {
2277 queue_post(&mpeg_queue, MPEG_PAUSE_RECORDING, 0);
2278 }
2279
2280 void audio_resume_recording(void)
2281 {
2282 queue_post(&mpeg_queue, MPEG_RESUME_RECORDING, 0);
2283 }
2284
2285 static void prepend_header(void)
2286 {
2287 int startpos;
2288 unsigned i;
2289
2290 /* Make room for header */
2291 audiobuf_read -= MPEG_RESERVED_HEADER_SPACE;
2292 if(audiobuf_read < 0)
2293 {
2294 /* Clear the bottom half */
2295 memset(audiobuf, 0, audiobuf_read + MPEG_RESERVED_HEADER_SPACE);
2296
2297 /* And the top half */
2298 audiobuf_read += audiobuflen;
2299 memset(audiobuf + audiobuf_read, 0, audiobuflen - audiobuf_read);
2300 }
2301 else
2302 {
2303 memset(audiobuf + audiobuf_read, 0, MPEG_RESERVED_HEADER_SPACE);
2304 }
2305 /* Copy the empty ID3 header */
2306 startpos = audiobuf_read;
2307 for(i = 0; i < sizeof(empty_id3_header); i++)
2308 {
2309 audiobuf[startpos++] = empty_id3_header[i];
2310 if(startpos == audiobuflen)
2311 startpos = 0;
2312 }
2313 }
2314
2315 static void update_header(void)
2316 {
2317 int fd, framelen;
2318 unsigned long frames;
2319
2320 if (last_rec_bytes > 0)
2321 {
2322 /* Create the Xing header */
2323 fd = open(delayed_filename, O_RDWR);
2324 if (fd < 0)
2325 panicf("rec upd: %d (%s)", fd, recording_filename);
2326
2327 frames = frame_count_end - frame_count_start;
2328 /* If the number of recorded frames has reached 0x7ffff,
2329 we can no longer trust it */
2330 if (frame_count_end == 0x7ffff)
2331 frames = 0;
2332
2333 /* saved_header is saved right before stopping the MAS */
2334 framelen = create_xing_header(fd, 0, last_rec_bytes, xing_buffer,
2335 frames, last_rec_time * (1000/HZ),
2336 saved_header, NULL, false);
2337
2338 lseek(fd, MPEG_RESERVED_HEADER_SPACE - framelen, SEEK_SET);
2339 write(fd, xing_buffer, framelen);
2340 close(fd);
2341 }
2342 }
2343
2344 static void start_prerecording(void)
2345 {
2346 unsigned long val;
2347
2348 DEBUGF("Starting prerecording\n");
2349
2350 prerecord_index = 0;
2351 prerecord_count = 0;
2352 prerecord_timeout = current_tick + HZ;
2353 memset(prerecord_buffer, 0, sizeof(prerecord_buffer));
2354 reset_mp3_buffer();
2355
2356 is_prerecording = true;
2357
2358 /* Stop monitoring and start the encoder */
2359 shadow_io_control_main &= ~(1 << 10);
2360 mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main, 1);
2361 DEBUGF("mas_writemem(MAS_BANK_D0, IO_CONTROL_MAIN, %x)\n", shadow_io_control_main);
2362
2363 /* Wait until the DSP has accepted the settings */
2364 do
2365 {
2366 mas_readmem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &val,1);
2367 } while(val & 1);
2368
2369 is_recording = true;
2370 saving_status = NOT_SAVING;
2371
2372 demand_irq_enable(true);
2373 }
2374
2375 static void start_recording(void)
2376 {
2377 unsigned long val;
2378
2379 if(is_prerecording)
2380 {
2381 /* This will make the IRQ handler start recording
2382 for real, i.e send MPEG_SAVE_DATA messages when
2383 the buffer is full */
2384 is_prerecording = false;
2385 }
2386 else
2387 {
2388 /* If prerecording is off, we need to stop the monitoring
2389 and start the encoder */
2390 shadow_io_control_main &= ~(1 << 10);
2391 mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main, 1);
2392 DEBUGF("mas_writemem(MAS_BANK_D0, IO_CONTROL_MAIN, %x)\n", shadow_io_control_main);
2393
2394 /* Wait until the DSP has accepted the settings */
2395 do
2396 {
2397 mas_readmem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &val,1);
2398 } while(val & 1);
2399 }
2400
2401 is_recording = true;
2402 saving_status = NOT_SAVING;
2403 paused = false;
2404
2405 /* Store the current time */
2406 if(prerecording)
2407 record_start_time = current_tick - prerecord_count * HZ;
2408 else
2409 record_start_time = current_tick;
2410
2411 pause_start_time = 0;
2412
2413 demand_irq_enable(true);
2414 }
2415
2416 static void pause_recording(void)
2417 {
2418 pause_start_time = current_tick;
2419
2420 /* Set the pause bit */
2421 shadow_soft_mute |= 2;
2422 mas_writemem(MAS_BANK_D0, MAS_D0_SOFT_MUTE, &shadow_soft_mute, 1);
2423
2424 paused = true;
2425 }
2426
2427 static void resume_recording(void)
2428 {
2429 paused = false;
2430
2431 /* Clear the pause bit */
2432 shadow_soft_mute &= ~2;
2433 mas_writemem(MAS_BANK_D0, MAS_D0_SOFT_MUTE, &shadow_soft_mute, 1);
2434
2435 /* Compensate for the time we have been paused */
2436 if(pause_start_time)
2437 {
2438 record_start_time =
2439 current_tick - (pause_start_time - record_start_time);
2440 pause_start_time = 0;
2441 }
2442 }
2443
2444 static void stop_recording(void)
2445 {
2446 unsigned long val;
2447
2448 /* Let it finish the last frame */
2449 if(!paused)
2450 pause_recording();
2451 sleep(HZ/5);
2452
2453 demand_irq_enable(false);
2454
2455 is_recording = false;
2456 is_prerecording = false;
2457
2458 last_rec_bytes = num_rec_bytes;
2459 mas_readmem(MAS_BANK_D0, MAS_D0_MPEG_FRAME_COUNT, &frame_count_end, 1);
2460 last_rec_time = current_tick - record_start_time;
2461
2462 /* Start monitoring */
2463 shadow_io_control_main |= (1 << 10);
2464 mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main, 1);
2465 DEBUGF("mas_writemem(MAS_BANK_D0, IO_CONTROL_MAIN, %x)\n", shadow_io_control_main);
2466
2467 /* Wait until the DSP has accepted the settings */
2468 do
2469 {
2470 mas_readmem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &val,1);
2471 } while(val & 1);
2472
2473 resume_recording();
2474 }
2475
2476 void audio_set_recording_options(struct audio_recording_options *options)
2477 {
2478 bool is_mpeg1;
2479
2480 is_mpeg1 = (options->rec_frequency < 3)?true:false;
2481
2482 rec_version_index = is_mpeg1?3:2;
2483 rec_frequency_index = options->rec_frequency % 3;
2484
2485 shadow_encoder_control = (options->rec_quality << 17) |
2486 (rec_frequency_index << 10) |
2487 ((is_mpeg1?1:0) << 9) |
2488 (((options->rec_channels * 2 + 1) & 3) << 6) |
2489 (1 << 5) /* MS-stereo */ |
2490 (1 << 2) /* Is an original */;
2491 mas_writemem(MAS_BANK_D0, MAS_D0_ENCODER_CONTROL, &shadow_encoder_control,1);
2492
2493 DEBUGF("mas_writemem(MAS_BANK_D0, ENCODER_CONTROL, %x)\n", shadow_encoder_control);
2494
2495 shadow_soft_mute = options->rec_editable?4:0;
2496 mas_writemem(MAS_BANK_D0, MAS_D0_SOFT_MUTE, &shadow_soft_mute,1);
2497
2498 DEBUGF("mas_writemem(MAS_BANK_D0, SOFT_MUTE, %x)\n", shadow_soft_mute);
2499
2500 shadow_io_control_main = ((1 << 10) | /* Monitoring ON */
2501 ((options->rec_source < 2)?1:2) << 8) | /* Input select */
2502 (1 << 5) | /* SDO strobe invert */
2503 ((is_mpeg1?0:1) << 3) |
2504 (1 << 2) | /* Inverted SIBC clock signal */
2505 1; /* Validate */
2506 mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main,1);
2507
2508 DEBUGF("mas_writemem(MAS_BANK_D0, IO_CONTROL_MAIN, %x)\n", shadow_io_control_main);
2509
2510 if(options->rec_source == AUDIO_SRC_MIC)
2511 {
2512 /* Copy left channel to right (mono mode) */
2513 mas_codec_writereg(8, 0x8000);
2514 }
2515 else
2516 {
2517 /* Stereo input mode */
2518 mas_codec_writereg(8, 0);
2519 }
2520
2521 prerecording_max_seconds = options->rec_prerecord_time;
2522 if(prerecording_max_seconds)
2523 {
2524 prerecording = true;
2525 start_prerecording();
2526 }
2527 else
2528 {
2529 prerecording = false;
2530 is_prerecording = false;
2531 is_recording = false;
2532 }
2533 }
2534
2535 /* If use_mic is true, the left gain is used */
2536 void audio_set_recording_gain(int left, int right, int type)
2537 {
2538 /* Enable both left and right A/D */
2539 shadow_codec_reg0 = (left << 12) |
2540 (right << 8) |
2541 (left << 4) |
2542 (type==AUDIO_GAIN_MIC?0x0008:0) | /* Connect left A/D to mic */
2543 0x0007;
2544 mas_codec_writereg(0x0, shadow_codec_reg0);
2545 }
2546
2547 #if CONFIG_TUNER & S1A0903X01
2548 /* Get the (unpitched) MAS PLL frequency, for avoiding FM interference with the
2549 * Samsung tuner. Zero means unknown. Currently handles recording from analog
2550 * input only. */
2551 int mpeg_get_mas_pllfreq(void)
2552 {
2553 if (mpeg_mode != MPEG_ENCODER)
2554 return 0;
2555
2556 if (rec_frequency_index == 0) /* 44.1 kHz / 22.05 kHz */
2557 return 22579000;
2558 else
2559 return 24576000;
2560 }
2561 #endif /* CONFIG_TUNER & S1A0903X01 */
2562
2563 /* try to make some kind of beep, also in recording mode */
2564 void audio_beep(int duration)
2565 {
2566 long starttick = current_tick;
2567 do
2568 { /* toggle bit 0 of codec register 0, toggling the DAC off & on.
2569 * While this is still audible even without an external signal,
2570 * it doesn't affect the (pre-)recording. */
2571 mas_codec_writereg(0, shadow_codec_reg0 ^ 1);
2572 mas_codec_writereg(0, shadow_codec_reg0);
2573 yield();
2574 }
2575 while (current_tick - starttick < duration);
2576 }
2577
2578 void audio_new_file(const char *filename)
2579 {
2580 mpeg_errno = 0;
2581
2582 strncpy(recording_filename, filename, MAX_PATH - 1);
2583 recording_filename[MAX_PATH - 1] = 0;
2584
2585 queue_post(&mpeg_queue, MPEG_NEW_FILE, 0);
2586 }
2587
2588 unsigned long audio_recorded_time(void)
2589 {
2590 if(is_prerecording)
2591 return prerecord_count * HZ;
2592
2593 if(is_recording)
2594 {
2595 if(paused)
2596 return pause_start_time - record_start_time;
2597 else
2598 return current_tick - record_start_time;
2599 }
2600
2601 return 0;
2602 }
2603
2604 unsigned long audio_num_recorded_bytes(void)
2605 {
2606 int num_bytes;
2607 int index;
2608
2609 if(is_recording)
2610 {
2611 if(is_prerecording)
2612 {
2613 index = prerecord_index - prerecord_count;
2614 if(index < 0)
2615 index += prerecording_max_seconds;
2616
2617 num_bytes = audiobuf_write - prerecord_buffer[index].mempos;
2618 if(num_bytes < 0)
2619 num_bytes += audiobuflen;
2620
2621 return num_bytes;;
2622 }
2623 else
2624 return num_rec_bytes;
2625 }
2626 else
2627 return 0;
2628 }
2629
2630 #else /* SIMULATOR */
2631
2632 /* dummies coming up */
2633
2634 void audio_init_playback(void)
2635 {
2636 /* a dummy */
2637 }
2638 unsigned long audio_recorded_time(void)
2639 {
2640 /* a dummy */
2641 return 0;
2642 }
2643 void audio_beep(int duration)
2644 {
2645 /* a dummy */
2646 (void)duration;
2647 }
2648 void audio_pause_recording(void)
2649 {
2650 /* a dummy */
2651 }
2652 void audio_resume_recording(void)
2653 {
2654 /* a dummy */
2655 }
2656 unsigned long audio_num_recorded_bytes(void)
2657 {
2658 /* a dummy */
2659 return 0;
2660 }
2661 void audio_record(const char *filename)
2662 {
2663 /* a dummy */
2664 (void)filename;
2665 }
2666 void audio_new_file(const char *filename)
2667 {
2668 /* a dummy */
2669 (void)filename;
2670 }
2671
2672 void audio_set_recording_gain(int left, int right, int type)
2673 {
2674 /* a dummy */
2675 (void)left;
2676 (void)right;
2677 (void)type;
2678 }
2679 void audio_init_recording(unsigned int buffer_offset)
2680 {
2681 /* a dummy */
2682 (void)buffer_offset;
2683 }
2684 void audio_set_recording_options(struct audio_recording_options *options)
2685 {
2686 /* a dummy */
2687 (void)options;
2688 }
2689 #endif /* SIMULATOR */
2690 #endif /* CONFIG_CODEC == MAS3587F */
2691
2692 void audio_play(long offset)
2693 {
2694 #ifdef SIMULATOR
2695 char* trackname;
2696 int steps=0;
2697
2698 is_playing = true;
2699
2700 do {
2701 trackname = playlist_peek( steps );
2702 if (!trackname)
2703 break;
2704 if(mp3info(&taginfo, trackname, v1first)) {
2705 /* bad mp3, move on */
2706 if(++steps > playlist_amount())
2707 break;
2708 continue;
2709 }
2710 #ifdef HAVE_MPEG_PLAY
2711 real_mpeg_play(trackname);
2712 #endif
2713 playlist_next(steps);
2714 taginfo.offset = offset;
2715 set_elapsed(&taginfo);
2716 is_playing = true;
2717 playing = true;
2718 break;
2719 } while(1);
2720 #else /* !SIMULATOR */
2721 is_playing = true;
2722
2723 queue_post(&mpeg_queue, MPEG_PLAY, offset);
2724 #endif /* !SIMULATOR */
2725
2726 mpeg_errno = 0;
2727 }
2728
2729 void audio_stop(void)
2730 {
2731 #ifndef SIMULATOR
2732 if (playing)
2733 {
2734 struct trackdata *track = get_trackdata(0);
2735 prev_track_elapsed = track->id3.elapsed;
2736 }
2737 mpeg_stop_done = false;
2738 queue_post(&mpeg_queue, MPEG_STOP, 0);
2739 while(!mpeg_stop_done)
2740 yield();
2741 #else /* SIMULATOR */
2742 paused = false;
2743 is_playing = false;
2744 playing = false;
2745 #endif /* SIMULATOR */
2746 }
2747
2748 /* dummy */
2749 void audio_stop_recording(void)
2750 {
2751 audio_stop();
2752 }
2753
2754 void audio_pause(void)
2755 {
2756 #ifndef SIMULATOR
2757 queue_post(&mpeg_queue, MPEG_PAUSE, 0);
2758 #else /* SIMULATOR */
2759 is_playing = true;
2760 playing = false;
2761 paused = true;
2762 #endif /* SIMULATOR */
2763 }
2764
2765 void audio_resume(void)
2766 {
2767 #ifndef SIMULATOR
2768 queue_post(&mpeg_queue, MPEG_RESUME, 0);
2769 #else /* SIMULATOR */
2770 is_playing = true;
2771 playing = true;
2772 paused = false;
2773 #endif /* SIMULATOR */
2774 }
2775
2776 void audio_next(void)
2777 {
2778 #ifndef SIMULATOR
2779 queue_remove_from_head(&mpeg_queue, MPEG_NEED_DATA);
2780 queue_post(&mpeg_queue, MPEG_NEXT, 0);
2781 #else /* SIMULATOR */
2782 char* file;
2783 int steps = 1;
2784 int index;
2785
2786 do {
2787 file = playlist_peek(steps);
2788 if(!file)
2789 break;
2790 if(mp3info(&taginfo, file, v1first)) {
2791 if(++steps > playlist_amount())
2792 break;
2793 continue;
2794 }
2795 index = playlist_next(steps);
2796 taginfo.index = index;
2797 current_track_counter++;
2798 is_playing = true;
2799 playing = true;
2800 break;
2801 } while(1);
2802 #endif /* SIMULATOR */
2803 }
2804
2805 void audio_prev(void)
2806 {
2807 #ifndef SIMULATOR
2808 queue_remove_from_head(&mpeg_queue, MPEG_NEED_DATA);
2809 queue_post(&mpeg_queue, MPEG_PREV, 0);
2810 #else /* SIMULATOR */
2811 char* file;
2812 int steps = -1;
2813 int index;
2814
2815 do {
2816 file = playlist_peek(steps);
2817 if(!file)
2818 break;
2819 if(mp3info(&taginfo, file, v1first)) {
2820 steps--;
2821 continue;
2822 }
2823 index = playlist_next(steps);
2824 taginfo.index = index;
2825 current_track_counter++;
2826 is_playing = true;
2827 playing = true;
2828 break;
2829 } while(1);
2830 #endif /* SIMULATOR */
2831 }
2832
2833 void audio_ff_rewind(long newtime)
2834 {
2835 #ifndef SIMULATOR
2836 queue_post(&mpeg_queue, MPEG_FF_REWIND, newtime);
2837 #else /* SIMULATOR */
2838 (void)newtime;
2839 #endif /* SIMULATOR */
2840 }
2841
2842 void audio_flush_and_reload_tracks(void)
2843 {
2844 #ifndef SIMULATOR
2845 queue_post(&mpeg_queue, MPEG_FLUSH_RELOAD, 0);
2846 #endif /* !SIMULATOR*/
2847 }
2848
2849 int audio_status(void)
2850 {
2851 int ret = 0;
2852
2853 if(is_playing)
2854 ret |= AUDIO_STATUS_PLAY;
2855
2856 if(paused)
2857 ret |= AUDIO_STATUS_PAUSE;
2858
2859 #if (CONFIG_CODEC == MAS3587F) && !defined(SIMULATOR)
2860 if(is_recording && !is_prerecording)
2861 ret |= AUDIO_STATUS_RECORD;
2862
2863 if(is_prerecording)
2864 ret |= AUDIO_STATUS_PRERECORD;
2865 #endif /* CONFIG_CODEC == MAS3587F */
2866
2867 if(mpeg_errno)
2868 ret |= AUDIO_STATUS_ERROR;
2869
2870 return ret;
2871 }
2872
2873 unsigned int audio_error(void)
2874 {
2875 return mpeg_errno;
2876 }
2877
2878 void audio_error_clear(void)
2879 {
2880 mpeg_errno = 0;
2881 }
2882
2883 #ifdef SIMULATOR
2884 static void mpeg_thread(void)
2885 {
2886 struct mp3entry* id3;
2887 while ( 1 ) {
2888 if (is_playing) {
2889 id3 = audio_current_track();
2890 if (!paused)
2891 {
2892 id3->elapsed+=1000;
2893 id3->offset+=1000;
2894 }
2895 if (id3->elapsed>=id3->length)
2896 audio_next();
2897 }
2898 sleep(HZ);
2899 }
2900 }
2901 #endif /* SIMULATOR */
2902
2903 void audio_init(void)
2904 {
2905 mpeg_errno = 0;
2906 track_buffer_callback = NULL;
2907 track_unbuffer_callback = NULL;
2908 track_changed_callback = NULL;
2909
2910 #ifndef SIMULATOR
2911 audiobuflen = audiobufend - audiobuf;
2912 queue_init(&mpeg_queue, true);
2913 #endif /* !SIMULATOR */
2914 create_thread(mpeg_thread, mpeg_stack,
2915 sizeof(mpeg_stack), mpeg_thread_name IF_PRIO(, PRIORITY_SYSTEM)
2916 IF_COP(, CPU, false));
2917
2918 memset(trackdata, sizeof(trackdata), 0);
2919
2920 #if (CONFIG_CODEC == MAS3587F) && !defined(SIMULATOR)
2921 if (HW_MASK & PR_ACTIVE_HIGH)
2922 and_b(~0x08, &PADRH);
2923 else
2924 or_b(0x08, &PADRH);
2925 #endif /* CONFIG_CODEC == MAS3587F */
2926
2927 #ifdef DEBUG
2928 dbg_timer_start();
2929 dbg_cnt2us(0);
2930 #endif /* DEBUG */
2931 }
2932
2933 #endif /* CONFIG_CODEC != SWCODEC */
Open Source Jukebox Firmware