gitscraper: support Python3.
[maemo-rb.git] / apps / codecs / spc.c
blob809562e2a059d282b7a812796f23a8825ee54ace
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
10 * Copyright (C) 2007-2008 Michael Sevakis (jhMikeS)
11 * Copyright (C) 2006-2007 Adam Gashlin (hcs)
12 * Copyright (C) 2004-2007 Shay Green (blargg)
13 * Copyright (C) 2002 Brad Martin
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version 2
18 * of the License, or (at your option) any later version.
20 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
21 * KIND, either express or implied.
23 ****************************************************************************/
25 /* lovingly ripped off from Game_Music_Emu 0.5.2. http://www.slack.net/~ant/ */
26 /* DSP Based on Brad Martin's OpenSPC DSP emulator */
27 /* tag reading from sexyspc by John Brawn (John_Brawn@yahoo.com) and others */
28 #include "codeclib.h"
29 #include "../fracmul.h"
30 #include "libspc/spc_codec.h"
31 #include "libspc/spc_profiler.h"
33 CODEC_HEADER
35 /**************** ID666 parsing ****************/
37 static struct {
38 unsigned char isBinary;
39 char song[32];
40 char game[32];
41 char dumper[16];
42 char comments[32];
43 int day,month,year;
44 unsigned long length;
45 unsigned long fade;
46 char artist[32];
47 unsigned char muted;
48 unsigned char emulator;
49 } ID666;
51 static int LoadID666(unsigned char *buf) {
52 unsigned char *ib=buf;
53 int isbinary = 1;
54 int i;
56 memcpy(ID666.song,ib,32);
57 ID666.song[31]=0;
58 ib+=32;
60 memcpy(ID666.game,ib,32);
61 ID666.game[31]=0;
62 ib+=32;
64 memcpy(ID666.dumper,ib,16);
65 ID666.dumper[15]=0;
66 ib+=16;
68 memcpy(ID666.comments,ib,32);
69 ID666.comments[31]=0;
70 ib+=32;
72 /* Ok, now comes the fun part. */
74 /* Date check */
75 if(ib[2] == '/' && ib[5] == '/' )
76 isbinary = 0;
78 /* Reserved bytes check */
79 if(ib[0xD2 - 0x2E - 112] >= '0' &&
80 ib[0xD2 - 0x2E - 112] <= '9' &&
81 ib[0xD3 - 0x2E - 112] == 0x00)
82 isbinary = 0;
84 /* is length & fade only digits? */
85 for (i=0;i<8 && (
86 (ib[0xA9 - 0x2E - 112+i]>='0'&&ib[0xA9 - 0x2E - 112+i]<='9') ||
87 ib[0xA9 - 0x2E - 112+i]=='\0');
88 i++);
89 if (i==8) isbinary=0;
91 ID666.isBinary = isbinary;
93 if(isbinary) {
94 DEBUGF("binary tag detected\n");
95 ID666.year=*ib;
96 ib++;
97 ID666.year|=*ib<<8;
98 ib++;
99 ID666.month=*ib;
100 ib++;
101 ID666.day=*ib;
102 ib++;
104 ib+=7;
106 ID666.length=*ib;
107 ib++;
109 ID666.length|=*ib<<8;
110 ib++;
112 ID666.length|=*ib<<16;
113 ID666.length*=1000;
114 ib++;
116 ID666.fade=*ib;
117 ib++;
118 ID666.fade|=*ib<<8;
119 ib++;
120 ID666.fade|=*ib<<16;
121 ib++;
122 ID666.fade|=*ib<<24;
123 ib++;
125 memcpy(ID666.artist,ib,32);
126 ID666.artist[31]=0;
127 ib+=32;
129 ID666.muted=*ib;
130 ib++;
132 ID666.emulator=*ib;
133 ib++;
134 } else {
135 unsigned long tmp;
136 char buf[64];
138 DEBUGF("text tag detected\n");
140 memcpy(buf, ib, 2);
141 buf[2] = 0;
142 tmp = 0;
143 for (i=0;i<2 && buf[i]>='0' && buf[i]<='9';i++) tmp=tmp*10+buf[i]-'0';
144 ID666.month = tmp;
145 ib+=3;
147 memcpy(buf, ib, 2);
148 buf[2] = 0;
149 tmp = 0;
150 for (i=0;i<2 && buf[i]>='0' && buf[i]<='9';i++) tmp=tmp*10+buf[i]-'0';
151 ID666.day = tmp;
152 ib+=3;
154 memcpy(buf, ib, 4);
155 buf[4] = 0;
156 tmp = 0;
157 for (i=0;i<4 && buf[i]>='0' && buf[i]<='9';i++) tmp=tmp*10+buf[i]-'0';
158 ID666.year = tmp;
159 ib+=5;
161 memcpy(buf, ib, 3);
162 buf[3] = 0;
163 tmp = 0;
164 for (i=0;i<3 && buf[i]>='0' && buf[i]<='9';i++) tmp=tmp*10+buf[i]-'0';
165 ID666.length = tmp * 1000;
166 ib+=3;
168 memcpy(buf, ib, 5);
169 buf[5] = 0;
170 tmp = 0;
171 for (i=0;i<5 && buf[i]>='0' && buf[i]<='9';i++) tmp=tmp*10+buf[i]-'0';
172 ID666.fade = tmp;
173 ib+=5;
175 memcpy(ID666.artist,ib,32);
176 ID666.artist[31]=0;
177 ib+=32;
179 /*I have no idea if this is right or not.*/
180 ID666.muted=*ib;
181 ib++;
183 memcpy(buf, ib, 1);
184 buf[1] = 0;
185 tmp = 0;
186 ib++;
188 return 1;
191 /**************** Codec ****************/
192 enum {SAMPLE_RATE = 32000};
193 static struct Spc_Emu spc_emu IBSS_ATTR_SPC CACHEALIGN_ATTR;
195 #if SPC_DUAL_CORE
196 /** Implementations for pipelined dual-core operation **/
197 static int spc_emu_thread_stack[DEFAULT_STACK_SIZE/sizeof(int)]
198 CACHEALIGN_ATTR;
200 static const unsigned char * const spc_emu_thread_name = "spc emu";
201 static unsigned int emu_thread_id = 0;
203 enum
205 SPC_EMU_AUDIO = 0,
206 SPC_EMU_LOAD,
207 SPC_EMU_QUIT,
210 struct spc_load
212 uint8_t *buf;
213 size_t size;
216 /* sample queue */
217 #define WAV_NUM_CHUNKS 2
218 #define WAV_CHUNK_MASK (WAV_NUM_CHUNKS-1)
219 struct sample_queue_chunk
221 long id;
222 union
224 intptr_t data;
225 int32_t audio[WAV_CHUNK_SIZE*2];
229 static struct
231 int head, tail;
232 struct semaphore emu_sem_head;
233 struct semaphore emu_sem_tail;
234 struct semaphore emu_evt_reply;
235 intptr_t retval;
236 struct sample_queue_chunk wav_chunk[WAV_NUM_CHUNKS];
237 } sample_queue SHAREDBSS_ATTR;
239 static inline void samples_release_wrbuf(void)
241 sample_queue.tail++;
242 ci->semaphore_release(&sample_queue.emu_sem_head);
245 static inline struct sample_queue_chunk * samples_get_wrbuf(void)
247 ci->semaphore_wait(&sample_queue.emu_sem_tail, TIMEOUT_BLOCK);
248 return &sample_queue.wav_chunk[sample_queue.tail & WAV_CHUNK_MASK];
251 static inline void samples_release_rdbuf(void)
253 if (sample_queue.head != sample_queue.tail) {
254 sample_queue.head++;
257 ci->semaphore_release(&sample_queue.emu_sem_tail);
260 static inline int32_t * samples_get_rdbuf(void)
262 ci->semaphore_wait(&sample_queue.emu_sem_head, TIMEOUT_BLOCK);
263 return sample_queue.wav_chunk[sample_queue.head & WAV_CHUNK_MASK].audio;
266 static intptr_t emu_thread_send_msg(long id, intptr_t data)
268 struct sample_queue_chunk *chunk;
269 /* Grab an audio output buffer */
270 ci->semaphore_wait(&sample_queue.emu_sem_head, TIMEOUT_BLOCK);
271 chunk = &sample_queue.wav_chunk[sample_queue.head & WAV_CHUNK_MASK];
272 /* Place a message in it instead of audio */
273 chunk->id = id;
274 chunk->data = data;
275 /* Release it to the emu thread */
276 samples_release_rdbuf();
278 if (id != SPC_EMU_QUIT) {
279 /* Wait for a response */
280 ci->semaphore_wait(&sample_queue.emu_evt_reply, TIMEOUT_BLOCK);
283 return sample_queue.retval;
286 /* thread function */
287 static bool emu_thread_process_msg(struct sample_queue_chunk *chunk)
289 long id = chunk->id;
290 bool ret = id != SPC_EMU_QUIT;
292 chunk->id = SPC_EMU_AUDIO; /* Reset chunk type to audio */
293 sample_queue.retval = 0;
295 if (id == SPC_EMU_LOAD)
297 struct spc_load *ld = (struct spc_load *)chunk->data;
298 ci->commit_discard_dcache();
299 SPC_Init(&spc_emu);
300 sample_queue.retval = SPC_load_spc(&spc_emu, ld->buf, ld->size);
302 /* Empty the audio queue */
303 ci->semaphore_release(&sample_queue.emu_sem_tail);
304 ci->semaphore_release(&sample_queue.emu_sem_tail);
305 ci->semaphore_wait(&sample_queue.emu_sem_head, TIMEOUT_NOBLOCK);
306 ci->semaphore_wait(&sample_queue.emu_sem_head, TIMEOUT_NOBLOCK);
307 sample_queue.head = sample_queue.tail = 0;
310 if (id != SPC_EMU_QUIT) {
311 ci->semaphore_release(&sample_queue.emu_evt_reply);
314 return ret;
317 static void spc_emu_thread(void)
319 CPU_Init(&spc_emu);
321 while (1) {
322 /* get a buffer for output */
323 struct sample_queue_chunk *chunk = samples_get_wrbuf();
325 if (chunk->id != SPC_EMU_AUDIO) {
326 /* This chunk doesn't contain audio but a command */
327 if (!emu_thread_process_msg(chunk))
328 break;
329 /* Have to re-get this pointer to keep semaphore counts correct */
330 continue;
333 ENTER_TIMER(render);
334 /* fill samples buffer */
335 if ( SPC_play(&spc_emu, WAV_CHUNK_SIZE*2, chunk->audio) )
336 assert( false );
337 EXIT_TIMER(render);
339 /* done so release it to output */
340 samples_release_wrbuf();
341 ci->yield();
345 static bool spc_emu_start(void)
347 emu_thread_id = ci->create_thread(spc_emu_thread, spc_emu_thread_stack,
348 sizeof(spc_emu_thread_stack), CREATE_THREAD_FROZEN,
349 spc_emu_thread_name IF_PRIO(, PRIORITY_PLAYBACK), COP);
351 if (emu_thread_id == 0)
352 return false;
354 /* Initialize audio queue as full to prevent emu thread from trying to run the
355 emulator before loading something */
356 ci->semaphore_init(&sample_queue.emu_evt_reply, 1, 0);
357 ci->semaphore_init(&sample_queue.emu_sem_tail, 2, 0);
358 ci->semaphore_init(&sample_queue.emu_sem_head, 2, 2);
359 sample_queue.head = 0;
360 sample_queue.tail = 2;
362 /* Start it running */
363 ci->thread_thaw(emu_thread_id);
364 return true;
367 /* load a new program on the emu thread */
368 static inline int load_spc_buffer(uint8_t *buf, size_t size)
370 struct spc_load ld = { buf, size };
371 ci->commit_dcache();
372 return emu_thread_send_msg(SPC_EMU_LOAD, (intptr_t)&ld);
375 static inline void spc_emu_quit(void)
377 if (emu_thread_id != 0) {
378 emu_thread_send_msg(SPC_EMU_QUIT, 0);
379 /* Wait for emu thread to be killed */
380 ci->thread_wait(emu_thread_id);
381 ci->commit_discard_dcache();
385 static inline int32_t * spc_play_get_samples(void)
387 /* obtain filled samples buffer */
388 return samples_get_rdbuf();
391 static inline void spc_play_send_samples(int32_t *samples)
393 ci->pcmbuf_insert(samples, samples+WAV_CHUNK_SIZE, WAV_CHUNK_SIZE);
394 /* done with chunk so release it to emu thread */
395 samples_release_rdbuf();
398 #else /* !SPC_DUAL_CORE */
399 /** Implementations for single-core operation **/
400 static int32_t wav_chunk[WAV_CHUNK_SIZE*2] IBSS_ATTR;
402 /* load a new program into emu */
403 static inline int load_spc_buffer(uint8_t *buf, size_t size)
405 SPC_Init(&spc_emu);
406 return SPC_load_spc(&spc_emu, buf, size);
409 static inline bool spc_emu_start(void)
411 #ifdef CPU_COLDFIRE
412 /* signed integer mode with saturation */
413 coldfire_set_macsr(EMAC_SATURATE);
414 #endif
415 CPU_Init(&spc_emu);
416 return true;
419 static inline void spc_play_send_samples(int32_t *samples)
421 ci->pcmbuf_insert(samples, samples+WAV_CHUNK_SIZE, WAV_CHUNK_SIZE);
424 #define spc_emu_quit()
425 #define samples_release_rdbuf()
427 static inline int32_t * spc_play_get_samples(void)
429 ENTER_TIMER(render);
430 /* fill samples buffer */
431 if ( SPC_play(&spc_emu,WAV_CHUNK_SIZE*2,wav_chunk) )
432 assert( false );
433 EXIT_TIMER(render);
434 return wav_chunk;
436 #endif /* SPC_DUAL_CORE */
438 /* The main decoder loop */
439 static int play_track( void )
441 int sampleswritten=0;
443 unsigned long fadestartsample = ID666.length*(long long) SAMPLE_RATE/1000;
444 unsigned long fadeendsample = (ID666.length+ID666.fade)*(long long) SAMPLE_RATE/1000;
445 int fadedec = 0;
446 int fadevol = 0x7fffffffl;
447 intptr_t param;
449 if (fadeendsample>fadestartsample)
450 fadedec=0x7fffffffl/(fadeendsample-fadestartsample)+1;
452 ENTER_TIMER(total);
454 while ( 1 )
456 enum codec_command_action action = ci->get_command(&param);
458 if (action == CODEC_ACTION_HALT)
459 break;
461 if (action == CODEC_ACTION_SEEK_TIME) {
462 int curtime = sampleswritten*1000LL/SAMPLE_RATE;
463 DEBUGF("seek to %ld\ncurrently at %d\n", (long)param, curtime);
464 if (param < curtime) {
465 DEBUGF("seek backwards = reset\n");
466 ci->set_elapsed(0);
467 ci->seek_complete();
468 return 1;
471 ci->set_elapsed(curtime);
472 ci->seek_complete();
475 int32_t *samples = spc_play_get_samples();
477 sampleswritten += WAV_CHUNK_SIZE;
479 /* is track timed? */
480 if (!ci->loop_track() && ci->id3->length) {
481 unsigned long curtime = sampleswritten*1000LL/SAMPLE_RATE;
482 unsigned long lasttimesample = (sampleswritten-WAV_CHUNK_SIZE);
484 /* fade? */
485 if (curtime>ID666.length)
487 #ifdef CPU_COLDFIRE
488 /* Have to switch modes to do this */
489 long macsr = coldfire_get_macsr();
490 coldfire_set_macsr(EMAC_SATURATE | EMAC_FRACTIONAL | EMAC_ROUND);
491 #endif
492 int i;
493 for (i=0;i<WAV_CHUNK_SIZE;i++) {
494 if (lasttimesample+i>fadestartsample) {
495 if (fadevol>0) {
496 samples[i] = FRACMUL(samples[i], fadevol);
497 samples[i+WAV_CHUNK_SIZE] = FRACMUL(samples[i+WAV_CHUNK_SIZE], fadevol);
498 } else samples[i]=samples[i+WAV_CHUNK_SIZE]=0;
499 fadevol-=fadedec;
502 #ifdef CPU_COLDFIRE
503 coldfire_set_macsr(macsr);
504 #endif
506 /* end? */
507 if (lasttimesample>=fadeendsample)
509 samples_release_rdbuf();
510 break;
514 spc_play_send_samples(samples);
516 if (ci->loop_track())
517 ci->set_elapsed(0);
518 else
519 ci->set_elapsed(sampleswritten*1000LL/SAMPLE_RATE);
522 EXIT_TIMER(total);
523 return 0;
526 /* this is the codec entry point */
527 enum codec_status codec_main(enum codec_entry_call_reason reason)
529 if (reason == CODEC_LOAD) {
530 if (!spc_emu_start())
531 return CODEC_ERROR;
533 ci->configure(DSP_SET_SAMPLE_DEPTH, 24);
534 ci->configure(DSP_SET_FREQUENCY, SAMPLE_RATE);
535 ci->configure(DSP_SET_STEREO_MODE, STEREO_NONINTERLEAVED);
537 else if (reason == CODEC_UNLOAD) {
538 spc_emu_quit();
541 return CODEC_OK;
544 /* this is called for each file to process */
545 enum codec_status codec_run(void)
547 DEBUGF("SPC: next_track\n");
548 if (codec_init())
549 return CODEC_ERROR;
550 DEBUGF("SPC: after init\n");
552 codec_set_replaygain(ci->id3);
554 /* Read the entire file */
555 DEBUGF("SPC: request initial buffer\n");
556 ci->seek_buffer(0);
557 size_t buffersize;
558 uint8_t* buffer = ci->request_buffer(&buffersize, ci->filesize);
559 if (!buffer)
560 return CODEC_ERROR;
562 DEBUGF("SPC: read size = 0x%lx\n",(unsigned long)buffersize);
563 ci->set_elapsed(0);
567 if (load_spc_buffer(buffer, buffersize)) {
568 DEBUGF("SPC load failure\n");
569 return CODEC_ERROR;
572 LoadID666(buffer+0x2e);
574 if (!ci->loop_track() && ID666.length==0) {
575 ID666.length=3*60*1000; /* 3 minutes */
576 ID666.fade=5*1000; /* 5 seconds */
579 reset_profile_timers();
581 while ( play_track() );
583 print_timers(ci->id3->path);
585 return CODEC_OK;