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