1 files changed, 276 insertions, 33 deletions

diff --git a/apps/codecs/spc.c b/apps/codecs/spc.c
index f2890cd4a4..ae3026354d 100644
--- a/apps/codecs/spc.c
+++ b/apps/codecs/spc.c
@@ -185,12 +185,253 @@ static int LoadID666(unsigned char *buf) {
 }
 
 /**************** Codec ****************/
+enum {SAMPLE_RATE = 32000};
+static struct Spc_Emu spc_emu IDATA_ATTR CACHEALIGN_ATTR;
 
-static int32_t samples[WAV_CHUNK_SIZE*2] IBSS_ATTR;
+#if SPC_DUAL_CORE
+/** Implementations for pipelined dual-core operation **/
+static int spc_emu_thread_stack[DEFAULT_STACK_SIZE/sizeof(int)]
+    CACHEALIGN_ATTR;
 
-static struct Spc_Emu spc_emu IDATA_ATTR;
+static const unsigned char * const spc_emu_thread_name = "spc emu";
+static struct thread_entry *emu_thread_p;
 
-enum {SAMPLE_RATE = 32000};
+enum
+{
+    SPC_EMU_AUDIO = 0,
+    SPC_EMU_LOAD,
+    SPC_EMU_QUIT,
+};
+
+struct spc_load
+{
+    uint8_t *buf;
+    size_t size;
+};
+
+/* sample queue */
+#define WAV_NUM_CHUNKS 2
+#define WAV_CHUNK_MASK (WAV_NUM_CHUNKS-1)
+struct sample_queue_chunk
+{
+    long id;
+    union
+    {
+        intptr_t data;
+        int32_t audio[WAV_CHUNK_SIZE*2];
+    };
+};
+
+static struct
+{
+    int head, tail;
+    struct semaphore emu_sem_head;
+    struct semaphore emu_sem_tail;
+    struct event emu_evt_reply;
+    intptr_t retval;
+    struct sample_queue_chunk wav_chunk[WAV_NUM_CHUNKS];
+} sample_queue NOCACHEBSS_ATTR;
+
+static inline void samples_release_wrbuf(void)
+{
+    sample_queue.tail++;
+    ci->semaphore_release(&sample_queue.emu_sem_head);
+}
+
+static inline struct sample_queue_chunk * samples_get_wrbuf(void)
+{
+    ci->semaphore_wait(&sample_queue.emu_sem_tail);
+    return &sample_queue.wav_chunk[sample_queue.tail & WAV_CHUNK_MASK];
+}
+
+static inline void samples_release_rdbuf(void)
+{
+    if (sample_queue.head != sample_queue.tail) {
+        sample_queue.head++;
+    }
+
+    ci->semaphore_release(&sample_queue.emu_sem_tail);
+}
+
+static inline int32_t * samples_get_rdbuf(void)
+{
+    ci->semaphore_wait(&sample_queue.emu_sem_head);
+
+    if (ci->stop_codec || ci->new_track)
+    {
+        /* Told to stop. Buffer must be released. */
+        samples_release_rdbuf();
+        return NULL;
+    }
+
+    return sample_queue.wav_chunk[sample_queue.head & WAV_CHUNK_MASK].audio;
+}
+
+static intptr_t emu_thread_send_msg(long id, intptr_t data)
+{
+    struct sample_queue_chunk *chunk;
+    /* Grab an audio output buffer */
+    ci->semaphore_wait(&sample_queue.emu_sem_head);
+    chunk = &sample_queue.wav_chunk[sample_queue.head & WAV_CHUNK_MASK];
+    /* Place a message in it instead of audio */
+    chunk->id = id;
+    chunk->data = data;
+    /* Release it to the emu thread */
+    samples_release_rdbuf();
+    /* Wait for a response */
+    ci->event_wait(&sample_queue.emu_evt_reply, STATE_SIGNALED);
+    return sample_queue.retval;    
+}
+
+/* thread function */
+static bool emu_thread_process_msg(struct sample_queue_chunk *chunk)
+{
+    long id = chunk->id;
+    bool ret = id != SPC_EMU_QUIT;
+
+    chunk->id = SPC_EMU_AUDIO; /* Reset chunk type to audio */
+    sample_queue.retval = 0;
+
+    if (id == SPC_EMU_LOAD)
+    {
+        struct spc_load *ld = (struct spc_load *)chunk->data;
+        invalidate_icache();
+        SPC_Init(&spc_emu);
+        sample_queue.retval = SPC_load_spc(&spc_emu, ld->buf, ld->size);
+    }
+
+    /* Empty the audio queue */
+    /* This is a dirty hack a timeout based wait would make unnescessary but
+       still safe because the other thread is known to be waiting for a reply
+       and is not using the objects. */
+    ci->semaphore_init(&sample_queue.emu_sem_tail, 2, 2);
+    ci->semaphore_init(&sample_queue.emu_sem_head, 2, 0);
+    sample_queue.head = sample_queue.tail = 0;
+    ci->event_set_state(&sample_queue.emu_evt_reply, STATE_SIGNALED);
+
+    return ret;
+}
+
+static void spc_emu_thread(void)
+{
+    CPU_Init(&spc_emu);
+
+    while (1) {
+        /* get a buffer for output */
+        struct sample_queue_chunk *chunk = samples_get_wrbuf();
+
+        if (chunk->id != SPC_EMU_AUDIO) {
+            /* This chunk doesn't contain audio but a command */
+            if (!emu_thread_process_msg(chunk))
+                break;
+            /* Have to re-get this pointer to keep semaphore counts correct */
+            continue;
+        }
+
+        ENTER_TIMER(render);
+        /* fill samples buffer */
+        if ( SPC_play(&spc_emu, WAV_CHUNK_SIZE*2, chunk->audio) )
+            assert( false );
+        EXIT_TIMER(render);
+
+        /* done so release it to output */
+        samples_release_wrbuf();
+        ci->yield();
+    }
+}
+
+static bool spc_emu_start(void)
+{
+    emu_thread_p = ci->create_thread(spc_emu_thread, spc_emu_thread_stack,
+                           sizeof(spc_emu_thread_stack), CREATE_THREAD_FROZEN,
+                           spc_emu_thread_name IF_PRIO(, PRIORITY_PLAYBACK), COP);
+
+    if (emu_thread_p == NULL)
+        return false;
+
+    /* Initialize audio queue as full to prevent emu thread from trying to run the
+       emulator before loading something */
+    ci->event_init(&sample_queue.emu_evt_reply,
+                   EVENT_AUTOMATIC | STATE_NONSIGNALED);
+    ci->semaphore_init(&sample_queue.emu_sem_tail, 2, 0);
+    ci->semaphore_init(&sample_queue.emu_sem_head, 2, 2);
+    sample_queue.head = 0;
+    sample_queue.tail = 2;
+
+    /* Start it running */
+    ci->thread_thaw(emu_thread_p);
+    return true;
+}
+
+/* load a new program on the emu thread */
+static inline int load_spc_buffer(uint8_t *buf, size_t size)
+{
+    struct spc_load ld = { buf, size };
+    flush_icache();
+    return emu_thread_send_msg(SPC_EMU_LOAD, (intptr_t)&ld);
+}
+
+static inline void spc_emu_quit(void)
+{
+    emu_thread_send_msg(SPC_EMU_QUIT, 0);
+    /* Wait for emu thread to be killed */
+    ci->thread_wait(emu_thread_p);
+}
+
+static inline bool spc_play_get_samples(int32_t **samples)
+{
+    /* obtain filled samples buffer */
+    *samples = samples_get_rdbuf();
+    return *samples != NULL;
+}
+
+static inline void spc_play_send_samples(int32_t *samples)
+{
+    ci->pcmbuf_insert(samples, samples+WAV_CHUNK_SIZE, WAV_CHUNK_SIZE);
+    /* done with chunk so release it to emu thread */
+    samples_release_rdbuf();
+}
+
+#else /* !SPC_DUAL_CORE */
+/** Implementations for single-core operation **/
+int32_t wav_chunk[WAV_CHUNK_SIZE*2] IBSS_ATTR;
+
+/* load a new program into emu */
+static inline int load_spc_buffer(uint8_t *buf, size_t size)
+{
+    SPC_Init(&spc_emu);
+    return SPC_load_spc(&spc_emu, buf, size);
+}
+
+static inline bool spc_emu_start(void)
+{
+#ifdef CPU_COLDFIRE
+    /* signed integer mode with saturation */
+    coldfire_set_macsr(EMAC_SATURATE);
+#endif
+    CPU_Init(&spc_emu);
+    return true;
+}
+
+static inline void spc_play_send_samples(int32_t *samples)
+{
+    ci->pcmbuf_insert(samples, samples+WAV_CHUNK_SIZE, WAV_CHUNK_SIZE);
+}
+
+#define spc_emu_quit()
+#define samples_release_rdbuf()
+
+static inline bool spc_play_get_samples(int32_t **samples)
+{
+    ENTER_TIMER(render);
+    /* fill samples buffer */
+    if ( SPC_play(&spc_emu,WAV_CHUNK_SIZE*2,wav_chunk) )
+        assert( false );
+    EXIT_TIMER(render);
+    *samples = wav_chunk;
+    return true;
+}
+#endif /* SPC_DUAL_CORE */
 
 /* The main decoder loop */
 static int play_track( void )
@@ -206,7 +447,7 @@ static int play_track( void )
         fadedec=0x7fffffffl/(fadeendsample-fadestartsample)+1;
         
     ENTER_TIMER(total);
-    
+
     while ( 1 )
     {
         ci->yield();
@@ -224,14 +465,12 @@ static int play_track( void )
             }
             ci->seek_complete();
         }
-        
-        ENTER_TIMER(render);
-        /* fill samples buffer */
-        if ( SPC_play(&spc_emu,WAV_CHUNK_SIZE*2,samples) )
-            assert( false );
-        EXIT_TIMER(render);
-        
-        sampleswritten+=WAV_CHUNK_SIZE;
+
+        int32_t *samples;
+        if (!spc_play_get_samples(&samples))
+            break;
+
+        sampleswritten += WAV_CHUNK_SIZE;
 
         /* is track timed? */
         if (ci->global_settings->repeat_mode!=REPEAT_ONE && ci->id3->length) {
@@ -241,11 +480,11 @@ static int play_track( void )
             /* fade? */
             if (curtime>ID666.length)
             {
-#ifdef CPU_COLDFIRE
+            #ifdef CPU_COLDFIRE
                 /* Have to switch modes to do this */
                 long macsr = coldfire_get_macsr();
                 coldfire_set_macsr(EMAC_SATURATE | EMAC_FRACTIONAL | EMAC_ROUND);
-#endif
+            #endif
                 int i;
                 for (i=0;i<WAV_CHUNK_SIZE;i++) {
                     if (lasttimesample+i>fadestartsample) {
@@ -256,42 +495,43 @@ static int play_track( void )
                         fadevol-=fadedec;
                     }
                 }
-#ifdef CPU_COLDFIRE
+            #ifdef CPU_COLDFIRE
                coldfire_set_macsr(macsr);
-#endif
+            #endif
             }
             /* end? */
             if (lasttimesample>=fadeendsample)
+            {
+                samples_release_rdbuf();
                 break;
+            }
         }
 
-        ci->pcmbuf_insert(samples, samples+WAV_CHUNK_SIZE, WAV_CHUNK_SIZE);
+        spc_play_send_samples(samples);
 
         if (ci->global_settings->repeat_mode!=REPEAT_ONE)
-        ci->set_elapsed(sampleswritten*1000LL/SAMPLE_RATE);
+            ci->set_elapsed(sampleswritten*1000LL/SAMPLE_RATE);
         else
             ci->set_elapsed(0);
     }
     
     EXIT_TIMER(total);
-    
     return 0;
 }
 
 /* this is the codec entry point */
 enum codec_status codec_main(void)
 {
-#ifdef CPU_COLDFIRE
-    /* signed integer mode with saturation */
-    coldfire_set_macsr(EMAC_SATURATE);
-#endif
-    CPU_Init(&spc_emu);
+    enum codec_status stat = CODEC_ERROR;
+
+    if (!spc_emu_start())
+        goto codec_quit;
 
     do
     {
         DEBUGF("SPC: next_track\n");
         if (codec_init()) {
-            return CODEC_ERROR;
+            goto codec_quit;
         }
         DEBUGF("SPC: after init\n");
 
@@ -301,7 +541,7 @@ enum codec_status codec_main(void)
 
         /* wait for track info to load */
         while (!*ci->taginfo_ready && !ci->stop_codec)
-            ci->sleep(1);
+            ci->yield();
 
         codec_set_replaygain(ci->id3);
 
@@ -313,20 +553,19 @@ enum codec_status codec_main(void)
         size_t buffersize;
         uint8_t* buffer = ci->request_buffer(&buffersize, ci->filesize);
         if (!buffer) {
-            return CODEC_ERROR;
+            goto codec_quit;
         }
 
         DEBUGF("SPC: read size = 0x%lx\n",(unsigned long)buffersize);
         do
         {
-            SPC_Init(&spc_emu);
-            if (SPC_load_spc(&spc_emu,buffer,buffersize)) {
+            if (load_spc_buffer(buffer, buffersize)) {
                 DEBUGF("SPC load failure\n");
-                return CODEC_ERROR;
+                goto codec_quit;
             }
 
             LoadID666(buffer+0x2e);
-            
+
             if (ci->global_settings->repeat_mode!=REPEAT_ONE && ID666.length==0) {
                 ID666.length=3*60*1000; /* 3 minutes */
                 ID666.fade=5*1000; /* 5 seconds */
@@ -340,12 +579,16 @@ enum codec_status codec_main(void)
 
             reset_profile_timers();
         }
-        
         while ( play_track() );
 
         print_timers(ci->id3->path);
     }
     while ( ci->request_next_track() );
+
+    stat = CODEC_OK;
+
+codec_quit:
+    spc_emu_quit();
     
-    return CODEC_OK;
+    return stat;
 }