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