diff --git a/sm64.ld b/sm64.ld
index e251d49663..cf6acafd50 100755
--- a/sm64.ld
+++ b/sm64.ld
@@ -190,6 +190,8 @@ SECTIONS
       /* data */
       BUILD_DIR/asm/n64_assert.o(.*data*);
       BUILD_DIR/src/boot*.o(.*data*);
+      BUILD_DIR/src/hvqm*.o(.*data*);
+      BUILD_DIR/src/usb*.o(.*data*);
       BUILD_DIR/src/audio*.o(.*data*);
 #ifdef S2DEX_TEXT_ENGINE
       BUILD_DIR/src/s2d_engine*.o(.*data*);
@@ -208,6 +210,7 @@ SECTIONS
       /* rodata */
       BUILD_DIR/src/boot*.o(.rodata*);
       BUILD_DIR/src/usb*.o(.rodata*);
+      BUILD_DIR/src/hvqm*.o(.rodata*);
       BUILD_DIR/src/audio*.o(.rodata*);
 #ifdef S2DEX_TEXT_ENGINE
       BUILD_DIR/src/s2d_engine*.o(.rodata*);
diff --git a/src/game/game_init.c b/src/game/game_init.c
index 443eb9c5b0..c573861b77 100644
--- a/src/game/game_init.c
+++ b/src/game/game_init.c
@@ -802,6 +802,10 @@ void setup_game_memory(void) {
     load_segment_decompress(SEGMENT_SEGMENT2, _segment2_mio0SegmentRomStart, _segment2_mio0SegmentRomEnd);
 }
 
+
+
+extern struct SPTask *sCurrentDisplaySPTask;
+
 /**
  * Main game loop thread. Runs forever as long as the game continues.
  */
@@ -858,7 +862,9 @@ void thread5_game_loop(UNUSED void *arg) {
         read_controller_inputs(THREAD_5_GAME_LOOP);
         profiler_update(PROFILER_TIME_CONTROLLERS, 0);
         profiler_collision_reset();
+
         addr = level_script_execute(addr);
+
         profiler_collision_completed();
 #if !defined(PUPPYPRINT_DEBUG) && defined(VISUAL_DEBUG)
         debug_box_input();
@@ -875,12 +881,6 @@ void thread5_game_loop(UNUSED void *arg) {
             // amount of free space remaining.
             print_text_fmt_int(180, 20, "BUF %d", gGfxPoolEnd - (u8 *) gDisplayListHead);
         }
-#endif
-#if 0
-        if (gPlayer1Controller->buttonPressed & L_TRIG) {
-            osStartThread(&hvqmThread);
-            osRecvMesg(&gDmaMesgQueue, NULL, OS_MESG_BLOCK);
-        }
 #endif
     }
 }
diff --git a/src/game/sound_init.c b/src/game/sound_init.c
index 3172073109..d0942fadb4 100644
--- a/src/game/sound_init.c
+++ b/src/game/sound_init.c
@@ -19,6 +19,10 @@
 #include "puppyprint.h"
 #include "profiling.h"
 
+#ifdef HVQM
+#include <hvqm/hvqm.h>
+#endif
+
 #include "config/config_audio.h"
 
 #define MUSIC_NONE 0xFFFF
@@ -373,7 +377,11 @@ void thread4_sound(UNUSED void *arg) {
 
         osRecvMesg(&sSoundMesgQueue, &msg, OS_MESG_BLOCK);
         profiler_audio_started(); // also starts PROFILER_TIME_SUB_AUDIO_UPDATE inside
+#ifdef HVQM
+        if (gResetTimer < 25 && gHvqmPlayState == 0) {
+#else
         if (gResetTimer < 25) {
+#endif
             struct SPTask *spTask = create_next_audio_frame_task();
             if (spTask != NULL) {
                 dispatch_audio_sptask(spTask);
diff --git a/src/hvqm/cfbkeep.c b/src/hvqm/cfbkeep.c
index fdebe79e42..14df5cb588 100644
--- a/src/hvqm/cfbkeep.c
+++ b/src/hvqm/cfbkeep.c
@@ -13,6 +13,7 @@
 #include <HVQM2File.h>
 #include "hvqm.h"
 #include "buffers/framebuffers.h"
+#include "game/debug.h"
 
 /***********************************************************************
  * Array maintaining the state of the frame buffer
@@ -98,12 +99,15 @@ int
 get_cfb()
 {
   int cfbno;
+  int loop_count = 0;
 
   for ( ; ; ) {
     for ( cfbno = 0; cfbno < NUM_CFBs; cfbno++ )
       if ( cfb_status[cfbno] == 0 )
 	return cfbno;
     osYieldThread();
+    loop_count++;
+    aggress(loop_count < 1000000, "HVQM: get_cfb: all framebuffers busy for too long");
   }
 }
 
diff --git a/src/hvqm/hvqm.c b/src/hvqm/hvqm.c
index 3719606bd9..038dae97f8 100644
--- a/src/hvqm/hvqm.c
+++ b/src/hvqm/hvqm.c
@@ -4,34 +4,37 @@
 #include <buffers/buffers.h>
 #include <hvqm2dec.h>
 #include <adpcmdec.h>
+#include <audio/load.h>
 #include "hvqm.h"
 
+extern OSMesgQueue gIntrMesgQueue;
+
 #define AUDIO_DMA_MSG_SIZE 1
-static OSIoMesg     audioDmaMesgBlock;
-static OSMesgQueue  audioDmaMessageQ;
-static OSMesg       audioDmaMessages[AUDIO_DMA_MSG_SIZE];
+static OSIoMesg audioDmaMesgBlock;
+static OSMesgQueue audioDmaMessageQ;
+static OSMesg audioDmaMessages[AUDIO_DMA_MSG_SIZE];
 
 /***********************************************************************
- *    Message queue for receiving message blocks and end of DMA 
- * notifications when requesting that video records be read from 
+ *    Message queue for receiving message blocks and end of DMA
+ * notifications when requesting that video records be read from
  * the HVQM2 data (ROM).
  ***********************************************************************/
-#define  VIDEO_DMA_MSG_SIZE  1
-static OSIoMesg     videoDmaMesgBlock;
-static OSMesgQueue  videoDmaMessageQ;
-static OSMesg       videoDmaMessages[VIDEO_DMA_MSG_SIZE];
+#define VIDEO_DMA_MSG_SIZE 1
+static OSIoMesg videoDmaMesgBlock;
+static OSMesgQueue videoDmaMessageQ;
+static OSMesg videoDmaMessages[VIDEO_DMA_MSG_SIZE];
 
 /***********************************************************************
  * SP event (SP task end) message queue
  ***********************************************************************/
-static OSMesgQueue  spMesgQ;
-static OSMesg       spMesgBuf;
+static OSMesgQueue spMesgQ;
+static OSMesg spMesgBuf;
 
 /***********************************************************************
  * RSP task data and parameter for the HVQM2 microcode
  ***********************************************************************/
-OSTask hvqtask;			/* RSP task data */
-HVQM2Arg hvq_sparg;		/* Parameter for the HVQM2 microcode */
+OSTask hvqtask;     /* RSP task data */
+HVQM2Arg hvq_sparg; /* Parameter for the HVQM2 microcode */
 
 /***********************************************************************
  * Buffer for the HVQM2 header ***********************************************************************/
@@ -40,199 +43,227 @@ u8 hvqm_headerBuf[sizeof(HVQM2Header) + 16];
 /***********************************************************************
  * Other data
  ***********************************************************************/
-static u32 total_frames;	/* Total number of video records (frames) */
-static u32 total_audio_records;	/* Total number of audio records */
-static void *video_streamP;	/* Video record read-in pointer */
-static void *audio_streamP;	/* Audio record read-in pointer */
-static u32 audio_remain;	/* Counter for remaining number of audio records to read */
-static u32 video_remain;	/* Counter for remaining number of video records to read */
-static u64 disptime;		/* Counter for scheduled display time of next video frame */
-static ADPCMstate adpcm_state;	/* Buffer for state information passed to the ADPCM decoder */
+static u32 total_frames;        /* Total number of video records (frames) */
+static u32 total_audio_records; /* Total number of audio records */
+static void *video_streamP;     /* Video record read-in pointer */
+static void *audio_streamP;     /* Audio record read-in pointer */
+static u32 audio_remain;        /* Counter for remaining number of audio records to read */
+static u32 video_remain;        /* Counter for remaining number of video records to read */
+static u64 disptime;            /* Counter for scheduled display time of next video frame */
+static ADPCMstate adpcm_state;  /* Buffer for state information passed to the ADPCM decoder */
 
 /*
- * Macro for loading multi-byte data from buffer holding data from stream 
+ * Macro for loading multi-byte data from buffer holding data from stream
+ *
+ * NOTE: Original macros had conflicts, so directly dereference properly
  */
-#define load32(from) (*(u32*)&(from))
-#define load16(from) (*(u16*)&(from))
+#undef load32
+#undef load16
+#define load32(from) (*(u32 *) &(from))
+#define load16(from) (*(u16 *) &(from))
 
 extern u8 _capcomSegmentRomStart[];
 extern u8 _seinSegmentRomStart[];
 
-static u32 next_audio_record( void *pcmbuf ) {
-  ALIGNED16 u8 header_buffer[sizeof(HVQM2Record)+16];
-  HVQM2Record *record_header;
-  HVQM2Audio *audio_headerP;
-  u32 samples;
+static u8 *gHvqmRomStart;
+
+static u32 next_audio_record(void *pcmbuf) {
+    ALIGNED16 u8 header_buffer[sizeof(HVQM2Record) + 16];
+    HVQM2Record *record_header;
+    HVQM2Audio *audio_headerP;
+    u32 samples;
 
-  if ( audio_remain == 0 ) return 0;
+    if (audio_remain == 0)
+        return 0;
 
-  record_header = OS_DCACHE_ROUNDUP_ADDR(header_buffer);
-  audio_streamP = get_record(record_header, adpcmbuf, HVQM2_AUDIO, audio_streamP, &audioDmaMesgBlock, &audioDmaMessageQ);
-  --audio_remain;
+    record_header = OS_DCACHE_ROUNDUP_ADDR(header_buffer);
+    audio_streamP = get_record(record_header, adpcmbuf, HVQM2_AUDIO, audio_streamP, &audioDmaMesgBlock,
+                               &audioDmaMessageQ);
+    --audio_remain;
 
-  audio_headerP = (HVQM2Audio *)adpcmbuf;
-  samples = load32(audio_headerP->samples);
-  adpcmDecode(&audio_headerP[1], (u32)load16(record_header->format), samples, pcmbuf, 1, &adpcm_state);
+    audio_headerP = (HVQM2Audio *) adpcmbuf;
+    samples = load32(audio_headerP->samples);
+    adpcmDecode(&audio_headerP[1], (u32) load16(record_header->format), samples, pcmbuf, 1,
+                &adpcm_state);
 
-  return samples;
+    return samples;
 }
 
-static tkAudioProc rewind( void ) {
-  video_streamP = audio_streamP = (u32)_capcomSegmentRomStart + sizeof(HVQM2Header);
-  audio_remain = total_audio_records;
-  video_remain = total_frames;
-  disptime = 0;
-  return &next_audio_record;
+static tkAudioProc rewind(void) {
+    video_streamP = audio_streamP = gHvqmRomStart + sizeof(HVQM2Header);
+    audio_remain = total_audio_records;
+    video_remain = total_frames;
+    disptime = 0;
+    return &next_audio_record;
 }
 
 HVQM2Header *hvqm_header;
 
-static OSMesgQueue   hvqmMesgQ;
-static OSMesg        hvqmMesgBuf;
+OSMesgQueue hvqmMesgQ;
+OSMesg hvqmMesgBuf;
 
 OSThread hvqmThread;
-static u64 hvqmStack[STACKSIZE/sizeof(u64)];
+static u64 hvqmStack[STACKSIZE / sizeof(u64)];
+
+OSMesgQueue gHvqmDoneQueue;
+static OSMesg gHvqmDoneMesgBuf;
+volatile s32 gHvqmPlayState = 0;
 
 void hvqm_main_proc() {
-    int h_offset, v_offset;	/* Position of image display */
-    int screen_offset;		/* Number of pixels from start of frame buffer to display position */
+    int h_offset, v_offset; /* Position of image display */
+    int screen_offset;      /* Number of pixels from start of frame buffer to display position */
     u32 usec_per_frame;
-    int prev_bufno = -1;
-
-    
-    hvqm_header = OS_DCACHE_ROUNDUP_ADDR( hvqm_headerBuf );
-    
-    osCreateMesgQueue( &spMesgQ, &spMesgBuf, 1 );
-    osSetEventMesg( OS_EVENT_SP, &spMesgQ, NULL );
-    
-    osCreateMesgQueue( &audioDmaMessageQ, audioDmaMessages, AUDIO_DMA_MSG_SIZE );
-    osCreateMesgQueue( &videoDmaMessageQ, videoDmaMessages, VIDEO_DMA_MSG_SIZE );
+    int prev_bufno;
+
+    osCreateMesgQueue(&spMesgQ, &spMesgBuf, 1);
+
+    osCreateMesgQueue(&audioDmaMessageQ, audioDmaMessages, AUDIO_DMA_MSG_SIZE);
+    osCreateMesgQueue(&videoDmaMessageQ, videoDmaMessages, VIDEO_DMA_MSG_SIZE);
     createTimekeeper();
-    
+
     hvqm2InitSP1(0xff);
-    hvqtask.t.ucode = (u64 *)hvqm2sp1TextStart;
-    hvqtask.t.ucode_size = (int)hvqm2sp1TextEnd - (int)hvqm2sp1TextStart;
-    hvqtask.t.ucode_data = (u64 *)hvqm2sp1DataStart;
+    hvqtask.t.ucode = (u64 *) hvqm2sp1TextStart;
+    hvqtask.t.ucode_size = (int) hvqm2sp1TextEnd - (int) hvqm2sp1TextStart;
+    hvqtask.t.ucode_data = (u64 *) hvqm2sp1DataStart;
     hvqtask.t.type = M_HVQM2TASK;
     hvqtask.t.flags = 0;
-    hvqtask.t.ucode_boot = (u64 *)rspbootTextStart;
-    hvqtask.t.ucode_boot_size = (int)rspbootTextEnd - (int)rspbootTextStart;
+    hvqtask.t.ucode_boot = (u64 *) rspbootTextStart;
+    hvqtask.t.ucode_boot_size = (int) rspbootTextEnd - (int) rspbootTextStart;
     hvqtask.t.ucode_data_size = HVQM2_UCODE_DATA_SIZE;
-    hvqtask.t.data_ptr = (u64 *)&hvq_sparg;
-    hvqtask.t.yield_data_ptr = (u64 *)hvq_yieldbuf;
+    hvqtask.t.data_ptr = (u64 *) &hvq_sparg;
+    hvqtask.t.yield_data_ptr = (u64 *) hvq_yieldbuf;
     hvqtask.t.yield_data_size = HVQM2_YIELD_DATA_SIZE;
 
-    init_cfb();
-    osViSwapBuffer( gFramebuffers[NUM_CFBs-1] );
+    for (;;) {
+        OSMesg start_msg;
+        osRecvMesg(&hvqmMesgQ, &start_msg, OS_MESG_BLOCK);
+
+        gHvqmRomStart = (u8 *) start_msg;
+
+        osSetEventMesg(OS_EVENT_SP, &spMesgQ, NULL);
+
+        hvqm_header = OS_DCACHE_ROUNDUP_ADDR(hvqm_headerBuf);
+        init_cfb();
+        osViSwapBuffer(gFramebuffers[NUM_CFBs - 1]);
+
+        romcpy(hvqm_header, (void *) gHvqmRomStart, sizeof(HVQM2Header), OS_MESG_PRI_NORMAL,
+               &videoDmaMesgBlock, &videoDmaMessageQ);
+
+        total_frames = load32(hvqm_header->total_frames);
+        usec_per_frame = load32(hvqm_header->usec_per_frame);
+        total_audio_records = load32(hvqm_header->total_audio_records);
+
+        h_offset = (SCREEN_WD - load16(hvqm_header->width)) / 2;
+        v_offset = (SCREEN_HT - load16(hvqm_header->height)) / 2;
+        screen_offset = v_offset * SCREEN_WD + h_offset;
+
+        hvqm2SetupSP1(hvqm_header, SCREEN_WD);
 
-    romcpy(hvqm_header, (void *)_capcomSegmentRomStart, sizeof(HVQM2Header), OS_MESG_PRI_NORMAL, &videoDmaMesgBlock, &videoDmaMessageQ);
+        release_all_cfb();
+        tkStart(&rewind, load32(hvqm_header->samples_per_sec));
 
-    total_frames = load32(hvqm_header->total_frames);
-    usec_per_frame = load32(hvqm_header->usec_per_frame);
-    total_audio_records = load32(hvqm_header->total_audio_records);
-    
-    hvqm2SetupSP1(hvqm_header, SCREEN_WD);
-    
-    release_all_cfb();
-    tkStart( &rewind, load32( hvqm_header->samples_per_sec ) );
-    
-    for ( ; ; ) {
+        prev_bufno = -1;
 
-        //while ( video_remain > 0 ) {
-            u8 header_buffer[sizeof(HVQM2Record)+16];
+        while (video_remain > 0) {
+            u8 header_buffer[sizeof(HVQM2Record) + 16];
             HVQM2Record *record_header;
             u16 frame_format;
             int bufno;
-            OSMesg msg;
 
-            if ( disptime > 0 && tkGetTime() > 0) {
-                if ( tkGetTime() < (disptime - (usec_per_frame * 2)) ) {
-                   tkPushVideoframe( gFramebuffers[prev_bufno], &cfb_status[prev_bufno], disptime );
-                   continue;
-                  //if ( video_remain == 0 ) break;
+            if (disptime > 0 && tkGetTime() > 0) {
+                if (tkGetTime() < (disptime - (usec_per_frame * 2))) {
+                    osYieldThread();
+                    continue;
                 }
             }
-            
-            record_header = OS_DCACHE_ROUNDUP_ADDR( header_buffer );
-            
-            video_streamP = get_record(record_header, hvqbuf, 
-                        HVQM2_VIDEO, video_streamP, 
-                        &videoDmaMesgBlock, &videoDmaMessageQ);
-                        
-            //! SYNC VIDEO code
-
-            if ( disptime > 0 && tkGetTime() > 0) {
-                if ( tkGetTime() > (disptime + (usec_per_frame * 2)) ) {
-                  release_all_cfb();
-                  do {
-                    disptime += usec_per_frame;
-                    if ( --video_remain == 0 ) break;
-                    video_streamP = get_record( record_header, hvqbuf, 
-				    HVQM2_VIDEO, video_streamP, 
-				    &videoDmaMesgBlock, &videoDmaMessageQ );
-                  } while (load16( record_header->format ) != HVQM2_VIDEO_KEYFRAME || tkGetTime() > disptime );
-                  if ( video_remain == 0 ) break;
+
+            record_header = OS_DCACHE_ROUNDUP_ADDR(header_buffer);
+
+            video_streamP = get_record(record_header, hvqbuf, HVQM2_VIDEO, video_streamP,
+                                       &videoDmaMesgBlock, &videoDmaMessageQ);
+
+            if (disptime > 0 && tkGetTime() > 0) {
+                if (tkGetTime() > (disptime + (usec_per_frame * 2))) {
+                    release_all_cfb();
+                    do {
+                        disptime += usec_per_frame;
+                        if (--video_remain == 0)
+                            break;
+                        video_streamP = get_record(record_header, hvqbuf, HVQM2_VIDEO, video_streamP,
+                                                   &videoDmaMesgBlock, &videoDmaMessageQ);
+                    } while (load16(record_header->format) != HVQM2_VIDEO_KEYFRAME
+                             || tkGetTime() > disptime);
+                    if (video_remain == 0)
+                        break;
                 }
             }
-            
+
             frame_format = load16(record_header->format);
             if (frame_format == HVQM2_VIDEO_HOLD) {
-                /*
-                 *   Just like when frame_format != HVQM2_VIDEO_HOLD you 
-                     * could call hvqm2Decode*() and decode in a new frame
-                     * buffer (in this case, just copying from the buffer of
-                     * the preceding frame).  But here we make use of the
-                     * preceding frame's buffer for the next frame in order
-                     * to speed up the process.
-                 */
                 bufno = prev_bufno;
             } else {
                 int status;
                 bufno = get_cfb(); /* Get the frame buffer */
 
-                /*
-                 * Process first half in the CPU
-                 */
                 hvqtask.t.flags = 0;
-                status = hvqm2DecodeSP1( hvqbuf, frame_format, 
-                           &gFramebuffers[bufno][screen_offset], 
-                           &gFramebuffers[prev_bufno][screen_offset], 
-                           hvqwork, &hvq_sparg, hvq_spfifo );
+                status = hvqm2DecodeSP1(hvqbuf, frame_format, &gFramebuffers[bufno][screen_offset],
+                                        &gFramebuffers[prev_bufno][screen_offset], hvqwork, &hvq_sparg,
+                                        hvq_spfifo);
 
                 osWritebackDCacheAll();
 
-                /*
-                 * Process last half in the RSP
-                 */
-                if ( status > 0 ) {
-                    osInvalDCache( (void *)gFramebuffers[bufno], sizeof gFramebuffers[bufno] );
-                    osSpTaskStart( &hvqtask );
-                    osRecvMesg( &spMesgQ, NULL, OS_MESG_BLOCK );
+                if (status > 0) {
+                    osInvalDCache((void *) gFramebuffers[bufno], sizeof gFramebuffers[bufno]);
+                    osSpTaskStart(&hvqtask);
+                    osRecvMesg(&spMesgQ, NULL, OS_MESG_BLOCK);
                 }
             }
-        
-        keep_cfb( bufno );
-        
-        if ( prev_bufno >= 0 && prev_bufno != bufno ) 
-          release_cfb( prev_bufno );
-
-        tkPushVideoframe( gFramebuffers[bufno], &cfb_status[bufno], disptime );
-
-        prev_bufno = bufno;
-        disptime += usec_per_frame;
-        --video_remain;
-        
-        //if (1) {
-            //osAiSetFrequency(gAudioSessionPresets.frequency);
-            //osSendMesg(&gDmaMesgQueue, 0, OS_MESG_BLOCK);
-            //osDestroyThread(&hvqmMesgQ);
-        //}
+
+            keep_cfb(bufno);
+
+            if (prev_bufno >= 0 && prev_bufno != bufno)
+                release_cfb(prev_bufno);
+
+            tkPushVideoframe(gFramebuffers[bufno], &cfb_status[bufno], disptime);
+
+            prev_bufno = bufno;
+            disptime += usec_per_frame;
+            --video_remain;
+        }
+
+        tkStop();
+        osSetEventMesg(OS_EVENT_SP, &gIntrMesgQueue, (OSMesg) 100);
+        osAiSetFrequency(gAiFrequency);
+        osSendMesg(&gHvqmDoneQueue, (OSMesg) 1, OS_MESG_NOBLOCK);
     }
 }
 
 void createHvqmThread(void) {
-  osCreateMesgQueue( &hvqmMesgQ, &hvqmMesgBuf, 1 );
-  osCreateThread( &hvqmThread, HVQM_THREAD_ID, hvqm_main_proc, 
-		 NULL, hvqmStack + (STACKSIZE/sizeof(u64)), 
-		 (OSPri)HVQM_PRIORITY );
+    osCreateMesgQueue(&hvqmMesgQ, &hvqmMesgBuf, 1);
+    osCreateMesgQueue(&gHvqmDoneQueue, &gHvqmDoneMesgBuf, 1);
+    osCreateThread(&hvqmThread, HVQM_THREAD_ID, hvqm_main_proc, NULL,
+                   hvqmStack + (STACKSIZE / sizeof(u64)), (OSPri) HVQM_PRIORITY);
+    osStartThread(&hvqmThread);
+}
+
+extern struct SPTask *sCurrentDisplaySPTask;
+extern OSMesgQueue gGfxVblankQueue;
+extern OSMesg gMainReceivedMesg;
+extern void turn_off_audio(void);
+extern void turn_on_audio(void);
+
+void play_hvqm(u8 *romStart) {
+    if (gHvqmPlayState == 0) {
+        gHvqmPlayState = 1;
+        if (sCurrentDisplaySPTask != NULL) {
+            osRecvMesg(&gGfxVblankQueue, &gMainReceivedMesg, OS_MESG_BLOCK);
+        }
+        turn_off_audio();
+        gHvqmPlayState = 2;
+        osSendMesg(&hvqmMesgQ, (OSMesg) romStart, OS_MESG_BLOCK);
+        osRecvMesg(&gHvqmDoneQueue, NULL, OS_MESG_BLOCK);
+        gHvqmPlayState = 0;
+        turn_on_audio();
+        osSendMesg(&gGfxVblankQueue, gMainReceivedMesg, OS_MESG_NOBLOCK);
+    }
 }
diff --git a/src/hvqm/hvqm.h b/src/hvqm/hvqm.h
index ba994c8c01..478bb00a33 100644
--- a/src/hvqm/hvqm.h
+++ b/src/hvqm/hvqm.h
@@ -1,6 +1,9 @@
 #ifndef HVQM_H
 #define HVQM_H
 
+#include <PR/ultratypes.h>
+#include <HVQM2File.h>
+
 
 /*
  * Size of the data area for the HVQ microcode
@@ -114,5 +117,13 @@ int get_cfb();
 typedef u32 (*tkAudioProc)(void *pcmbuf);
 typedef tkAudioProc (*tkRewindProc)(void);
 
+extern OSMesgQueue gHvqmDoneQueue;
+extern OSMesgQueue hvqmMesgQ;
+extern volatile s32 gHvqmPlayState;
+
+extern u8 _capcomSegmentRomStart[];
+#define MOVIE_CAPCOM _capcomSegmentRomStart
+
+void play_hvqm(u8 *romStart);
 
 #endif // HVQM_H
\ No newline at end of file
diff --git a/src/hvqm/timekeeper.c b/src/hvqm/timekeeper.c
index 5cd55f7b3e..1d68e3cb99 100644
--- a/src/hvqm/timekeeper.c
+++ b/src/hvqm/timekeeper.c
@@ -4,108 +4,112 @@
 #include "audio/data.h"
 #include "buffers/framebuffers.h"
 
+extern OSMesgQueue gIntrMesgQueue;
+
 /***********************************************************************
  * Timekeeper thread
  ***********************************************************************/
-static OSThread  tkThread;
-static u64  tkStack[STACKSIZE/sizeof(u64)];
+static OSThread tkThread;
+static u64 tkStack[STACKSIZE / sizeof(u64)];
 
 /***********************************************************************
  * Audio DA counter thread
  ***********************************************************************/
-static OSThread  daCounterThread;
-static u64  daCounterStack[STACKSIZE/sizeof(u64)];
+static OSThread daCounterThread;
+static u64 daCounterStack[STACKSIZE / sizeof(u64)];
 
 /***********************************************************************
  * Timekeeper's command message queue
  ***********************************************************************/
-static OSMesgQueue   tkCmdMesgQ;
-static OSMesg        tkCmdMesgBuf;
+static OSMesgQueue tkCmdMesgQ;
+static OSMesg tkCmdMesgBuf;
 
 /***********************************************************************
  * Message queue for responses from timekeeper
  ***********************************************************************/
-static OSMesgQueue   tkResMesgQ;
-static OSMesg        tkResMesgBuf;
+static OSMesgQueue tkResMesgQ;
+static OSMesg tkResMesgBuf;
 
 /***********************************************************************
  * Timekeeper's command structure
  ***********************************************************************/
 typedef struct {
-  tkRewindProc rewind;		/* Pointer to stream rewind function */
-  u32 samples_per_sec;		/* Audio sampling rate */
+    tkRewindProc rewind; /* Pointer to stream rewind function */
+    u32 samples_per_sec; /* Audio sampling rate */
 } TKCMD;
 
 /***********************************************************************
  * VI event (retrace) message queue
  ***********************************************************************/
-#define  VI_MSG_SIZE  2
-static OSMesgQueue    viMessageQ;
-static OSMesg         viMessages[VI_MSG_SIZE];
+#define VI_MSG_SIZE 2
+static OSMesgQueue viMessageQ;
+static OSMesg viMessages[VI_MSG_SIZE];
 
 /***********************************************************************
  * AI event (FIFO free) message queue
  ***********************************************************************/
-#define  AI_MSG_SIZE  2
-static OSMesgQueue    aiMessageQ;
-static OSMesg         aiMessages[AI_MSG_SIZE];
+#define AI_MSG_SIZE 2
+static OSMesgQueue aiMessageQ;
+static OSMesg aiMessages[AI_MSG_SIZE];
 
 /***********************************************************************
  * Ring buffer for reserving display of image
  *
- *     As soon as image (frame buffer) is complete, put into this 
+ *     As soon as image (frame buffer) is complete, put into this
  *     ring buffer, wait for display time to come and set in VI.
  ***********************************************************************/
-#define  VIDEO_RING_SIZE  NUM_CFBs
+#define VIDEO_RING_SIZE NUM_CFBs
 
 static struct {
-  u64 disptime;			/* Display time */
-  void *vaddr;			/* Frame buffer address */
-  u32 *statP;			/* Pointer to frame buffer state flag */
+    u64 disptime; /* Display time */
+    void *vaddr;  /* Frame buffer address */
+    u32 *statP;   /* Pointer to frame buffer state flag */
 } videoRing[VIDEO_RING_SIZE];
 
-static int  videoRingCount;	/* Amount of data remaining in ring buffer */
-static int  videoRingWrite;	/* Ring buffer write index */
-static int  videoRingRead;	/* Ring buffer read index */
+static int videoRingCount; /* Amount of data remaining in ring buffer */
+static int videoRingWrite; /* Ring buffer write index */
+static int videoRingRead;  /* Ring buffer read index */
 
 /***********************************************************************
  * Ring buffer for reserving playback of audio
- * 
+ *
  *     As soon as audio (PCM data) is complete, put into this
  *     ring buffer and push as soon as AI FIFO is free.
  ***********************************************************************/
-#define  AUDIO_RING_BUFFER_SIZE  NUM_PCMBUFs
+#define AUDIO_RING_BUFFER_SIZE NUM_PCMBUFs
 
 static struct {
-  void *buf;			/* PCM data buffer */
-  u32 len;			/* PCM data length */
+    void *buf; /* PCM data buffer */
+    u32 len;   /* PCM data length */
 } audioRing[AUDIO_RING_BUFFER_SIZE];
 
-static int  audioRingCount;	/* Amount of data remaining in ring buffer */
-static int  audioRingWrite;	/* Ring buffer write index */
-static int  audioRingRead;	/* Ring buffer read index */
+static int audioRingCount; /* Amount of data remaining in ring buffer */
+static int audioRingWrite; /* Ring buffer write index */
+static int audioRingRead;  /* Ring buffer read index */
 
 /***********************************************************************
  * PCM data buffer information
  ***********************************************************************/
-static int  pcmBufferCount;	/* Number of PCM data buffers being used */
-static u32  aiFIFOsamples;	/* Number of PCM samples waiting in AI FIFO */
-static u32  aiDAsamples;	/* Number of samples AI is DMA transferring to DA */
+static int pcmBufferCount; /* Number of PCM data buffers being used */
+static u32 aiFIFOsamples;  /* Number of PCM samples waiting in AI FIFO */
+static u32 aiDAsamples;    /* Number of samples AI is DMA transferring to DA */
 
 /***********************************************************************
- * Buffer for matching PCM transfer data length to PCM_ALIGN 
+ * Buffer for matching PCM transfer data length to PCM_ALIGN
  ***********************************************************************/
-static s16 pcmModBuf[(PCM_ALIGN-1)*PCM_CHANNELS];
+static s16 pcmModBuf[(PCM_ALIGN - 1) * PCM_CHANNELS];
+
+ALIGNED16 static s16 hvqm_pcmbuf[NUM_PCMBUFs][PCMBUF_SIZE];
 
 /***********************************************************************
  * Flag enabling measurement of passage of time
  ***********************************************************************/
-static int  clock_alive;
+static int clock_alive;
 
 /***********************************************************************
  * Audio sampling rate
  ***********************************************************************/
-static u32  samples_per_sec;
+static u32 samples_per_sec;
 
 /***********************************************************************
  * Number of PCM samples that have finished playing
@@ -116,14 +120,14 @@ static u32  samples_per_sec;
  *    From this value you get the amount of time that has passed
  *    since the start of play of the HVQM2 stream.
  ***********************************************************************/
-static u64  samples_played;
+static u64 samples_played;
 
 /***********************************************************************
  * The time samples_played was first updated ( osGetTime() )
  *
  *    Time measured beyond this point is supplemented with osGetTime().
  ***********************************************************************/
-static OSTime  last_time;
+static OSTime last_time;
 
 /***********************************************************************
  *
@@ -133,20 +137,22 @@ static OSTime  last_time;
  *     The time that has passed since the start of HVQM2 movie playback
  *   is calculated back from the number of samples that have finished
  *   playing (samples_played) and the sampling rate (samples_per_sec).
- *     The time after samples_played was first updated is supplemented 
+ *     The time after samples_played was first updated is supplemented
  *   with osGetTime().
  *
  * Returned value
  *     The time that has passed since playback of the HVQM2 movie started
  *
  ***********************************************************************/
-u64 tkGetTime(void){
+u64 tkGetTime(void) {
     u64 retval;
 
-    if (!clock_alive) return 0;
+    if (!clock_alive)
+        return 0;
 
-    retval = OS_CYCLES_TO_USEC((u64)osGetTime() - last_time);
-    if (samples_per_sec) retval += samples_played * 1000000LL / samples_per_sec;
+    retval = OS_CYCLES_TO_USEC((u64) osGetTime() - last_time);
+    if (samples_per_sec)
+        retval += samples_played * 1000000LL / samples_per_sec;
     return retval;
 }
 
@@ -158,9 +164,8 @@ u64 tkGetTime(void){
  *     Disable measurement of time from start of HVQM2 movie playback
  *
  ***********************************************************************/
-static void tkClockDisable(void)
-{
-  clock_alive = 0;
+static void tkClockDisable(void) {
+    clock_alive = 0;
 }
 
 /***********************************************************************
@@ -171,11 +176,10 @@ static void tkClockDisable(void)
  *     Start measurement of time from start of HVQM2 movie playback
  *
  ***********************************************************************/
-static void tkClockStart(void)
-{
-  samples_played = 0;
-  last_time = osGetTime();
-  clock_alive = 1;
+static void tkClockStart(void) {
+    samples_played = 0;
+    last_time = osGetTime();
+    clock_alive = 1;
 }
 
 /***********************************************************************
@@ -185,16 +189,16 @@ static void tkClockStart(void)
  *    Counts the number of audio samples that have finished playing.
  *
  ***********************************************************************/
-static void   daCounterProc(void UNUSED*argument)
-{
-  for ( ; ; ) {
-    osRecvMesg( &aiMessageQ, NULL, OS_MESG_BLOCK );
-    last_time = osGetTime();
-    if ( aiDAsamples > 0 ) --pcmBufferCount;
-    samples_played += aiDAsamples;
-    aiDAsamples = aiFIFOsamples;
-    aiFIFOsamples = 0;
-  }
+static void daCounterProc(void UNUSED *argument) {
+    for (;;) {
+        osRecvMesg(&aiMessageQ, NULL, OS_MESG_BLOCK);
+        last_time = osGetTime();
+        if (aiDAsamples > 0)
+            --pcmBufferCount;
+        samples_played += aiDAsamples;
+        aiDAsamples = aiFIFOsamples;
+        aiFIFOsamples = 0;
+    }
 }
 
 /***********************************************************************
@@ -205,211 +209,214 @@ static void   daCounterProc(void UNUSED*argument)
  *   completed frame buffers, displaying them at the scheduled times.
  *
  ***********************************************************************/
-static void timekeeperProc(void UNUSED*argument) {
+static void timekeeperProc(void UNUSED *argument) {
     TKCMD *cmd;
-    void *showing_cfb = NULL;	/* Frame buffer being displayed */
+    void *showing_cfb = NULL;      /* Frame buffer being displayed */
     u32 *showing_cfb_statP = NULL; /* Pointer to state flag of the frame buffer being displayed */
-    s32 video_started;		/* Flag indicating start of video display */
-    s32 audio_started;		/* Flag indicating start of audio playback */
-    s32 video_done;		/* Flag indicating end of video decoding */
-    s32 audio_done;		/* Flag indicating end of audio decoding */
-    void *pushed_cfb;		/* Frame buffer reserved for swap */
-    u32 *pushed_cfb_statP;	/* Pointer to state flag of frame buffer reserved for swap */
-    s32 next_pcmbufno;		/* The number of the PCM buffer to use next */
-    s32 pcm_mod_samples;	/* The number of PCM samples left over */
+    s32 video_started;             /* Flag indicating start of video display */
+    s32 audio_started;             /* Flag indicating start of audio playback */
+    s32 video_done;                /* Flag indicating end of video decoding */
+    s32 audio_done;                /* Flag indicating end of audio decoding */
+    void *pushed_cfb;              /* Frame buffer reserved for swap */
+    u32 *pushed_cfb_statP;         /* Pointer to state flag of frame buffer reserved for swap */
+    s32 next_pcmbufno;             /* The number of the PCM buffer to use next */
+    s32 pcm_mod_samples;           /* The number of PCM samples left over */
     tkAudioProc audioproc;
     OSTime present_vtime;
-    
-    /* Acquire retrace event */
-    osCreateMesgQueue( &viMessageQ, viMessages, VI_MSG_SIZE );
-    osViSetEvent( &viMessageQ, 0, 1 );
-
-    /* Acquire AI event*/
-    osCreateMesgQueue( &aiMessageQ, aiMessages, AI_MSG_SIZE );
-    osSetEventMesg( OS_EVENT_AI, &aiMessageQ, (OSMesg *)1 );
-
-  /*
-   * Create and start audio DA counter thread
-   */
-    osCreateThread(&daCounterThread, DA_COUNTER_THREAD_ID, daCounterProc, 
-		 NULL, daCounterStack + (STACKSIZE/sizeof(u64)), 
-		 (OSPri)DA_COUNTER_PRIORITY);
-    osStartThread(&daCounterThread);
-    
-    osRecvMesg(&tkCmdMesgQ, (OSMesg *)&cmd, OS_MESG_BLOCK);
+
+    osCreateMesgQueue(&viMessageQ, viMessages, VI_MSG_SIZE);
+    osCreateMesgQueue(&aiMessageQ, aiMessages, AI_MSG_SIZE);
 
     /*
-     * Wait for movie playback command
+     * Create and start audio DA counter thread
      */
-    while ( cmd == NULL ) {
-      osSendMesg( &tkResMesgQ, NULL, OS_MESG_BLOCK );
-      osRecvMesg( &tkCmdMesgQ, (OSMesg *)&cmd, OS_MESG_BLOCK );
-    }
-    
-    tkClockDisable();
-    audioproc = (cmd->rewind)();
-    
-    samples_per_sec = cmd->samples_per_sec;
-    if (samples_per_sec) osAiSetFrequency(samples_per_sec);
-
-    pcmBufferCount = 0;
-
-    aiDAsamples = 0;
-    aiFIFOsamples = 0;
-
-    audioRingRead = audioRingWrite = 0;
-    audioRingCount = 0;
-
-    videoRingRead = videoRingWrite = 0;
-    videoRingCount = 0;
-
-    video_started = 0;
-    audio_started = 0;
-    video_done = 0;
-    audio_done = 0;
-    pushed_cfb = NULL;
-    pushed_cfb_statP = NULL;
-    next_pcmbufno = 0;
-    pcm_mod_samples = 0;
-
-    osSendMesg( &tkResMesgQ, NULL, OS_MESG_BLOCK ); /* Notification that playback preparations are finished */
-
-    present_vtime = osGetTime();
-    
-    while (!video_done || videoRingCount > 0 || pushed_cfb != NULL ||
-	    !audio_done || audioRingCount > 0 || aiFIFOsamples > 0) {
-        u64 present_time;
-        OSTime last_vtime;
+    osCreateThread(&daCounterThread, DA_COUNTER_THREAD_ID, daCounterProc, NULL,
+                   daCounterStack + (STACKSIZE / sizeof(u64)), (OSPri) DA_COUNTER_PRIORITY);
+    osStartThread(&daCounterThread);
+
+    for (;;) {
+        osRecvMesg(&tkCmdMesgQ, (OSMesg *) &cmd, OS_MESG_BLOCK);
+
         /*
-        * Block until retrace comes
-        */
-        osRecvMesg(&viMessageQ, NULL, OS_MESG_BLOCK);
+         * Wait for movie playback command
+         */
+        while (cmd == NULL) {
+            osSendMesg(&tkResMesgQ, NULL, OS_MESG_BLOCK);
+            osRecvMesg(&tkCmdMesgQ, (OSMesg *) &cmd, OS_MESG_BLOCK);
+        }
+
+        /* hijack vi/ai event only when we start playing! */
+        osViSetEvent(&viMessageQ, 0, 1);
+        osSetEventMesg(OS_EVENT_AI, &aiMessageQ, (OSMesg *) 1);
+
+        tkClockDisable();
+        audioproc = (cmd->rewind)();
+
+        samples_per_sec = cmd->samples_per_sec;
+        if (samples_per_sec)
+            osAiSetFrequency(samples_per_sec);
+
+        pcmBufferCount = 0;
+
+        aiDAsamples = 0;
+        aiFIFOsamples = 0;
+
+        audioRingRead = audioRingWrite = 0;
+        audioRingCount = 0;
+
+        videoRingRead = videoRingWrite = 0;
+        videoRingCount = 0;
+
+        video_started = 0;
+        audio_started = 0;
+        video_done = 0;
+        audio_done = 0;
+        pushed_cfb = NULL;
+        pushed_cfb_statP = NULL;
+        showing_cfb = NULL;
+        showing_cfb_statP = NULL;
+        next_pcmbufno = 0;
+        pcm_mod_samples = 0;
+
+        osSendMesg(&tkResMesgQ, NULL,
+                   OS_MESG_BLOCK); /* Notification that playback preparations are finished */
 
-        last_vtime = present_vtime;
         present_vtime = osGetTime();
-        present_time = tkGetTime() + OS_CYCLES_TO_USEC(present_vtime - last_vtime);
-        
-        if (pushed_cfb != NULL) {
-            /* The display has switched from showing_cfb to pushed_cfb (it should have) */
-            if (!video_started) {
-                /* Display of the first frame has begun (the audio will begin from here) */
-                video_started = 1;
-                if (!audio_started && audio_done) {
-                    audio_started = 1;
-                    tkClockStart();
+
+        while (!video_done || videoRingCount > 0 || pushed_cfb != NULL || !audio_done
+               || audioRingCount > 0 || aiFIFOsamples > 0) {
+            u64 present_time;
+            OSTime last_vtime;
+
+            /*
+             * Block until retrace comes
+             */
+            osRecvMesg(&viMessageQ, NULL, OS_MESG_BLOCK);
+
+            last_vtime = present_vtime;
+            present_vtime = osGetTime();
+            present_time = tkGetTime() + OS_CYCLES_TO_USEC(present_vtime - last_vtime);
+
+            if (pushed_cfb != NULL) {
+                /* The display has switched from showing_cfb to pushed_cfb (it should have) */
+                if (!video_started) {
+                    /* Display of the first frame has begun (the audio will begin from here) */
+                    video_started = 1;
+                    if (!audio_started && audio_done) {
+                        audio_started = 1;
+                        tkClockStart();
+                    }
+                }
+
+                /* Release showing_cfb  */
+                if (showing_cfb_statP != NULL && showing_cfb != pushed_cfb) {
+                    *showing_cfb_statP &= ~CFB_SHOWING;
+                }
+
+                /* Update showing_cfb, pushed_cfb */
+                showing_cfb = pushed_cfb;
+                showing_cfb_statP = pushed_cfb_statP;
+                pushed_cfb = NULL;
+                pushed_cfb_statP = NULL;
+            }
+
+            /*
+             * Push the next frame buffer to the VI
+             */
+            if (video_started || audioRingCount > 0 || audio_done) {
+                while (videoRingCount) {
+                    if (videoRing[videoRingRead].disptime > present_time)
+                        break;
+                    if (pushed_cfb_statP != NULL)
+                        *pushed_cfb_statP &= ~CFB_SHOWING;
+                    pushed_cfb = videoRing[videoRingRead].vaddr;
+                    pushed_cfb_statP = videoRing[videoRingRead].statP;
+                    *pushed_cfb_statP |= CFB_SHOWING;
+                    osViSwapBuffer(pushed_cfb);
+                    if (++videoRingRead == VIDEO_RING_SIZE)
+                        videoRingRead = 0;
+                    --videoRingCount;
+                }
+            }
+
+            /*
+             * Push the next PCM data to the AI
+             */
+            if (video_started) {
+                osSetThreadPri(NULL, (OSPri) (DA_COUNTER_PRIORITY + 1));
+                while (audioRingCount > 0 && aiFIFOsamples == 0) {
+                    void *buffer = audioRing[audioRingRead].buf;
+                    u32 length = audioRing[audioRingRead].len;
+                    if (osAiGetStatus() & AI_STATUS_FIFO_FULL)
+                        break;
+                    if (osAiSetNextBuffer(buffer, length) == -1)
+                        break;
+                    aiFIFOsamples = length >> PCM_BYTES_PER_SAMPLE_SHIFT;
+                    if (!audio_started) {
+                        audio_started = 1;
+                        tkClockStart();
+                    }
+                    if (++audioRingRead == AUDIO_RING_BUFFER_SIZE)
+                        audioRingRead = 0;
+                    --audioRingCount;
                 }
+                osSetThreadPri(NULL, (OSPri) TIMEKEEPER_PRIORITY);
             }
 
-            /* Release showing_cfb  */
-            if (showing_cfb_statP != NULL && showing_cfb != pushed_cfb) {
-                *showing_cfb_statP &= ~CFB_SHOWING;
+            /*
+             * Prepare the next PCM data
+             */
+            if (!audio_done && audioRingCount < AUDIO_RING_BUFFER_SIZE
+                && pcmBufferCount < NUM_PCMBUFs) {
+                u32 samples;
+                u32 length;
+                void *buffer;
+                s16 *sp, *dp;
+                int i;
+
+                samples = audioproc(&hvqm_pcmbuf[next_pcmbufno][pcm_mod_samples << PCM_CHANNELS_SHIFT]);
+
+                if (samples > 0) {
+                    ++pcmBufferCount;
+
+                    sp = pcmModBuf;
+                    dp = (s16 *) ((u8 *) hvqm_pcmbuf[next_pcmbufno]);
+                    i = pcm_mod_samples << PCM_CHANNELS_SHIFT;
+                    while (i--)
+                        *dp++ = *sp++;
+                    samples += pcm_mod_samples;
+                    samples -= (pcm_mod_samples = samples & (PCM_ALIGN - 1));
+                    length = samples << PCM_BYTES_PER_SAMPLE_SHIFT;
+                    buffer = hvqm_pcmbuf[next_pcmbufno];
+                    osWritebackDCache(buffer, length);
+                    audioRing[audioRingWrite].buf = buffer;
+                    audioRing[audioRingWrite].len = length;
+                    if (++audioRingWrite == AUDIO_RING_BUFFER_SIZE)
+                        audioRingWrite = 0;
+                    ++audioRingCount;
+
+                    sp = (s16 *) ((u8 *) (hvqm_pcmbuf[next_pcmbufno]) + length);
+                    dp = pcmModBuf;
+                    i = pcm_mod_samples << PCM_CHANNELS_SHIFT;
+                    while (i--)
+                        *dp++ = *sp++;
+
+                    if (++next_pcmbufno >= NUM_PCMBUFs)
+                        next_pcmbufno = 0;
+                } else
+                    audio_done = 1;
             }
 
-            /* Update showing_cfb, pushed_cfb */
-            showing_cfb = pushed_cfb;
-            showing_cfb_statP = pushed_cfb_statP;
-            pushed_cfb = NULL;
-            pushed_cfb_statP = NULL;
+            if (osRecvMesg(&tkCmdMesgQ, (OSMesg *) &cmd, OS_MESG_NOBLOCK) == 0) {
+                video_done = 1;
+            }
         }
-        
-	/*
-	 * Push the next frame buffer to the VI
-	 *
-	 *     Before the start of video display (video_started == 0), 
-	 *   wait until audio data is prepared for playback
-         *   (audioRingCount > 0).
-	 */
-	if ( video_started || audioRingCount > 0 || audio_done ) {
-	  while ( videoRingCount ) {
-	    if ( videoRing[videoRingRead].disptime > present_time ) break;
-	    if ( pushed_cfb_statP != NULL ) *pushed_cfb_statP &= ~CFB_SHOWING;
-	    pushed_cfb = videoRing[videoRingRead].vaddr;
-	    pushed_cfb_statP = videoRing[videoRingRead].statP;
-	    *pushed_cfb_statP |= CFB_SHOWING;
-	    osViSwapBuffer( pushed_cfb );
-	    if ( ++videoRingRead == VIDEO_RING_SIZE ) videoRingRead = 0;
-	    --videoRingCount;
-	  }
-	}
-        
-	/*
-	 * Push the next PCM data to the AI
-	 *
-	 *      Before the start of video display (video_started == 0) 
-	 *    wait until the display of the first image frame 
-         *    has begun (video_started == 1).
-	 */
-	if ( video_started ) {
-	  osSetThreadPri( NULL, (OSPri)(DA_COUNTER_PRIORITY + 1) );
-	  while ( audioRingCount > 0 && aiFIFOsamples == 0 ) {
-	    void *buffer = audioRing[audioRingRead].buf;
-	    u32   length = audioRing[audioRingRead].len;
-	    if ( osAiGetStatus() & AI_STATUS_FIFO_FULL ) break;
-	    if ( osAiSetNextBuffer( buffer, length ) == -1 ) break;
-	    aiFIFOsamples = length >> PCM_BYTES_PER_SAMPLE_SHIFT;
-	    if ( ! audio_started ) {
-	      /*
-	       * Audio playback has begun.
-	       * Here the time count starts to synchronize audio and video
-	       */
-	      audio_started = 1;
-	      tkClockStart();
-	    }
-	    if ( ++audioRingRead == AUDIO_RING_BUFFER_SIZE ) audioRingRead = 0;
-	    --audioRingCount;
-	  }
-	  osSetThreadPri( NULL, (OSPri)TIMEKEEPER_PRIORITY );
-	}
-	/*
-	 * Prepare the next PCM data
-	 */
-	if ( ! audio_done && audioRingCount < AUDIO_RING_BUFFER_SIZE && pcmBufferCount < NUM_PCMBUFs ) {
-	  u32 samples;
-	  u32 length;
-	  void *buffer;
-	  s16 *sp, *dp;
-	  int i;
-
-	  samples = audioproc( &gAiBuffers[next_pcmbufno][pcm_mod_samples<<PCM_CHANNELS_SHIFT] );
-
-	  if ( samples > 0 ) {
-	    ++pcmBufferCount;
-
-	    sp = pcmModBuf;
-	    dp = (s16 *)((u8 *)gAiBuffers[next_pcmbufno]);
-	    i = pcm_mod_samples << PCM_CHANNELS_SHIFT;
-	    while ( i-- ) *dp++ = *sp++;
-	    samples += pcm_mod_samples;
-	    samples -= (pcm_mod_samples = samples & (PCM_ALIGN-1));
-	    length = samples << PCM_BYTES_PER_SAMPLE_SHIFT;
-	    buffer = gAiBuffers[next_pcmbufno];
-	    osWritebackDCache( buffer, length );
-	    audioRing[audioRingWrite].buf = buffer;
-	    audioRing[audioRingWrite].len = length;
-	    if ( ++audioRingWrite == AUDIO_RING_BUFFER_SIZE ) audioRingWrite = 0;
-	    ++audioRingCount;
-
-	    sp = (s16 *)((u8 *)(gAiBuffers[next_pcmbufno]) + length);
-	    dp = pcmModBuf;
-	    i = pcm_mod_samples << PCM_CHANNELS_SHIFT;
-	    while ( i-- ) *dp++ = *sp++;
-
-	    if ( ++next_pcmbufno >= NUM_PCMBUFs ) next_pcmbufno = 0;
-	  }
-	  else audio_done = 1;
-	}
-        
-	if ( osRecvMesg( &tkCmdMesgQ, (OSMesg *)&cmd, OS_MESG_NOBLOCK ) == 0 )
-	  {
-	    /*
-	     * tkStop() or tkStart() has been executed
-	     * 
-	     *     Set 1 in video_done and end this playback loop
-             *   after playback of the current movie's video and 
-	     *   and audio has completely finished.
-	     */
-	    video_done = 1;
-	  }
+
+        /* restore vi vblank event back to the game! */
+        osViSetEvent(&gIntrMesgQueue, (OSMesg) 102, 1);
+
+        /* notify tkResMesgQ that we are stopped! */
+        osSendMesg(&tkResMesgQ, NULL, OS_MESG_BLOCK);
     }
 }
 
@@ -421,15 +428,12 @@ static void timekeeperProc(void UNUSED*argument) {
  *     Creates and starts the timekeeper thread
  *
  ***********************************************************************/
-void
-createTimekeeper(void)
-{
-  osCreateMesgQueue( &tkCmdMesgQ, &tkCmdMesgBuf, 1 );
-  osCreateMesgQueue( &tkResMesgQ, &tkResMesgBuf, 1 );
-  osCreateThread( &tkThread, TIMEKEEPER_THREAD_ID, timekeeperProc, 
-		 NULL, tkStack + (STACKSIZE/sizeof(u64)), 
-		 (OSPri)TIMEKEEPER_PRIORITY );
-  osStartThread( &tkThread );
+void createTimekeeper(void) {
+    osCreateMesgQueue(&tkCmdMesgQ, &tkCmdMesgBuf, 1);
+    osCreateMesgQueue(&tkResMesgQ, &tkResMesgBuf, 1);
+    osCreateThread(&tkThread, TIMEKEEPER_THREAD_ID, timekeeperProc, NULL,
+                   tkStack + (STACKSIZE / sizeof(u64)), (OSPri) TIMEKEEPER_PRIORITY);
+    osStartThread(&tkThread);
 }
 
 /***********************************************************************
@@ -443,21 +447,19 @@ createTimekeeper(void)
  *    Directs the timekeeper to play a new movie.  Playback of the
  *  movie starts after callback of "rewind" by the timekeeper.  After
  *  this, the HVQM2 video records are read and decoded and the
- *  completed frame buffers are handed over to the timekeeper by 
+ *  completed frame buffers are handed over to the timekeeper by
  *  tkPushVideoframe() in succession to play the video part of the movie.
- *  As for the audio, the timekeeper itself calls the callback 
+ *  As for the audio, the timekeeper itself calls the callback
  *  function (the value returned by rewind) that gets the PCM data as
  *  needed to playback the audio.
  *
  ***********************************************************************/
-void
-tkStart( tkRewindProc rewind, u32 samples_per_sec )
-{
-  TKCMD tkcmd;
-  tkcmd.samples_per_sec = samples_per_sec;
-  tkcmd.rewind = rewind;
-  osSendMesg( &tkCmdMesgQ, (OSMesg *)&tkcmd, OS_MESG_BLOCK );
-  osRecvMesg( &tkResMesgQ, (OSMesg *)NULL, OS_MESG_BLOCK );
+void tkStart(tkRewindProc rewind, u32 samples_per_sec) {
+    TKCMD tkcmd;
+    tkcmd.samples_per_sec = samples_per_sec;
+    tkcmd.rewind = rewind;
+    osSendMesg(&tkCmdMesgQ, (OSMesg *) &tkcmd, OS_MESG_BLOCK);
+    osRecvMesg(&tkResMesgQ, (OSMesg *) NULL, OS_MESG_BLOCK);
 }
 
 /***********************************************************************
@@ -475,17 +477,15 @@ tkStart( tkRewindProc rewind, u32 samples_per_sec )
  *  to execute tkStart() without executing tkStop().
  *
  ***********************************************************************/
-void
-tkStop( void )
-{
-  osSendMesg( &tkCmdMesgQ, (OSMesg *)NULL, OS_MESG_BLOCK );
-  osRecvMesg( &tkResMesgQ, (OSMesg *)NULL, OS_MESG_BLOCK );
+void tkStop(void) {
+    osSendMesg(&tkCmdMesgQ, (OSMesg *) NULL, OS_MESG_BLOCK);
+    osRecvMesg(&tkResMesgQ, (OSMesg *) NULL, OS_MESG_BLOCK);
 }
 
 /***********************************************************************
  *
  * void tkPushVideoframe(void *vaddr, u32 *statP, u64 disptime)
- * 
+ *
  * Argument
  *     vaddr     Frame buffer address
  *     statP     Pointer to state flag data regarding vaddr
@@ -496,22 +496,22 @@ tkStop( void )
  *  The timekeeper displays the frame buffer after waiting for the
  *  "disptime" amount of time to pass from the start of the movie.
  *
- *    To wait for the display of the vaddr frame buffer or to 
- *  indicate that something is being displayed, the CFB_SHOWING 
+ *    To wait for the display of the vaddr frame buffer or to
+ *  indicate that something is being displayed, the CFB_SHOWING
  *  flag is set in the u32 type data pointed to by the statP pointer.
  *  At the time when display of vaddr is finished, (once its display
  *  is over and display has switched to another frame buffer) this
  *  flag is cleared by the timekeeper.
  *
  ***********************************************************************/
-void
-tkPushVideoframe( void *vaddr, u32 *statP, u64 disptime )
-{
-  *statP |= CFB_SHOWING;
-  while ( videoRingCount >= VIDEO_RING_SIZE ) osYieldThread();
-  videoRing[videoRingWrite].disptime = disptime;
-  videoRing[videoRingWrite].vaddr = vaddr;
-  videoRing[videoRingWrite].statP = statP;
-  if ( ++videoRingWrite == VIDEO_RING_SIZE ) videoRingWrite = 0;
-  ++videoRingCount;
+void tkPushVideoframe(void *vaddr, u32 *statP, u64 disptime) {
+    *statP |= CFB_SHOWING;
+    while (videoRingCount >= VIDEO_RING_SIZE)
+        osYieldThread();
+    videoRing[videoRingWrite].disptime = disptime;
+    videoRing[videoRingWrite].vaddr = vaddr;
+    videoRing[videoRingWrite].statP = statP;
+    if (++videoRingWrite == VIDEO_RING_SIZE)
+        videoRingWrite = 0;
+    ++videoRingCount;
 }
diff --git a/src/usb/debug.h b/src/usb/debug.h
index 674241bae1..a6c2bb0f1d 100644
--- a/src/usb/debug.h
+++ b/src/usb/debug.h
@@ -14,7 +14,7 @@
     #define DEBUG_INIT_MSG    1   // Print a message when debug mode has initialized
     #define AUTOPOLL_ENABLED  0   // Automatically poll the USB on a timer
     #define AUTOPOLL_TIME     200 // Time (in milliseconds) between auto polls
-    #define USE_FAULTTHREAD   1   // Create a fault detection thread (libultra only)
+    #define USE_FAULTTHREAD   0   // Create a fault detection thread (libultra only)
     #define USE_RDBTHREAD     0   // Create a remote debugger thread
     // #define OVERWRITE_OSPRINT 1   // Replaces osSyncPrintf calls with debug_printf (defined in makefile - libultra_rom does not have osSyncPrintf)
     #define MAX_COMMANDS      25  // The max amount of user defined commands possible