mirror of
https://github.com/thug1src/thug.git
synced 2024-12-02 21:07:12 +00:00
1656 lines
46 KiB
C
1656 lines
46 KiB
C
/* Vag streaming into SPU2 -- from sony sample -- matt may 2001 */
|
|
|
|
#include <kernel.h>
|
|
#include <sys/types.h>
|
|
#include <sys/file.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <sif.h>
|
|
#include <sifcmd.h>
|
|
#include <sifrpc.h>
|
|
#include <libsd.h>
|
|
#include <thread.h>
|
|
#include "pcm.h"
|
|
#include "pcmiop.h"
|
|
|
|
// ================================================================
|
|
#define DATA_INTEGRITY_CHECK 1
|
|
|
|
#define SHOW_STATE 0
|
|
#define SHOW_SMALL_STATE 1
|
|
#define SHOW_ACTION 0
|
|
#define SHOW_SMALL_ACTION 1
|
|
#define DBUGPRINTF 0
|
|
#define SHOW_TIMING 1
|
|
#define SHOW_STOP 1
|
|
#define SHOW_SMALL_COMMANDS 1
|
|
|
|
#if SHOW_SMALL_COMMANDS
|
|
#define ShowSmallCommand printf
|
|
#else
|
|
#define ShowSmallCommand( x )
|
|
#endif
|
|
|
|
#if SHOW_STOP
|
|
#define ShowStop printf //printf( " %d}{", GetTime( ) ), printf
|
|
#else
|
|
#define ShowStop( x )
|
|
#endif
|
|
|
|
#if SHOW_TIMING
|
|
#define ShowTime printf
|
|
#else
|
|
#define ShowTime DoNothing
|
|
void DoNothing( char* text, ... ) { }
|
|
#endif
|
|
|
|
#if SHOW_ACTION
|
|
#define ShowAction printf( "Time %d", GetTime( ) ), printf
|
|
#else
|
|
#define ShowAction( x )
|
|
#endif
|
|
|
|
#if SHOW_SMALL_STATE
|
|
#define SmallShowState printf
|
|
#else
|
|
#define SmallShowState( x )
|
|
#endif
|
|
|
|
#if SHOW_SMALL_ACTION
|
|
#define SmallShowAction printf( " %d*", GetTime( ) ), printf
|
|
#else
|
|
#define SmallShowAction( x )
|
|
#endif
|
|
|
|
#if SHOW_STATE
|
|
#define ShowState printf( "Time %d ", GetTime( ) ), printf
|
|
#else
|
|
#define ShowState( x )
|
|
#endif
|
|
|
|
#if DBUGPRINTF
|
|
#define Dbug_Printf( x ) printf( x )
|
|
#else
|
|
#define Dbug_Printf( x )
|
|
#endif
|
|
|
|
//volatile int gTestPause = 0;
|
|
|
|
#define SHARE_DMA_CH 0
|
|
|
|
// the program running on the EE side will check to see if any of the buffers need to be filled:
|
|
volatile unsigned int gEECommand = 0;
|
|
|
|
#if SHARE_DMA_CH
|
|
#define TRANS_DMA_CH_COMMON 0
|
|
#define TRANS_DMA_CH_MUSIC TRANS_DMA_CH_COMMON
|
|
#define TRANS_DMA_CH_STREAM TRANS_DMA_CH_COMMON
|
|
|
|
enum{
|
|
LOAD_STATUS_IDLE = 0,
|
|
LOAD_STATUS_LOADING_MUSIC = ( 1 << 0 ),
|
|
LOAD_STATUS_LOADING_STREAM = ( 1 << 1 ),
|
|
LOAD_STATUS_NEED_MUSIC = ( 1 << 2 ),
|
|
LOAD_STATUS_NEED_STREAM = ( 1 << 3 ),
|
|
};
|
|
|
|
volatile unsigned int gLoadStatus = LOAD_STATUS_IDLE;
|
|
|
|
#else
|
|
#define TRANS_DMA_CH_MUSIC 1
|
|
#define TRANS_DMA_CH_STREAM 0
|
|
#endif
|
|
|
|
|
|
#define _1st 0
|
|
#define _2nd 1
|
|
|
|
#define DEFAULT_PITCH 0x1000
|
|
|
|
unsigned int gThid = 0;
|
|
unsigned int gSem = 0;
|
|
unsigned int gpIopBuf; // IOP SMEM
|
|
unsigned int gMusicIopOffset;
|
|
unsigned int gStreamIopOffset;
|
|
|
|
enum{
|
|
MUSIC_LOAD_STATE_IDLE,
|
|
MUSIC_LOAD_STATE_PRELOADING_L,
|
|
MUSIC_LOAD_STATE_PRELOADING_R,
|
|
MUSIC_LOAD_STATE_WAITING_FOR_IRQ,
|
|
MUSIC_LOAD_STATE_LOADING_L,
|
|
MUSIC_LOAD_STATE_LOADING_R,
|
|
};
|
|
|
|
volatile unsigned int gMusicPaused = 0;
|
|
volatile unsigned int gStreamPaused = 0;
|
|
volatile unsigned int gStreamTimeOffset = 0; // when paused, keep track of time passed since last IRQ
|
|
volatile unsigned int gMusicTimeOffset = 0; // when paused, keep track of time passed since last IRQ
|
|
|
|
#define RF_START_MUSIC ( 1 << 0 )
|
|
#define RF_START_STREAM ( 1 << 1 )
|
|
#define RF_UNPAUSE_MUSIC ( 1 << 2 )
|
|
#define RF_UNPAUSE_STREAM ( 1 << 3 )
|
|
|
|
volatile unsigned int gRequestFlags = 0;
|
|
|
|
volatile unsigned int gTimeOfLastMusicUpdate = 0;
|
|
volatile unsigned int gTimeOfLastStreamUpdate = 0;
|
|
|
|
volatile unsigned int gMusicBufSide = _1st;
|
|
volatile unsigned int gMusicTransSize = 0;
|
|
volatile unsigned int gMusicLoadState = MUSIC_LOAD_STATE_IDLE;
|
|
volatile unsigned int gMusicVolume;
|
|
volatile unsigned int gMusicVolumeSet = 0;
|
|
volatile unsigned int gMusicStop = 0;
|
|
volatile unsigned int gMusicStatus = EzADPCM_STATUS_IDLE;
|
|
volatile unsigned int gUpdateMusic = 0;
|
|
volatile unsigned int gMusicSize;
|
|
volatile unsigned int gMusicRemaining;
|
|
|
|
enum{
|
|
STREAM_LOAD_STATE_IDLE,
|
|
STREAM_LOAD_STATE_PRELOADING,
|
|
STREAM_LOAD_STATE_WAITING_FOR_IRQ,
|
|
STREAM_LOAD_STATE_LOADING,
|
|
};
|
|
|
|
|
|
volatile unsigned int gStreamBufSide = _1st;
|
|
volatile unsigned int gStreamTransSize = 0;
|
|
volatile unsigned int gStreamLoadState = STREAM_LOAD_STATE_IDLE;
|
|
volatile unsigned int gStreamVolume;
|
|
volatile unsigned int gStreamVolumeSet = 0;
|
|
volatile unsigned int gStreamStop = 0;
|
|
volatile unsigned int gStreamStatus = EzADPCM_STATUS_IDLE;
|
|
volatile unsigned int gUpdateStream = 0;
|
|
volatile unsigned int gStreamSize;
|
|
volatile unsigned int gStreamRemaining;
|
|
|
|
int _AdpcmPlay( int status );
|
|
|
|
#if SHARE_DMA_CH
|
|
static int _AdpcmDmaIntCommon( int, void* );
|
|
#else
|
|
static int _AdpcmDmaIntMusic( int, void* );
|
|
static int _AdpcmDmaIntStream( int, void* );
|
|
#endif
|
|
static int _AdpcmSpu2Int( int, void * );
|
|
|
|
#define _L 0
|
|
#define _R 1
|
|
#define _Lch(x) ((x >> 16) & 0xffff)
|
|
#define _Rch(x) (x & 0xffff)
|
|
|
|
unsigned int GetTime( void )
|
|
{
|
|
unsigned int sex, usex, msex;
|
|
struct SysClock sysClock;
|
|
GetSystemTime( &sysClock );
|
|
SysClock2USec( &sysClock, &sex, &usex );
|
|
msex = ( sex * 1000 ) + ( usex / 1000 );
|
|
return ( msex );
|
|
}
|
|
|
|
// EzADPCM_SDINIT
|
|
void AdpcmSdInit( void )
|
|
{
|
|
sceSdInit (0);
|
|
|
|
// Disk media: DVD
|
|
// Output format: PCM
|
|
// Copy guard: normal (one generation recordable / default)
|
|
sceSdSetCoreAttr (SD_C_SPDIF_MODE, (SD_SPDIF_MEDIA_DVD |
|
|
SD_SPDIF_OUT_PCM |
|
|
SD_SPDIF_COPY_NORMAL));
|
|
return;
|
|
}
|
|
|
|
void AdpcmSetUpVoice( int core, int vnum, int pSpuBuf )
|
|
{
|
|
sceSdSetParam ( core | ( vnum << 1 ) | SD_VP_VOLL, 0 );
|
|
sceSdSetParam ( core | ( vnum << 1 ) | SD_VP_VOLR, 0 );
|
|
sceSdSetParam ( core | ( vnum << 1 ) | SD_VP_PITCH, DEFAULT_PITCH );
|
|
sceSdSetParam ( core | ( vnum << 1 ) | SD_VP_ADSR1, 0x000f );
|
|
sceSdSetParam ( core | ( vnum << 1 ) | SD_VP_ADSR2, 0x1fc0 );
|
|
sceSdSetAddr ( core | ( vnum << 1 ) | SD_VA_SSA, pSpuBuf );
|
|
return;
|
|
}
|
|
|
|
/*const char StrayVoiceData[ STRAY_VOICE_BLOCKER_SIZE ] =
|
|
{
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x0C, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x0C, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x0C, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x0C, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x0C, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x0C, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x0C, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
};*/
|
|
|
|
// EzADPCM_INIT
|
|
int AdpcmInit( int pIopBuf )
|
|
{
|
|
if ( gEECommand & PCMSTATUS_INITIALIZED )
|
|
{
|
|
return ( 0 );
|
|
}
|
|
|
|
if ( gSem == 0 )
|
|
{
|
|
struct SemaParam sem;
|
|
sem.initCount = 0;
|
|
sem.maxCount = 1;
|
|
sem.attr = AT_THFIFO;
|
|
gSem = CreateSema (&sem);
|
|
}
|
|
if (gThid == 0)
|
|
{
|
|
struct ThreadParam param;
|
|
param.attr = TH_C;
|
|
param.entry = _AdpcmPlay;
|
|
param.initPriority = 5;// BASE_priority-3;
|
|
param.stackSize = 0x800; // was 800
|
|
param.option = 0;
|
|
gThid = CreateThread (¶m);
|
|
printf( "EzADPCM: create thread ID= %d\n", gThid );
|
|
StartThread (gThid, (u_long) NULL);
|
|
}
|
|
|
|
/*
|
|
// This data represents an empty looping sound...
|
|
// The voices wandering across SPU ram will get
|
|
// stuck here, so as not to trigger the interrupts
|
|
// reserved for the stream and music voices and shit.
|
|
strcpy( ( char * )pIopBuf, StrayVoiceData );
|
|
// send that to the SPU ram:
|
|
sceSdVoiceTrans( 0, ( SD_TRANS_MODE_WRITE | SD_TRANS_BY_DMA ),
|
|
(unsigned char *) pIopBuf, STRAY_VOICE_BLOCKER_SPU_ADDR, STRAY_VOICE_BLOCKER_SIZE );
|
|
sceSdVoiceTransStatus( 0, SD_TRANS_STATUS_WAIT );*/
|
|
|
|
#if SHARE_DMA_CH
|
|
sceSdSetTransIntrHandler( TRANS_DMA_CH_COMMON, ( sceSdTransIntrHandler ) _AdpcmDmaIntCommon, ( void * ) &gSem );
|
|
#else
|
|
sceSdSetTransIntrHandler( TRANS_DMA_CH_MUSIC, ( sceSdTransIntrHandler ) _AdpcmDmaIntMusic, ( void * ) &gSem );
|
|
sceSdSetTransIntrHandler( TRANS_DMA_CH_STREAM, ( sceSdTransIntrHandler ) _AdpcmDmaIntStream, ( void * ) &gSem );
|
|
#endif
|
|
sceSdSetSpu2IntrHandler( ( sceSdSpu2IntrHandler ) _AdpcmSpu2Int, ( void * ) &gSem );
|
|
|
|
AdpcmSetUpVoice( MUSIC_CORE, MUSIC_L_VOICE, MUSIC_L_SPU_BUF_LOC );
|
|
AdpcmSetUpVoice( MUSIC_CORE, MUSIC_R_VOICE, MUSIC_R_SPU_BUF_LOC );
|
|
AdpcmSetUpVoice( STREAM_CORE, STREAM_VOICE, STREAM_SPU_BUF_LOC );
|
|
|
|
gpIopBuf = pIopBuf;
|
|
gEECommand |= PCMSTATUS_INITIALIZED;
|
|
//printf( "PCM Irx iop buf %d\n", gpIopBuf );
|
|
//Dbug_Printf( "PCM irx is initialized\n" );
|
|
return gThid;
|
|
}
|
|
|
|
// EzADPCM_QUIT
|
|
void AdpcmQuit( void )
|
|
{
|
|
DeleteThread (gThid);
|
|
gThid = 0;
|
|
#if 0
|
|
DeleteSema (gSem);
|
|
gSem = 0;
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
// EzADPCM_PLAYMUSIC
|
|
int AdpcmPlayMusic( int size )
|
|
{
|
|
extern void AdpcmSetMusicVolumeDirect( unsigned int );
|
|
|
|
if ( gMusicStatus != EzADPCM_STATUS_IDLE )
|
|
{
|
|
ShowAction( "NOTE NOTE NOTE NOTE Can't play music -- music isn't in Idle state.\n" );
|
|
return -1;
|
|
}
|
|
|
|
AdpcmSetMusicVolumeDirect( gMusicVolume );
|
|
|
|
gMusicStatus = EzADPCM_STATUS_PRELOAD;
|
|
gMusicLoadState = MUSIC_LOAD_STATE_IDLE;
|
|
gMusicSize = size;
|
|
gMusicTimeOffset = 0;
|
|
if ( gMusicSize < 64 )
|
|
{
|
|
gMusicSize = 64;
|
|
}
|
|
gEECommand &= ~( PCMSTATUS_NEED_MUSIC_BUFFER_0 | PCMSTATUS_NEED_MUSIC_BUFFER_1 );
|
|
gEECommand |= PCMSTATUS_MUSIC_PLAYING;
|
|
|
|
// stagger the two streams so there are no IRQ or DMA interrupt conflicts:
|
|
gRequestFlags |= RF_START_MUSIC;
|
|
return 0;
|
|
}
|
|
|
|
// EzADPCM_PLAYSTREAM
|
|
int AdpcmPlayStream( int size )
|
|
{
|
|
extern void AdpcmSetStreamVolumeDirect( unsigned int );
|
|
|
|
if ( gStreamStatus != EzADPCM_STATUS_IDLE )
|
|
{
|
|
printf( "trying to play stream when stream already playing!\n" );
|
|
return -1;
|
|
}
|
|
|
|
AdpcmSetStreamVolumeDirect( gStreamVolume );
|
|
|
|
gStreamStatus = EzADPCM_STATUS_PRELOAD;
|
|
gStreamSize = size;
|
|
if ( gStreamSize < 64 )
|
|
{
|
|
gStreamSize = 64;
|
|
}
|
|
gStreamLoadState = STREAM_LOAD_STATE_IDLE;
|
|
gEECommand &= ~( PCMSTATUS_NEED_STREAM_BUFFER_0 | PCMSTATUS_NEED_STREAM_BUFFER_1 );
|
|
gEECommand |= PCMSTATUS_STREAM_PLAYING;
|
|
gStreamTimeOffset = 0;
|
|
gRequestFlags = RF_START_STREAM;
|
|
ShowAction( "Requesting stream start\n" );
|
|
SmallShowAction( "-rsb" );
|
|
return 0;
|
|
}
|
|
|
|
/* internal */
|
|
void _AdpcmSetMusicVoiceMute( void )
|
|
{
|
|
sceSdSetParam ( MUSIC_CORE | ( MUSIC_L_VOICE << 1) | SD_VP_VOLL, 0);
|
|
sceSdSetParam ( MUSIC_CORE | ( MUSIC_L_VOICE << 1) | SD_VP_VOLR, 0);
|
|
sceSdSetParam ( MUSIC_CORE | ( MUSIC_R_VOICE << 1) | SD_VP_VOLL, 0);
|
|
sceSdSetParam ( MUSIC_CORE | ( MUSIC_R_VOICE << 1) | SD_VP_VOLR, 0);
|
|
return;
|
|
}
|
|
|
|
/* internal */
|
|
void _AdpcmSetStreamVoiceMute( void )
|
|
{
|
|
sceSdSetParam( STREAM_CORE | ( STREAM_VOICE << 1) | SD_VP_VOLL, 0);
|
|
sceSdSetParam( STREAM_CORE | ( STREAM_VOICE << 1) | SD_VP_VOLR, 0);
|
|
return;
|
|
}
|
|
|
|
void StopMusic( void )
|
|
{
|
|
sceSdSetCoreAttr( MUSIC_CORE | SD_C_IRQ_ENABLE, 0 );
|
|
gMusicStatus = EzADPCM_STATUS_IDLE;
|
|
gEECommand &= ~( PCMSTATUS_MUSIC_PLAYING | PCMSTATUS_NEED_MUSIC_BUFFER_0 | PCMSTATUS_NEED_MUSIC_BUFFER_1 );
|
|
_AdpcmSetMusicVoiceMute( );
|
|
sceSdSetSwitch( MUSIC_CORE | SD_S_KOFF, ( 1 << MUSIC_L_VOICE ) );
|
|
sceSdSetSwitch( MUSIC_CORE | SD_S_KOFF, ( 1 << MUSIC_R_VOICE ) );
|
|
ShowAction( "Stopping music\n" );
|
|
SmallShowAction( "-!sm!" );
|
|
}
|
|
|
|
void StopStream( void )
|
|
{
|
|
sceSdSetCoreAttr( STREAM_CORE | SD_C_IRQ_ENABLE, 0 );
|
|
gStreamStatus = EzADPCM_STATUS_IDLE;
|
|
gEECommand &= ~( PCMSTATUS_STREAM_PLAYING | PCMSTATUS_NEED_STREAM_BUFFER_0 | PCMSTATUS_NEED_STREAM_BUFFER_1 );
|
|
_AdpcmSetStreamVoiceMute( );
|
|
sceSdSetSwitch( STREAM_CORE | SD_S_KOFF, ( 1 << STREAM_VOICE ) );
|
|
ShowAction( "Stopping stream\n" );
|
|
SmallShowAction( "-!ss!" );
|
|
}
|
|
|
|
#define NUM_WAIT_CLICKS 25000
|
|
|
|
// EzADPCM_STOPMUSIC
|
|
int AdpcmStopMusic( void )
|
|
{
|
|
int i;
|
|
int j = 0;
|
|
|
|
if ( gMusicStatus != EzADPCM_STATUS_IDLE )
|
|
{
|
|
if ( gRequestFlags & RF_START_MUSIC )
|
|
{
|
|
gRequestFlags &= ~RF_START_MUSIC;
|
|
gMusicStatus = EzADPCM_STATUS_IDLE;
|
|
ShowAction( "Supressing music request\n" );
|
|
SmallShowAction( "-smr" );
|
|
}
|
|
else if ( gMusicPaused )
|
|
{
|
|
// if loading is happening, wait then just stop:
|
|
ShowStop( "stop music %d", GetTime( ) );
|
|
while ( gMusicLoadState != MUSIC_LOAD_STATE_WAITING_FOR_IRQ )
|
|
{
|
|
for ( i = 0; i < NUM_WAIT_CLICKS; i++ )
|
|
;
|
|
j++;
|
|
if ( j > NUM_WAIT_CLICKS )
|
|
{
|
|
j = 0;
|
|
ShowStop( "." );
|
|
}
|
|
}
|
|
// ShowStop( "\n" );
|
|
ShowAction( "Stopped paused music\n" );
|
|
SmallShowAction( "-spm" );
|
|
StopMusic( );
|
|
}
|
|
else
|
|
{
|
|
ShowStop( " %d-stopmusic", GetTime( ) );
|
|
gMusicStop++;
|
|
while ( gMusicStatus != EzADPCM_STATUS_IDLE )
|
|
{
|
|
for ( i = 0; i < NUM_WAIT_CLICKS; i++ )
|
|
;
|
|
if ( j++ > NUM_WAIT_CLICKS )
|
|
{
|
|
j = 0;
|
|
ShowStop( "." );
|
|
//printf( " ms %d mls %d rf %d eecom %d\n", gMusicStatus, gMusicLoadState, gRequestFlags, gEECommand );
|
|
}
|
|
}
|
|
//ShowStop( "\n" );
|
|
}
|
|
gEECommand &= ~ ( PCMSTATUS_MUSIC_PLAYING | PCMSTATUS_NEED_MUSIC_BUFFER_0 | PCMSTATUS_NEED_MUSIC_BUFFER_1 );
|
|
return ( 1 );
|
|
}
|
|
return ( 0 );
|
|
}
|
|
|
|
// EzADPCM_STOPSTREAM
|
|
int AdpcmStopStream( void )
|
|
{
|
|
int i;
|
|
int j = 0;
|
|
|
|
if ( gStreamStatus != EzADPCM_STATUS_IDLE )
|
|
{
|
|
if ( gRequestFlags & RF_START_STREAM )
|
|
{
|
|
gRequestFlags &= ~RF_START_STREAM;
|
|
gStreamStatus = EzADPCM_STATUS_IDLE;
|
|
ShowAction( "Supressing stream request\n" );
|
|
SmallShowAction( "-ssr" );
|
|
}
|
|
else if ( gStreamPaused )
|
|
{
|
|
// if loading is happening, wait then just stop:
|
|
ShowStop( " %d-Stop p stream", GetTime( ) );
|
|
while ( gStreamLoadState != STREAM_LOAD_STATE_WAITING_FOR_IRQ )
|
|
{
|
|
for ( i = 0; i < NUM_WAIT_CLICKS; i++ )
|
|
;
|
|
ShowStop( "." );
|
|
}
|
|
//ShowStop( "\n" );
|
|
StopStream( );
|
|
}
|
|
else
|
|
{
|
|
ShowStop( " %d-Stop stream", GetTime( ) );
|
|
gStreamStop++;
|
|
while ( gStreamStatus != EzADPCM_STATUS_IDLE )
|
|
{
|
|
for ( i = 0; i < NUM_WAIT_CLICKS; i++ )
|
|
;
|
|
if ( j++ > NUM_WAIT_CLICKS )
|
|
{
|
|
ShowStop( "." );
|
|
// printf( " ss %x sls %d rf %d eecom %d\n", gStreamStatus, gStreamLoadState, gRequestFlags, gEECommand );
|
|
j = 0;
|
|
}
|
|
}
|
|
//ShowStop( "\n" );
|
|
SmallShowAction( "-ss" );
|
|
ShowAction( "Stopped stream\n" );
|
|
}
|
|
gEECommand &= ~ ( PCMSTATUS_STREAM_PLAYING | PCMSTATUS_NEED_STREAM_BUFFER_0 | PCMSTATUS_NEED_STREAM_BUFFER_1 );
|
|
return ( 1 );
|
|
}
|
|
return ( 0 );
|
|
}
|
|
|
|
// EzADPCM_SETMUSICVOL
|
|
void AdpcmSetMusicVolume( unsigned int vol )
|
|
{
|
|
gMusicVolumeSet = 1;
|
|
gMusicVolume = vol;
|
|
return;
|
|
}
|
|
|
|
// EzADPCM_SETMUSICVOLDIRECT
|
|
void AdpcmSetMusicVolumeDirect( unsigned int vol )
|
|
{
|
|
gMusicVolume = vol;
|
|
sceSdSetParam ( MUSIC_CORE | ( MUSIC_L_VOICE << 1 ) | SD_VP_VOLL, vol );
|
|
sceSdSetParam ( MUSIC_CORE | ( MUSIC_L_VOICE << 1 ) | SD_VP_VOLR, 0 );
|
|
sceSdSetParam ( MUSIC_CORE | ( MUSIC_R_VOICE << 1 ) | SD_VP_VOLL, 0 );
|
|
sceSdSetParam ( MUSIC_CORE | ( MUSIC_R_VOICE << 1 ) | SD_VP_VOLR, vol );
|
|
return;
|
|
}
|
|
|
|
// EzADPCM_SETSTREAMVOL
|
|
void AdpcmSetStreamVolume( unsigned int vol )
|
|
{
|
|
gStreamVolumeSet = 1;
|
|
gStreamVolume = vol;
|
|
return;
|
|
}
|
|
|
|
// EzADPCM_SETSTREAMVOLDIRECT
|
|
void AdpcmSetStreamVolumeDirect( unsigned int vol )
|
|
{
|
|
gStreamVolume = vol;
|
|
sceSdSetParam ( STREAM_CORE | ( STREAM_VOICE << 1 ) | SD_VP_VOLL, _Lch( vol ) );
|
|
sceSdSetParam ( STREAM_CORE | ( STREAM_VOICE << 1 ) | SD_VP_VOLR, _Rch( vol ) );
|
|
return;
|
|
}
|
|
|
|
// Shouldn't need these unless debugging or something --
|
|
// Instead just get gEECommand each frame and act accordingly.
|
|
|
|
// EzADPCM_GETMUSICSTATUS
|
|
unsigned int AdpcmGetMusicStatus( void )
|
|
{
|
|
return gMusicStatus;
|
|
}
|
|
|
|
// EzADPCM_GETSTREAMSTATUS
|
|
unsigned int AdpcmGetStreamStatus( void )
|
|
{
|
|
return gStreamStatus;
|
|
}
|
|
|
|
// actual time 300 ms across one buffer (600ms across double buffer)
|
|
#define SINGLE_BUFFER_MS 300
|
|
#define MIN_INTERRUPT_SEPARATION_MS 90
|
|
#define MAX_MS_BETWEEN_STREAMS ( SINGLE_BUFFER_MS - MIN_INTERRUPT_SEPARATION_MS )
|
|
#define MIN_MS_BETWEEN_STREAMS ( MIN_INTERRUPT_SEPARATION_MS )
|
|
|
|
int SafeForStreamToGo( unsigned int time )
|
|
{
|
|
if ( gMusicStatus == EzADPCM_STATUS_IDLE )
|
|
{
|
|
SmallShowState( "[ss]" );
|
|
return ( 1 );
|
|
}
|
|
else
|
|
{
|
|
time -= gStreamTimeOffset;
|
|
if ( gMusicPaused )
|
|
{
|
|
if ( time > gMusicPaused + MIN_MS_BETWEEN_STREAMS )
|
|
{
|
|
SmallShowState( "[ss0]" );
|
|
return ( 1 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int musicMod;
|
|
int streamMod;
|
|
musicMod = gTimeOfLastMusicUpdate % SINGLE_BUFFER_MS;
|
|
streamMod = time % SINGLE_BUFFER_MS;
|
|
if ( musicMod > streamMod )
|
|
{
|
|
if ( ( musicMod - streamMod > MIN_MS_BETWEEN_STREAMS ) &&
|
|
( ( ( streamMod + SINGLE_BUFFER_MS ) - musicMod ) > MIN_MS_BETWEEN_STREAMS ) )
|
|
{
|
|
SmallShowState( "[ss1]" );
|
|
return ( 1 );
|
|
}
|
|
}
|
|
else if ( ( streamMod - musicMod > MIN_MS_BETWEEN_STREAMS ) &&
|
|
( ( ( musicMod + SINGLE_BUFFER_MS ) - streamMod ) > MIN_MS_BETWEEN_STREAMS ) )
|
|
{
|
|
SmallShowState( "[ss2]" );
|
|
return ( 1 );
|
|
}
|
|
}
|
|
/*
|
|
else if ( ( time > gTimeOfLastMusicUpdate + MIN_MS_BETWEEN_STREAMS ) &&
|
|
( time < gTimeOfLastMusicUpdate + MAX_MS_BETWEEN_STREAMS ) )
|
|
{
|
|
SmallShowState( "[ss1]" );
|
|
return ( 1 );
|
|
}
|
|
else
|
|
{
|
|
unsigned int predictedTimeOfInterrupt;
|
|
predictedTimeOfInterrupt = ( time + SINGLE_BUFFER_MS );
|
|
if ( ( predictedTimeOfInterrupt > ( gTimeOfLastMusicUpdate + MIN_MS_BETWEEN_STREAMS ) )
|
|
&& ( predictedTimeOfInterrupt < ( gTimeOfLastMusicUpdate + MAX_MS_BETWEEN_STREAMS ) ) )
|
|
{
|
|
SmallShowState( "[ss2]" );
|
|
return ( 1 );
|
|
}
|
|
else
|
|
{
|
|
//printf( " <>gsto %d<>", gStreamTimeOffset );
|
|
SmallShowState( "[nss]" ); //fe ss %x sls %d eecom %d\n", gStreamStatus, gStreamLoadState, gEECommand );
|
|
}
|
|
}*/
|
|
}
|
|
SmallShowState( "[nss]" ); //fe ss %x sls %d eecom %d\n", gStreamStatus, gStreamLoadState, gEECommand );
|
|
return ( 0 );
|
|
}
|
|
|
|
int SafeForMusicToGo( unsigned int time )
|
|
{
|
|
if ( gStreamStatus == EzADPCM_STATUS_IDLE )
|
|
{
|
|
SmallShowState( "[ms]" ); //fe ss %x sls %d eecom %d\n", gStreamStatus, gStreamLoadState, gEECommand );
|
|
return ( 1 );
|
|
}
|
|
else
|
|
{
|
|
time -= gMusicTimeOffset;
|
|
if ( gStreamPaused )
|
|
{
|
|
if ( time > gStreamPaused + MIN_MS_BETWEEN_STREAMS )
|
|
{
|
|
SmallShowState( "[ms0]" ); //fe ss %x sls %d eecom %d\n", gStreamStatus, gStreamLoadState, gEECommand );
|
|
return ( 1 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int streamMod;
|
|
int musicMod;
|
|
streamMod = gTimeOfLastStreamUpdate % SINGLE_BUFFER_MS;
|
|
musicMod = time % SINGLE_BUFFER_MS;
|
|
if ( musicMod > streamMod )
|
|
{
|
|
if ( ( musicMod - streamMod > MIN_MS_BETWEEN_STREAMS ) &&
|
|
( ( ( streamMod + SINGLE_BUFFER_MS ) - musicMod ) > MIN_MS_BETWEEN_STREAMS ) )
|
|
{
|
|
SmallShowState( "[ms1]" );
|
|
return ( 1 );
|
|
}
|
|
}
|
|
else if ( ( streamMod - musicMod > MIN_MS_BETWEEN_STREAMS ) &&
|
|
( ( ( musicMod + SINGLE_BUFFER_MS ) - streamMod ) > MIN_MS_BETWEEN_STREAMS ) )
|
|
{
|
|
SmallShowState( "[ms2]" );
|
|
return ( 1 );
|
|
}
|
|
}
|
|
/*
|
|
else if ( ( time > gTimeOfLastStreamUpdate + MIN_MS_BETWEEN_STREAMS ) &&
|
|
( time < gTimeOfLastStreamUpdate + MAX_MS_BETWEEN_STREAMS ) )
|
|
{
|
|
SmallShowState( "[ms1]" ); //fe ss %x sls %d eecom %d\n", gStreamStatus, gStreamLoadState, gEECommand );
|
|
return ( 1 );
|
|
}
|
|
else
|
|
{
|
|
unsigned int predictedTimeOfInterrupt;
|
|
predictedTimeOfInterrupt = ( time + SINGLE_BUFFER_MS );
|
|
if ( ( predictedTimeOfInterrupt > ( gTimeOfLastStreamUpdate + MIN_MS_BETWEEN_STREAMS ) )
|
|
&& ( predictedTimeOfInterrupt < ( gTimeOfLastStreamUpdate + MAX_MS_BETWEEN_STREAMS ) ) )
|
|
{
|
|
SmallShowState( "[ms2]" ); //fe ss %x sls %d eecom %d\n", gStreamStatus, gStreamLoadState, gEECommand );
|
|
return ( 1 );
|
|
}
|
|
else
|
|
{
|
|
SmallShowState( "[nsm]" ); //fe ss %x sls %d eecom %d\n", gStreamStatus, gStreamLoadState, gEECommand );
|
|
}
|
|
}*/
|
|
|
|
}
|
|
SmallShowState( "[nsm]" ); //fe ss %x sls %d eecom %d\n", gStreamStatus, gStreamLoadState, gEECommand );
|
|
return ( 0 );
|
|
}
|
|
|
|
// EzADPCM_GETSTATUS
|
|
unsigned int AdpcmGetStatus( void )
|
|
{
|
|
unsigned int temp;
|
|
unsigned int time;
|
|
|
|
if ( gRequestFlags & ( RF_START_MUSIC | RF_START_STREAM | RF_UNPAUSE_MUSIC | RF_UNPAUSE_STREAM ) )
|
|
{
|
|
time = GetTime( );
|
|
if ( ( gRequestFlags & RF_START_STREAM ) && ( SafeForStreamToGo( time ) ) )
|
|
{
|
|
gUpdateStream = 1;
|
|
gTimeOfLastStreamUpdate = time;
|
|
ShowAction( "Starting stream\n" );
|
|
SmallShowAction( "-sb" );
|
|
SignalSema( gSem );
|
|
gRequestFlags &= ~RF_START_STREAM;
|
|
}
|
|
else if ( ( gRequestFlags & RF_START_MUSIC ) && ( SafeForMusicToGo( time ) ) )
|
|
{
|
|
gUpdateMusic = 1;
|
|
gTimeOfLastStreamUpdate = time;
|
|
ShowAction( "Starting music\n" );
|
|
SmallShowAction( "-mb" );
|
|
SignalSema( gSem );
|
|
gRequestFlags &= ~RF_START_MUSIC;
|
|
}
|
|
else // unpause one or both of these motherfuckers:
|
|
{
|
|
if ( ( gRequestFlags & RF_UNPAUSE_STREAM ) && ( SafeForStreamToGo( time ) ) )
|
|
{
|
|
sceSdSetParam( STREAM_CORE | ( STREAM_VOICE << 1 ) | SD_VP_PITCH, DEFAULT_PITCH );
|
|
gStreamPaused = 0;
|
|
gTimeOfLastStreamUpdate = time - gStreamTimeOffset;
|
|
gStreamTimeOffset = 0;
|
|
gRequestFlags &= ~RF_UNPAUSE_STREAM;
|
|
ShowAction( "Unpausing stream\n" );
|
|
SmallShowAction( "-ups" );
|
|
}
|
|
if ( ( gRequestFlags & RF_UNPAUSE_MUSIC ) && ( SafeForMusicToGo( time ) ) )
|
|
{
|
|
sceSdSetParam( MUSIC_CORE | ( MUSIC_L_VOICE << 1 ) | SD_VP_PITCH, DEFAULT_PITCH );
|
|
sceSdSetParam( MUSIC_CORE | ( MUSIC_R_VOICE << 1 ) | SD_VP_PITCH, DEFAULT_PITCH );
|
|
gMusicPaused = 0;
|
|
gTimeOfLastMusicUpdate = time - gMusicTimeOffset;
|
|
gMusicTimeOffset = 0;
|
|
gRequestFlags &= ~RF_UNPAUSE_MUSIC;
|
|
ShowAction( "Unpausing music\n" );
|
|
SmallShowAction( "-upm" );
|
|
}
|
|
}
|
|
}
|
|
|
|
temp = gEECommand;
|
|
gEECommand &= ~( PCMSTATUS_NEED_MUSIC_BUFFER_0 | PCMSTATUS_NEED_MUSIC_BUFFER_1 |
|
|
PCMSTATUS_NEED_STREAM_BUFFER_0 | PCMSTATUS_NEED_STREAM_BUFFER_1 );
|
|
#if SHOW_SMALL_COMMANDS
|
|
if ( temp & ( PCMSTATUS_NEED_MUSIC_BUFFER_0 | PCMSTATUS_NEED_MUSIC_BUFFER_1 |
|
|
PCMSTATUS_NEED_STREAM_BUFFER_0 | PCMSTATUS_NEED_STREAM_BUFFER_1 ) )
|
|
{
|
|
ShowSmallCommand( " <_L_>" );
|
|
}
|
|
#endif
|
|
return temp;
|
|
}
|
|
|
|
// ================================================================
|
|
|
|
#define _ADPCM_MARK_START 0x04
|
|
#define _ADPCM_MARK_LOOP 0x02
|
|
#define _ADPCM_MARK_END 0x01
|
|
|
|
#define _AdpcmSetMarkSTART(a,s) { \
|
|
*((unsigned char *)((a)+1)) = \
|
|
(_ADPCM_MARK_LOOP | _ADPCM_MARK_START); \
|
|
*((unsigned char *)((a)+0x10+1)) = \
|
|
_ADPCM_MARK_LOOP; \
|
|
*((unsigned char *)((a)+(s)-0x0f)) = \
|
|
_ADPCM_MARK_LOOP; \
|
|
FlushDcache (); }
|
|
#define _AdpcmSetMarkEND(a,s) { \
|
|
*((unsigned char *)((a)+1)) = \
|
|
_ADPCM_MARK_LOOP; \
|
|
*((unsigned char *)((a)+0x10+1)) = \
|
|
_ADPCM_MARK_LOOP; \
|
|
*((unsigned char *)((a)+(s)-0x0f)) = \
|
|
(_ADPCM_MARK_LOOP | _ADPCM_MARK_END); \
|
|
FlushDcache (); }
|
|
|
|
#define _AdpcmSetMarkFINAL(a,s) { \
|
|
*((unsigned char *)((a)+(s)-0x0f)) = \
|
|
(_ADPCM_MARK_LOOP | _ADPCM_MARK_START | _ADPCM_MARK_END); \
|
|
FlushDcache (); }
|
|
|
|
#define _AdpcmSetMarkSTARTpre(a,s) { \
|
|
*((unsigned char *)((a)+1)) = \
|
|
(_ADPCM_MARK_LOOP | _ADPCM_MARK_START); \
|
|
*((unsigned char *)((a)+0x10+1)) = \
|
|
_ADPCM_MARK_LOOP; \
|
|
FlushDcache (); }
|
|
#define _AdpcmSetMarkENDpre(a,s) { \
|
|
*((unsigned char *)((a)+(s)-0x0f)) = \
|
|
(_ADPCM_MARK_LOOP | _ADPCM_MARK_END); \
|
|
FlushDcache (); }
|
|
|
|
#if SHARE_DMA_CH
|
|
|
|
/* internal */
|
|
static int _AdpcmDmaIntCommon(int ch, void *common) // DMA Interrupt -- when transfering data to SPU2 from IOP
|
|
{
|
|
if ( gLoadStatus & LOAD_STATUS_LOADING_MUSIC )
|
|
{
|
|
if ( gMusicStatus != EzADPCM_STATUS_IDLE )
|
|
{
|
|
gUpdateMusic++;
|
|
iSignalSema (* (int *) common);
|
|
return 1;
|
|
}
|
|
}
|
|
else if ( gLoadStatus & LOAD_STATUS_LOADING_STREAM )
|
|
{
|
|
if ( gStreamStatus != EzADPCM_STATUS_IDLE )
|
|
{
|
|
gUpdateStream++;
|
|
iSignalSema (* (int *) common);
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#else
|
|
|
|
/* internal */
|
|
static int _AdpcmDmaIntMusic(int ch, void *common) // DMA Interrupt -- when transfering data to SPU2 from IOP
|
|
{
|
|
if ( gMusicStatus != EzADPCM_STATUS_IDLE )
|
|
{
|
|
gUpdateMusic++;
|
|
iSignalSema (* (int *) common);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* internal */
|
|
static int _AdpcmDmaIntStream(int ch, void *common) // DMA Interrupt -- when transfering data to SPU2 from IOP
|
|
{
|
|
if ( gStreamStatus != EzADPCM_STATUS_IDLE )
|
|
{
|
|
gUpdateStream++;
|
|
iSignalSema (* (int *) common);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
/* internal */
|
|
static int _AdpcmSpu2Int( int core, void *common ) // SPU2 Voice Interrupt
|
|
{
|
|
if ( core == ( 1 << MUSIC_CORE ) )
|
|
{
|
|
if ( gMusicLoadState != MUSIC_LOAD_STATE_WAITING_FOR_IRQ )
|
|
{
|
|
int shit;
|
|
for ( shit = 0; shit < 666; shit++ )
|
|
{
|
|
printf( "shit\n" );
|
|
return 0;
|
|
}
|
|
}
|
|
gUpdateMusic++;
|
|
}
|
|
else
|
|
{
|
|
if ( gStreamLoadState != STREAM_LOAD_STATE_WAITING_FOR_IRQ )
|
|
{
|
|
int shit;
|
|
for ( shit = 0; shit < 666; shit++ )
|
|
{
|
|
printf( "shit\n" );
|
|
return 0;
|
|
}
|
|
}
|
|
gUpdateStream++;
|
|
}
|
|
iSignalSema (* (int *) common);
|
|
return 1;
|
|
}
|
|
|
|
#define LAST_VAG_POS 15
|
|
|
|
//prototype:
|
|
void UpdateStream( void );
|
|
|
|
void UpdateMusic( void )
|
|
{
|
|
switch ( gMusicStatus )
|
|
{
|
|
case EzADPCM_STATUS_IDLE:
|
|
break;
|
|
|
|
case EzADPCM_STATUS_PRELOAD:
|
|
switch ( gMusicLoadState )
|
|
{
|
|
case ( MUSIC_LOAD_STATE_IDLE ):
|
|
{
|
|
#if SHARE_DMA_CH
|
|
if ( gLoadStatus & LOAD_STATUS_LOADING_STREAM )
|
|
{
|
|
gLoadStatus |= LOAD_STATUS_NEED_MUSIC;
|
|
return;
|
|
}
|
|
gLoadStatus |= LOAD_STATUS_LOADING_MUSIC;
|
|
#endif
|
|
ShowState( "music preload l\n" );
|
|
SmallShowState( "-MPL" );
|
|
gMusicBufSide = _1st;
|
|
gMusicIopOffset = 0;
|
|
gMusicRemaining = gMusicSize;
|
|
gMusicRemaining -= SB_BUF_SIZE;
|
|
gMusicTransSize = SB_BUF_SIZE;
|
|
if ( gMusicRemaining < 0 )
|
|
{
|
|
gMusicTransSize += gMusicRemaining;
|
|
}
|
|
|
|
#if DATA_INTEGRITY_CHECK
|
|
{
|
|
int gronk;
|
|
for ( gronk = 0; gronk < gMusicTransSize >> 4; gronk++ )
|
|
{
|
|
if ( *( ( char * )( 1 + gpIopBuf + MUSIC_L_IOP_OFFSET + ( gronk * 16 ) ) ) != 0 )
|
|
{
|
|
printf( "Fucked up data!!!!" );
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// preload left:
|
|
_AdpcmSetMarkSTARTpre( gpIopBuf + MUSIC_L_IOP_OFFSET, gMusicTransSize );
|
|
if ( gMusicRemaining > 0 )
|
|
{
|
|
_AdpcmSetMarkENDpre( gpIopBuf + MUSIC_L_IOP_OFFSET, gMusicTransSize );
|
|
}
|
|
else
|
|
{
|
|
_AdpcmSetMarkFINAL( gpIopBuf + MUSIC_L_IOP_OFFSET, gMusicTransSize );
|
|
}
|
|
sceSdVoiceTrans( TRANS_DMA_CH_MUSIC, ( SD_TRANS_MODE_WRITE | SD_TRANS_BY_DMA ),
|
|
(unsigned char *) ( gpIopBuf + MUSIC_L_IOP_OFFSET ),
|
|
MUSIC_L_SPU_BUF_LOC, gMusicTransSize );
|
|
gMusicLoadState++;
|
|
break;
|
|
}
|
|
case ( MUSIC_LOAD_STATE_PRELOADING_L ):
|
|
{
|
|
ShowState( "music preload r\n" );
|
|
SmallShowState( "-MPR" );
|
|
// preload right:
|
|
#if DATA_INTEGRITY_CHECK
|
|
{
|
|
int gronk;
|
|
for ( gronk = 0; gronk < gMusicTransSize >> 4; gronk++ )
|
|
{
|
|
if ( *( ( char * )( 1 + gpIopBuf + MUSIC_R_IOP_OFFSET + ( gronk * 16 ) ) ) != 0 )
|
|
{
|
|
printf( "Fucked up data!!!!" );
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
_AdpcmSetMarkSTARTpre( gpIopBuf + MUSIC_R_IOP_OFFSET, gMusicTransSize );
|
|
if ( gMusicRemaining > 0 )
|
|
{
|
|
_AdpcmSetMarkENDpre( gpIopBuf + MUSIC_R_IOP_OFFSET, gMusicTransSize );
|
|
}
|
|
else
|
|
{
|
|
_AdpcmSetMarkFINAL( gpIopBuf + MUSIC_R_IOP_OFFSET, gMusicTransSize );
|
|
}
|
|
sceSdVoiceTrans( TRANS_DMA_CH_MUSIC, ( SD_TRANS_MODE_WRITE | SD_TRANS_BY_DMA ),
|
|
(unsigned char *) ( gpIopBuf + MUSIC_R_IOP_OFFSET ),
|
|
MUSIC_R_SPU_BUF_LOC, gMusicTransSize );
|
|
gMusicLoadState++;
|
|
break;
|
|
}
|
|
case ( MUSIC_LOAD_STATE_PRELOADING_R ):
|
|
{
|
|
ShowState( "Music starting -- waiting for IRQ\n" );
|
|
SmallShowState( " %d-MSIRQ", GetTime( ) );
|
|
gMusicIopOffset = SB_BUF_SIZE;
|
|
if ( gMusicRemaining <= 0 )
|
|
{
|
|
sceSdSetAddr( MUSIC_CORE | SD_A_IRQA, MUSIC_L_SPU_BUF_LOC + gMusicTransSize - LAST_VAG_POS );
|
|
gMusicStatus = EzADPCM_STATUS_TERMINATE;
|
|
}
|
|
else
|
|
{
|
|
sceSdSetAddr( MUSIC_CORE | SD_A_IRQA, MUSIC_L_SPU_BUF_LOC + SB_BUF_HALF );
|
|
gMusicStatus = EzADPCM_STATUS_RUNNING;
|
|
}
|
|
AdpcmSetMusicVolumeDirect( gMusicVolume );
|
|
sceSdSetCoreAttr( MUSIC_CORE | SD_C_IRQ_ENABLE, 1 );
|
|
sceSdSetSwitch( MUSIC_CORE | SD_S_KON, ( ( 1 << MUSIC_R_VOICE ) | ( 1 << MUSIC_L_VOICE ) ) );
|
|
gMusicLoadState++;
|
|
gTimeOfLastMusicUpdate = GetTime( );
|
|
// printf( "music wait IRQ...\n" );
|
|
#if SHARE_DMA_CH
|
|
gLoadStatus &= ~LOAD_STATUS_LOADING_MUSIC;
|
|
if ( gLoadStatus & LOAD_STATUS_NEED_STREAM )
|
|
{
|
|
gLoadStatus &= ~LOAD_STATUS_NEED_STREAM;
|
|
UpdateStream( );
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EzADPCM_STATUS_RUNNING:
|
|
switch ( gMusicLoadState )
|
|
{
|
|
case ( MUSIC_LOAD_STATE_WAITING_FOR_IRQ ):
|
|
{
|
|
#if SHARE_DMA_CH
|
|
if ( gLoadStatus & LOAD_STATUS_LOADING_STREAM )
|
|
{
|
|
gLoadStatus |= LOAD_STATUS_NEED_MUSIC;
|
|
return;
|
|
}
|
|
gLoadStatus |= LOAD_STATUS_LOADING_MUSIC;
|
|
#endif
|
|
ShowState( "Music Running -- Loading L\n" );
|
|
SmallShowState( "-MRLL" );
|
|
sceSdSetCoreAttr ( MUSIC_CORE | SD_C_IRQ_ENABLE, 0);
|
|
gMusicTransSize = SB_BUF_HALF;
|
|
gMusicRemaining -= SB_BUF_HALF;
|
|
if ( gMusicRemaining < 0 )
|
|
{
|
|
gMusicTransSize += gMusicRemaining;
|
|
}
|
|
#if DATA_INTEGRITY_CHECK
|
|
{
|
|
int gronk;
|
|
for ( gronk = 0; gronk < gMusicTransSize >> 4; gronk++ )
|
|
{
|
|
if ( *( ( char * )( 1 + gpIopBuf + MUSIC_L_IOP_OFFSET + gMusicIopOffset + ( gronk * 16 ) ) ) != 0 )
|
|
{
|
|
printf( "Fucked up data!!!!" );
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// load in left side:
|
|
if ( gMusicBufSide == _1st )
|
|
{
|
|
_AdpcmSetMarkSTART( gpIopBuf + MUSIC_L_IOP_OFFSET + gMusicIopOffset, gMusicTransSize );
|
|
}
|
|
if ( gMusicRemaining <= 0 )
|
|
{
|
|
_AdpcmSetMarkFINAL( gpIopBuf + MUSIC_L_IOP_OFFSET + gMusicIopOffset, gMusicTransSize );
|
|
}
|
|
else if ( gMusicBufSide == _2nd )
|
|
{
|
|
_AdpcmSetMarkEND( gpIopBuf + MUSIC_L_IOP_OFFSET + gMusicIopOffset, gMusicTransSize );
|
|
}
|
|
|
|
sceSdVoiceTrans( TRANS_DMA_CH_MUSIC, ( SD_TRANS_MODE_WRITE | SD_TRANS_BY_DMA ),
|
|
(unsigned char *) gpIopBuf + MUSIC_L_IOP_OFFSET + gMusicIopOffset,
|
|
( MUSIC_L_SPU_BUF_LOC + SB_BUF_HALF * gMusicBufSide ), gMusicTransSize );
|
|
gMusicLoadState++;
|
|
break;
|
|
}
|
|
case ( MUSIC_LOAD_STATE_LOADING_L ):
|
|
{
|
|
ShowState( "Music Running -- Loading R\n" );
|
|
SmallShowState( "-MRLR" );
|
|
#if DATA_INTEGRITY_CHECK
|
|
{
|
|
int gronk;
|
|
for ( gronk = 0; gronk < gMusicTransSize >> 4; gronk++ )
|
|
{
|
|
if ( *( ( char * )( 1 + gpIopBuf + MUSIC_R_IOP_OFFSET + gMusicIopOffset + ( gronk * 16 ) ) ) != 0 )
|
|
{
|
|
printf( "Fucked up data!!!!" );
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// load in right side:
|
|
if ( gMusicBufSide == _1st )
|
|
{
|
|
_AdpcmSetMarkSTART( gpIopBuf + MUSIC_R_IOP_OFFSET + gMusicIopOffset, gMusicTransSize );
|
|
}
|
|
if ( gMusicRemaining <= 0 )
|
|
{
|
|
_AdpcmSetMarkFINAL( gpIopBuf + MUSIC_R_IOP_OFFSET + gMusicIopOffset, gMusicTransSize );
|
|
}
|
|
else if ( gMusicBufSide == _2nd )
|
|
{
|
|
_AdpcmSetMarkEND( gpIopBuf + MUSIC_R_IOP_OFFSET + gMusicIopOffset, gMusicTransSize );
|
|
}
|
|
sceSdVoiceTrans( TRANS_DMA_CH_MUSIC, ( SD_TRANS_MODE_WRITE | SD_TRANS_BY_DMA ),
|
|
(unsigned char *) gpIopBuf + MUSIC_R_IOP_OFFSET + gMusicIopOffset,
|
|
( MUSIC_R_SPU_BUF_LOC + SB_BUF_HALF * gMusicBufSide ), gMusicTransSize );
|
|
gMusicLoadState++;
|
|
break;
|
|
}
|
|
case ( MUSIC_LOAD_STATE_LOADING_R ):
|
|
{
|
|
ShowState( "Music Running -- Waiting for IRQ\n" );
|
|
SmallShowState( " %d-MRIRQ", GetTime( ) );
|
|
// reset the interrupt:
|
|
if ( gMusicRemaining <= 0 )
|
|
{
|
|
sceSdSetAddr( MUSIC_CORE | SD_A_IRQA, gMusicTransSize - LAST_VAG_POS + MUSIC_L_SPU_BUF_LOC + SB_BUF_HALF * gMusicBufSide );
|
|
}
|
|
else
|
|
{
|
|
sceSdSetAddr( MUSIC_CORE | SD_A_IRQA, MUSIC_L_SPU_BUF_LOC + SB_BUF_HALF * gMusicBufSide );
|
|
}
|
|
gTimeOfLastMusicUpdate = GetTime( );
|
|
gMusicIopOffset += SB_BUF_HALF;
|
|
gMusicBufSide = ( gMusicBufSide == _1st ) ? _2nd : _1st;
|
|
|
|
if ( gMusicRemaining <= 0 )
|
|
{
|
|
// the vag data up to the end should contain all zeros,
|
|
// so it doesn't matter that the interrupt won't happen until the end.
|
|
// stop the music when it gets to the end:
|
|
gMusicStop++;
|
|
}
|
|
else
|
|
{
|
|
if ( gMusicIopOffset == HALF_BUFFER_SIZE )
|
|
{
|
|
//Dbug_Printf( "music move over\n" );
|
|
gMusicIopOffset += HALF_BUFFER_SIZE; // move over by half the size since L/R load in together...
|
|
if ( gMusicRemaining > HALF_BUFFER_SIZE )
|
|
{
|
|
gEECommand |= PCMSTATUS_NEED_MUSIC_BUFFER_0;
|
|
}
|
|
}
|
|
else if ( gMusicIopOffset == ( SINGLE_STREAM_BUFFER_SIZE + HALF_BUFFER_SIZE ) )
|
|
{
|
|
//Dbug_Printf( "music move back\n" );
|
|
gMusicIopOffset = 0;
|
|
if ( gMusicRemaining > HALF_BUFFER_SIZE )
|
|
{
|
|
gEECommand |= PCMSTATUS_NEED_MUSIC_BUFFER_1;
|
|
}
|
|
}
|
|
}
|
|
if ( gMusicStop )
|
|
{
|
|
gMusicStop = 0;
|
|
gMusicStatus = EzADPCM_STATUS_TERMINATE;
|
|
}
|
|
sceSdSetCoreAttr( MUSIC_CORE | SD_C_IRQ_ENABLE, 1);
|
|
gMusicLoadState = MUSIC_LOAD_STATE_WAITING_FOR_IRQ;
|
|
// printf( "music wait IRQ\n" );
|
|
#if SHARE_DMA_CH
|
|
gLoadStatus &= ~LOAD_STATUS_LOADING_MUSIC;
|
|
if ( gLoadStatus & LOAD_STATUS_NEED_STREAM )
|
|
{
|
|
gLoadStatus &= ~LOAD_STATUS_NEED_STREAM;
|
|
UpdateStream( );
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
default:
|
|
printf( "Unknown music loading state %d\n", gMusicLoadState );
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case EzADPCM_STATUS_TERMINATE:
|
|
ShowState( "Music terminate\n" );
|
|
SmallShowState( "-MT!!!" );
|
|
StopMusic( );
|
|
break;
|
|
|
|
default:
|
|
printf( "unknown music status in pcm irx!!!\n" );
|
|
break;
|
|
}
|
|
}
|
|
|
|
void UpdateStream( void )
|
|
{
|
|
// printf( "hmmm %d %d bufside %d left %d\n", gStreamStatus, gStreamLoadState, gStreamBufSide, gStreamRemaining );
|
|
switch ( gStreamStatus )
|
|
{
|
|
case EzADPCM_STATUS_IDLE:
|
|
break;
|
|
|
|
case EzADPCM_STATUS_PRELOAD:
|
|
switch ( gStreamLoadState )
|
|
{
|
|
case ( STREAM_LOAD_STATE_IDLE ):
|
|
{
|
|
#if SHARE_DMA_CH
|
|
if ( gLoadStatus & LOAD_STATUS_LOADING_MUSIC )
|
|
{
|
|
gLoadStatus |= LOAD_STATUS_NEED_STREAM;
|
|
return;
|
|
}
|
|
gLoadStatus |= LOAD_STATUS_LOADING_STREAM;
|
|
#endif
|
|
ShowState( "stream preload l\n" );
|
|
SmallShowState( "-SPL" );
|
|
gStreamBufSide = _1st;
|
|
gStreamIopOffset = 0;
|
|
gStreamRemaining = gStreamSize;
|
|
gStreamRemaining -= SB_BUF_SIZE;
|
|
gStreamTransSize = SB_BUF_SIZE;
|
|
if ( gStreamRemaining < 0 )
|
|
{
|
|
gStreamTransSize += gStreamRemaining;
|
|
}
|
|
#if DATA_INTEGRITY_CHECK
|
|
{
|
|
int gronk;
|
|
for ( gronk = 0; gronk < gStreamTransSize >> 4; gronk++ )
|
|
{
|
|
if ( *( ( char * )( 1 + gpIopBuf + STREAM_IOP_OFFSET + ( gronk * 16 ) ) ) != 0 )
|
|
{
|
|
printf( "Fucked up data!!!!" );
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
// preload left:
|
|
_AdpcmSetMarkSTARTpre( gpIopBuf + STREAM_IOP_OFFSET, gStreamTransSize );
|
|
if ( gStreamRemaining > 0 )
|
|
{
|
|
_AdpcmSetMarkENDpre( gpIopBuf + STREAM_IOP_OFFSET, gStreamTransSize );
|
|
}
|
|
else
|
|
{
|
|
_AdpcmSetMarkFINAL( gpIopBuf + STREAM_IOP_OFFSET, gStreamTransSize );
|
|
}
|
|
sceSdVoiceTrans( TRANS_DMA_CH_STREAM, ( SD_TRANS_MODE_WRITE | SD_TRANS_BY_DMA ),
|
|
(unsigned char *) ( gpIopBuf + STREAM_IOP_OFFSET ),
|
|
STREAM_SPU_BUF_LOC, gStreamTransSize );
|
|
gStreamLoadState++;
|
|
break;
|
|
}
|
|
case ( STREAM_LOAD_STATE_PRELOADING ):
|
|
{
|
|
ShowState( "Stream starting -- waiting for IRQ\n" );
|
|
SmallShowState( " %d-SSIRQ", GetTime( ) );
|
|
gStreamIopOffset = SB_BUF_SIZE;
|
|
if ( gStreamRemaining <= 0 )
|
|
{
|
|
sceSdSetAddr( STREAM_CORE | SD_A_IRQA, STREAM_SPU_BUF_LOC + gStreamTransSize - LAST_VAG_POS );
|
|
//printf( "tiny stream!!! addr %x transsize %x remaining %x", STREAM_SPU_BUF_LOC + gStreamTransSize - LAST_VAG_POS, gStreamTransSize, gStreamRemaining );
|
|
gStreamStatus = EzADPCM_STATUS_TERMINATE;
|
|
}
|
|
else
|
|
{
|
|
sceSdSetAddr( STREAM_CORE | SD_A_IRQA, STREAM_SPU_BUF_LOC + SB_BUF_HALF );
|
|
gStreamStatus = EzADPCM_STATUS_RUNNING;
|
|
}
|
|
AdpcmSetStreamVolumeDirect( gStreamVolume );
|
|
sceSdSetCoreAttr( STREAM_CORE | SD_C_IRQ_ENABLE, 1 );
|
|
sceSdSetSwitch( STREAM_CORE | SD_S_KON, 1 << STREAM_VOICE );
|
|
gStreamLoadState++;
|
|
gTimeOfLastStreamUpdate = GetTime( );
|
|
#if SHARE_DMA_CH
|
|
gLoadStatus &= ~LOAD_STATUS_LOADING_STREAM;
|
|
if ( gLoadStatus & LOAD_STATUS_NEED_MUSIC )
|
|
{
|
|
gLoadStatus &= ~LOAD_STATUS_NEED_MUSIC;
|
|
UpdateMusic( );
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EzADPCM_STATUS_RUNNING:
|
|
switch ( gStreamLoadState )
|
|
{
|
|
case ( STREAM_LOAD_STATE_WAITING_FOR_IRQ ):
|
|
{
|
|
ShowState( "Stream Running -- Loading\n" );
|
|
SmallShowState( "-SRL" );
|
|
#if SHARE_DMA_CH
|
|
if ( gLoadStatus & LOAD_STATUS_LOADING_MUSIC )
|
|
{
|
|
gLoadStatus |= LOAD_STATUS_NEED_STREAM;
|
|
return;
|
|
}
|
|
gLoadStatus |= LOAD_STATUS_LOADING_STREAM;
|
|
#endif
|
|
sceSdSetCoreAttr ( STREAM_CORE | SD_C_IRQ_ENABLE, 0);
|
|
gStreamTransSize = SB_BUF_HALF;
|
|
gStreamRemaining -= SB_BUF_HALF;
|
|
if ( gStreamRemaining < 0 )
|
|
{
|
|
gStreamTransSize += gStreamRemaining;
|
|
}
|
|
|
|
#if DATA_INTEGRITY_CHECK
|
|
{
|
|
int gronk;
|
|
for ( gronk = 0; gronk < gStreamTransSize >> 4; gronk++ )
|
|
{
|
|
if ( *( ( char * )( 1 + gpIopBuf + gStreamIopOffset + STREAM_IOP_OFFSET + ( gronk * 16 ) ) ) != 0 )
|
|
{
|
|
printf( "Fucked up data!!!!" );
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// load in left side:
|
|
if ( gStreamBufSide == _1st )
|
|
{
|
|
_AdpcmSetMarkSTART( gpIopBuf + STREAM_IOP_OFFSET + gStreamIopOffset, gStreamTransSize );
|
|
|
|
}
|
|
if ( gStreamRemaining <= 0 )
|
|
{
|
|
_AdpcmSetMarkFINAL( gpIopBuf + STREAM_IOP_OFFSET + gStreamIopOffset, gStreamTransSize );
|
|
}
|
|
else if ( gStreamBufSide == _2nd )
|
|
{
|
|
_AdpcmSetMarkEND( gpIopBuf + STREAM_IOP_OFFSET + gStreamIopOffset, gStreamTransSize );
|
|
}
|
|
sceSdVoiceTrans( TRANS_DMA_CH_STREAM, ( SD_TRANS_MODE_WRITE | SD_TRANS_BY_DMA ),
|
|
(unsigned char *) gpIopBuf + STREAM_IOP_OFFSET + gStreamIopOffset,
|
|
( STREAM_SPU_BUF_LOC + SB_BUF_HALF * gStreamBufSide ), gStreamTransSize );
|
|
gStreamLoadState++;
|
|
break;
|
|
}
|
|
case ( STREAM_LOAD_STATE_LOADING ):
|
|
{
|
|
ShowState( "Stream Running -- Waiting for IRQ\n" );
|
|
SmallShowState( " %d-SRIRQ", GetTime( ) );
|
|
// reset the interrupt:
|
|
if ( gStreamRemaining <= 0 )
|
|
{
|
|
sceSdSetAddr( STREAM_CORE | SD_A_IRQA, gStreamTransSize - LAST_VAG_POS + STREAM_SPU_BUF_LOC + SB_BUF_HALF * gStreamBufSide );
|
|
}
|
|
else
|
|
{
|
|
sceSdSetAddr( STREAM_CORE | SD_A_IRQA, STREAM_SPU_BUF_LOC + SB_BUF_HALF * gStreamBufSide );
|
|
}
|
|
gTimeOfLastStreamUpdate = GetTime( );
|
|
|
|
gStreamIopOffset += SB_BUF_HALF;
|
|
gStreamBufSide = ( gStreamBufSide == _1st ) ? _2nd : _1st;
|
|
|
|
if ( gStreamRemaining <= 0 )
|
|
{
|
|
// the vag data up to the end should contain all zeros,
|
|
// so it doesn't matter that the interrupt won't happen until the end.
|
|
// stop the stream when it gets to the end:
|
|
gStreamStop++;
|
|
}
|
|
else
|
|
{
|
|
if ( gStreamIopOffset == HALF_BUFFER_SIZE )
|
|
{
|
|
//Dbug_Printf( "Stream move over\n" );
|
|
if ( gStreamRemaining > HALF_BUFFER_SIZE )
|
|
{
|
|
gEECommand |= PCMSTATUS_NEED_STREAM_BUFFER_0;
|
|
}
|
|
}
|
|
else if ( gStreamIopOffset == SINGLE_STREAM_BUFFER_SIZE )
|
|
{
|
|
//Dbug_Printf( "Stream move back\n" );
|
|
gStreamIopOffset = 0;
|
|
if ( gStreamRemaining > HALF_BUFFER_SIZE )
|
|
{
|
|
gEECommand |= PCMSTATUS_NEED_STREAM_BUFFER_1;
|
|
}
|
|
}
|
|
}
|
|
if ( gStreamStop )
|
|
{
|
|
gStreamStop = 0;
|
|
gStreamStatus = EzADPCM_STATUS_TERMINATE;
|
|
}
|
|
sceSdSetCoreAttr( STREAM_CORE | SD_C_IRQ_ENABLE, 1);
|
|
gStreamLoadState = STREAM_LOAD_STATE_WAITING_FOR_IRQ;
|
|
// printf( "stream wait IRQ\n" );
|
|
#if SHARE_DMA_CH
|
|
gLoadStatus &= ~LOAD_STATUS_LOADING_STREAM;
|
|
if ( gLoadStatus & LOAD_STATUS_NEED_MUSIC )
|
|
{
|
|
gLoadStatus &= ~LOAD_STATUS_NEED_MUSIC;
|
|
UpdateMusic( );
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
default:
|
|
printf( "Unknown Stream loading state %d\n", gStreamLoadState );
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case EzADPCM_STATUS_TERMINATE:
|
|
ShowState( "Stream terminate\n" );
|
|
SmallShowState( "-ST!!!" );
|
|
StopStream( );
|
|
break;
|
|
|
|
default:
|
|
printf( "unknown stream status in pcm irx!!!\n" );
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* internal */
|
|
int _AdpcmPlay( int status )
|
|
{
|
|
while ( 1 )
|
|
{
|
|
// int st, mu;
|
|
WaitSema(gSem);
|
|
|
|
// ShowTime( "ssig us %d um %d ss %d ms %d ee %d time %d\n", gUpdateStream, gUpdateMusic, gStreamStatus, gMusicStatus, gEECommand, GetTime( ) );
|
|
// SmallShowTime( " <%d>", GetTime( ) );
|
|
// st = gUpdateStream;
|
|
// mu = gUpdateMusic;
|
|
while ( gUpdateStream )
|
|
{
|
|
//printf( "s u\n" );
|
|
gUpdateStream--;
|
|
UpdateStream( );
|
|
}
|
|
while ( gUpdateMusic )
|
|
{
|
|
//printf( "m u\n" );
|
|
gUpdateMusic--;
|
|
UpdateMusic( );
|
|
}
|
|
|
|
/*
|
|
if ( gTestPause == 666 )
|
|
{
|
|
sceSdSetParam( MUSIC_CORE | ( MUSIC_L_VOICE << 1 ) | SD_VP_PITCH, 0 );
|
|
sceSdSetParam( MUSIC_CORE | ( MUSIC_R_VOICE << 1 ) | SD_VP_PITCH, 0 );
|
|
sceSdSetParam( STREAM_CORE | ( STREAM_VOICE << 1 ) | SD_VP_PITCH, 0 );
|
|
gPaused = 1;
|
|
}
|
|
if ( ( !gTestPause ) && ( !st && !mu ) )
|
|
{
|
|
printf( "MOTHERFUCKER MOTHERFUCKER MOTHERFUCKER MOTHERFUCKER\n" );
|
|
gTestPause = 30;
|
|
}*/
|
|
|
|
//printf( "hmm NAX %x\n", sceSdGetAddr( MUSIC_CORE | ( MUSIC_R_VOICE << 1 ) | SD_VA_NAX ) );
|
|
if ( gMusicVolumeSet )
|
|
{
|
|
gMusicVolumeSet = 0;
|
|
AdpcmSetMusicVolumeDirect( gMusicVolume );
|
|
}
|
|
if ( gStreamVolumeSet )
|
|
{
|
|
gStreamVolumeSet = 0;
|
|
AdpcmSetStreamVolumeDirect( gStreamVolume );
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int rpc_arg [16];
|
|
volatile int ret = 0;
|
|
|
|
static void *dispatch( unsigned int command, void *data_, int size )
|
|
{
|
|
int ch;
|
|
int data = *(( int *) data_);
|
|
unsigned int dataU = *((unsigned int *) data_);
|
|
|
|
/* PRINTF (("# dispatch [%04x] %x, %x, %x, %x\n",
|
|
command,
|
|
*((int*) data_ + 0),
|
|
*((int*) data_ + 1),
|
|
*((int*) data_ + 2),
|
|
*((int*) data_ + 3)));*/
|
|
|
|
ch = command & EzADPCM_CH_MASK;
|
|
switch ( command & EzADPCM_COMMAND_MASK )
|
|
{
|
|
case EzADPCM_INIT:
|
|
ret = AdpcmInit( data ); // iop buffer pointer
|
|
break;
|
|
|
|
case EzADPCM_QUIT:
|
|
AdpcmQuit( );
|
|
break;
|
|
|
|
case EzADPCM_PLAYMUSIC:
|
|
ret = AdpcmPlayMusic( data ); // size of the entire PCM data in the file
|
|
break;
|
|
|
|
case EzADPCM_PLAYSTREAM:
|
|
ret = AdpcmPlayStream( data ); // size of the entire PCM data in the file
|
|
break;
|
|
|
|
case EzADPCM_PAUSEMUSIC:
|
|
if ( data )
|
|
{
|
|
if ( !gMusicPaused )
|
|
{
|
|
sceSdSetParam( MUSIC_CORE | ( MUSIC_L_VOICE << 1 ) | SD_VP_PITCH, 0 );
|
|
sceSdSetParam( MUSIC_CORE | ( MUSIC_R_VOICE << 1 ) | SD_VP_PITCH, 0 );
|
|
gMusicPaused = GetTime( );
|
|
gMusicTimeOffset = gMusicPaused - gTimeOfLastMusicUpdate;
|
|
if ( gMusicTimeOffset > SINGLE_BUFFER_MS )
|
|
{
|
|
/* if ( gMusicStatus != EzADPCM_STATUS_TERMINATE )
|
|
{
|
|
printf( "\n\nfuck your mom %x \n\n", gMusicStatus );
|
|
}*/
|
|
gMusicTimeOffset -= SINGLE_BUFFER_MS;
|
|
}
|
|
ShowAction( "Pausing music\n" );
|
|
SmallShowAction( "-pm" );
|
|
}
|
|
gRequestFlags &= ~RF_UNPAUSE_MUSIC;
|
|
}
|
|
else
|
|
{
|
|
if ( gMusicPaused )
|
|
{
|
|
gRequestFlags |= RF_UNPAUSE_MUSIC;
|
|
ShowAction( "Requesting unpause music\n" );
|
|
SmallShowAction( "-rupm" );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EzADPCM_PAUSESTREAM:
|
|
if ( data )
|
|
{
|
|
if ( !gStreamPaused )
|
|
{
|
|
sceSdSetParam( STREAM_CORE | ( STREAM_VOICE << 1 ) | SD_VP_PITCH, 0 );
|
|
gStreamPaused = GetTime( );
|
|
gStreamTimeOffset = gStreamPaused - gTimeOfLastStreamUpdate;
|
|
if ( gStreamTimeOffset > SINGLE_BUFFER_MS )
|
|
{
|
|
/* if ( gStreamStatus != EzADPCM_STATUS_TERMINATE )
|
|
{
|
|
printf( "\n\nfuck your mom %x \n\n", gStreamStatus );
|
|
}*/
|
|
gStreamTimeOffset -= SINGLE_BUFFER_MS;
|
|
}
|
|
ShowAction( "Pausing stream\n" );
|
|
SmallShowAction( "-ps" );
|
|
}
|
|
gRequestFlags &= ~( RF_UNPAUSE_STREAM );
|
|
}
|
|
else
|
|
{
|
|
if ( gStreamPaused )
|
|
{
|
|
gRequestFlags |= RF_UNPAUSE_STREAM;
|
|
ShowAction( "Requesting unpause stream\n" );
|
|
SmallShowAction( "-rups" );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EzADPCM_STOPMUSIC:
|
|
ret = AdpcmStopMusic( );
|
|
break;
|
|
|
|
case EzADPCM_STOPSTREAM:
|
|
ret = AdpcmStopStream( );
|
|
break;
|
|
|
|
case EzADPCM_SETMUSICVOL:
|
|
AdpcmSetMusicVolume( dataU );
|
|
break;
|
|
|
|
case EzADPCM_SETMUSICVOLDIRECT:
|
|
AdpcmSetMusicVolumeDirect( dataU );
|
|
break;
|
|
|
|
case EzADPCM_SETSTREAMVOL:
|
|
AdpcmSetStreamVolume( dataU );
|
|
break;
|
|
|
|
case EzADPCM_SETSTREAMVOLDIRECT:
|
|
AdpcmSetStreamVolumeDirect( dataU );
|
|
break;
|
|
|
|
case EzADPCM_GETSTATUS:
|
|
ret = AdpcmGetStatus( );
|
|
break;
|
|
|
|
case EzADPCM_GETMUSICSTATUS:
|
|
ret = AdpcmGetMusicStatus( );
|
|
break;
|
|
|
|
case EzADPCM_GETSTREAMSTATUS:
|
|
ret = AdpcmGetStreamStatus( );
|
|
break;
|
|
|
|
case EzADPCM_SDINIT:
|
|
AdpcmSdInit( );
|
|
break;
|
|
|
|
default:
|
|
ERROR (("EzADPCM driver error: unknown command %d \n", data));
|
|
break;
|
|
}
|
|
//printf( "! return value = %x \n", ret );
|
|
return (void*)(&ret);
|
|
}
|
|
|
|
int sce_adpcm_loop( void )
|
|
{
|
|
sceSifQueueData qd;
|
|
sceSifServeData sd;
|
|
|
|
sceSifInitRpc (0);
|
|
sceSifSetRpcQueue (&qd, GetThreadId ());
|
|
sceSifRegisterRpc (&sd, EzADPCM_DEV, dispatch, (void*)rpc_arg, NULL, NULL, &qd);
|
|
//Dbug_Printf(("goto adpcm cmd loop\n"));
|
|
|
|
sceSifRpcLoop (&qd);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------
|
|
* End on File
|
|
* ---------------------------------------------------------------- */
|
|
/* DON'T ADD STUFF AFTER THIS */
|