void pmp_play_close(struct pmp_play_struct *p, int usePos, int pspType)
{
if (!(p->audio_reserved < 0)) {
while(sceAudioGetChannelRestLen(0) > 0 );
sceAudioChRelease(0);
}
cooleyesAudioSetFrequency(sceKernelDevkitVersion(), 44100);
if (!(p->semaphore_can_get < 0)) sceKernelDeleteSema(p->semaphore_can_get);
if (!(p->semaphore_can_put < 0)) sceKernelDeleteSema(p->semaphore_can_put);
if (!(p->semaphore_can_show < 0)) sceKernelDeleteSema(p->semaphore_can_show);
if (!(p->semaphore_show_done < 0)) sceKernelDeleteSema(p->semaphore_show_done);
if (!(p->output_thread < 0)) sceKernelDeleteThread(p->output_thread);
if (!(p->show_thread < 0)) sceKernelDeleteThread(p->show_thread);
pmp_decode_close(&p->decoder, pspType);
int i = 0;
for (i=0; i<p->subtitle_count; i++)
subtitle_parse_close( &subtitle_parser[i] );
//if (usePos) pmp_stat_save( p );
pmp_stat_save( p );
pmp_play_safe_constructor(p);
}
int main(int argc, char **argv) {
int i;
char temp[32];
checkpointNext("Names:");
testCreate(" Normal", "create", &testFunc, 0x20, 0x10000, 0, NULL);
testCreate(" NULL name", NULL, &testFunc, 0x20, 0x10000, 0, NULL);
testCreate(" Blank name", "", &testFunc, 0x20, 0x10000, 0, NULL);
testCreate(" Long name", "1234567890123456789012345678901234567890123456789012345678901234", &testFunc, 0x20, 0x10000, 0, NULL);
checkpointNext("Attributes:");
u32 attrs[] = {1, 0x10, 0x50, 0x100, 0x200, 0x400, 0x600, 0x800, 0xF00, 0x1000, 0x2000, 0x4000, 0x8000, 0x6000, 0xF000, 0x10000, 0x20000, 0x40000, 0x80000, 0xF0000, 0x100000, 0x200000, 0x400000, 0x800000, 0xF00000, 0x1000000, 0x2000000, 0x4000000, 0x8000000, 0xF000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 0xF0000000};
for (i = 0; i < sizeof(attrs) / sizeof(attrs[0]); ++i) {
sprintf(temp, " 0x%x attr", attrs[i]);
testCreate(temp, "create", &testFunc, 0x20, 0x10000, attrs[i], NULL);
}
checkpointNext("Stack size:");
testCreate(" Zero stack", "create", &testFunc, 0x20, 0, 0, NULL);
int stacks[] = {-1, 1, -0x10000, 0x100, 0x1FF, 0x200, 0x1000, 0x100000, 0x1000000, 0x1000001, 0x20000000};
for (i = 0; i < sizeof(stacks) / sizeof(stacks[0]); ++i) {
sprintf(temp, " 0x%08x stack", stacks[i]);
testCreate(temp, "create", &testFunc, 0x20, stacks[i], 0, NULL);
}
checkpointNext("Priorities:");
int prios[] = {0, 0x06, 0x07, 0x08, 0x77, 0x78, -1};
for (i = 0; i < sizeof(prios) / sizeof(prios[0]); ++i) {
sprintf(temp, " 0x%02x priority", prios[i]);
testCreate(temp, "create", &testFunc, prios[i], 0x200, 0, NULL);
}
checkpointNext("Entry:");
testCreate(" Null entry", "create", NULL, 0x20, 0x10000, 0, NULL);
testCreate(" Invalid entry", "create", (SceKernelThreadEntry) 0xDEADBEEF, 0x20, 0x10000, 0, NULL);
// TODO: Options?
checkpointNext(NULL);
SceUID thread1 = sceKernelCreateThread("create", &testFunc, 0x20, 0x1000, 0, NULL);
SceUID thread2 = sceKernelCreateThread("create", &testFunc, 0x20, 0x1000, 0, NULL);
if (thread1 > 0 && thread2 > 0) {
checkpoint("Two with same name: OK");
} else {
checkpoint("Two with same name: Failed (%X, %X)", thread1, thread2);
}
sceKernelDeleteThread(thread1);
sceKernelDeleteThread(thread2);
checkpointNext(NULL);
SceUID thread;
BASIC_SCHED_TEST("NULL name",
thread = sceKernelCreateThread(NULL, &testFunc, 0x20, 0x1000, 0, NULL);
result = thread > 0 ? 1 : thread;
);
int resolveSyscall(tStubEntry *dst, tStubEntry *netLib)
{
Arg arg;
SceUID thid;
size_t jump_size;
int r;
if (dst == NULL || netLib == NULL)
return SCE_KERNEL_ERROR_ILLEGAL_ADDR;
jump_size = dst->stub_size * 8;
dst->import_flags = 0x0011;
dst->lib_ver = strcmp(dst->lib_name, "sceSuspendForUser") ? 0x4001 : 0x4000;
arg.src = dst;
arg.dst = netLib;
thid = sceKernelCreateThread("HBL Stub Information Injector",
(void *)store, 8, 512, THREAD_ATTR_USER, NULL);
if (thid < 0)
return thid;
r = unloadNetCommon();
if (r) {
sceKernelDeleteThread(thid);
return r;
}
r = sceKernelStartThread(thid, sizeof(arg), &arg);
if (r) {
sceKernelDeleteThread(thid);
loadNetCommon();
return r;
}
r = loadNetCommon();
if (r) {
kill_thread(thid);
loadNetCommon();
return r;
}
r = sceKernelDeleteThread(thid);
if (r)
return r;
memcpy(dst->jump_p, jump_p, jump_size);
return 0;
}
void pl_snd_shutdown()
{
int i;
sound_ready = 0;
sound_stop = 1;
for (i = 0; i < AUDIO_CHANNELS; i++)
{
if (sound_stream[i].thread_handle != -1)
{
//sceKernelWaitThreadEnd(sound_stream[i].threadhandle,NULL);
sceKernelDeleteThread(sound_stream[i].thread_handle);
}
sound_stream[i].thread_handle = -1;
}
for (i = 0; i < AUDIO_CHANNELS; i++)
{
if (sound_stream[i].sound_ch_handle != -1)
{
sceAudioOutReleasePort(sound_stream[i].sound_ch_handle);
sound_stream[i].sound_ch_handle = -1;
}
}
free_buffers();
}
/* psp_timer_exit:
* Shuts down the PSP timer thread.
*/
static void psp_timer_exit(void)
{
psp_timer_on = FALSE;
sceKernelDeleteThread(timer_thread_UID);
return;
}
static void CleanUp(){
if ( mp3_audio_thread >= 0 ) {
sceKernelDeleteThread(mp3_audio_thread);
mp3_audio_thread = -1;
}
if ( mp3_audio_channel >= 0 ) {
sceAudioChRelease(mp3_audio_channel);
mp3_audio_channel = -1;
}
if ( !mp3_file_handle ) {
sceIoClose(mp3_file_handle);
mp3_file_handle = 0;
}
mp3_data_start = 0;
mp3_output_buffers = 0;
mp3_play = 0;
mp3_pause = 0;
if ( mp3_codec_flag ) {
sceAudiocodecReleaseEDRAM(mp3_codec_buffer);
mp3_codec_flag = 0;
}
}
/*------------------------------------------------------------------------------*/
int module_stop( SceSize args, void *argp )
{
if ( MainThreadID >= 0 ){ sceKernelDeleteThread( MainThreadID ); }
return( 0 );
}
/***
* Shuts down the audio systems and frees the buffers.
*/
void audio_shutdown()
{
int i;
stop_audio = 1;
for (i = 0; i < AUDIO_CHANNELS; i++)
{
if (audio_status[i].ThreadHandle != -1)
{
sceKernelDeleteThread(audio_status[i].ThreadHandle);
}
audio_status[i].ThreadHandle = -1;
}
for (i = 0; i < AUDIO_CHANNELS; i++)
{
if (audio_status[i].Handle != -1)
{
sceAudioOutReleasePort(audio_status[i].Handle);
audio_status[i].Handle = -1;
}
}
free_buffers();
sceKernelDeleteMutex(audio_mutex);
}
int music_free(void)
{
int ret;
unsigned to = 500000;
cache_on(false);
music_lock();
ret = -1;
while (ret != 0) {
ret = music_stop();
if (ret != 0)
sceKernelDelayThread(100000);
}
g_list.is_list_playing = 0;
g_thread_actived = 0;
music_unlock();
if (sceKernelWaitThreadEnd(g_music_thread, &to) != 0) {
sceKernelTerminateDeleteThread(g_music_thread);
} else {
sceKernelDeleteThread(g_music_thread);
}
xr_lock_destroy(&music_l);
return 0;
}
int terminateDeleteAllUserThreads()
{
SceKernelSemaInfo semaInfo;
SceKernelThreadInfo threadInfo;
globals_t *globals;
int res;
globals = getGlobals();
sceKernelLockMutex(globals->threadmgrMutex, 1, NULL);
semaInfo.size = sizeof(semaInfo);
res = sceKernelGetSemaInfo(globals->threadmgrSema, &semaInfo);
if (res)
return res;
while (semaInfo.currentCount < semaInfo.maxCount) {
res = sceKernelGetThreadInfo(globals->threadmgrTable[semaInfo.currentCount].uid, &threadInfo);
if (res == 0 && (threadInfo.status == PSP2_THREAD_STOPPED
|| threadInfo.status == PSP2_THREAD_KILLED))
sceKernelDeleteThread(globals->threadmgrTable[semaInfo.currentCount].uid);
else
sceKernelNotifyCallback(globals->threadmgrTable[semaInfo.currentCount].exitDeleteCb, 0);
semaInfo.currentCount++;
}
sceKernelUnlockMutex(globals->threadmgrMutex, 1);
sceKernelWaitSema(globals->threadmgrSema, MAX_THREADS_NUM, NULL);
sceKernelSignalSema(globals->threadmgrSema, MAX_THREADS_NUM);
return 0;
}
int MP3ME_Stop(){
MP3ME_isPlaying = 0;
MP3ME_threadActive = 0;
sceKernelWaitThreadEnd(MP3ME_thid, NULL);
sceKernelDeleteThread(MP3ME_thid);
return 0;
}
int pspAudioInit()
{
int i,ret;
int failed=0;
char str[32];
audio_terminate=0;
audio_ready=0;
for (i=0; i<PSP_NUM_AUDIO_CHANNELS; i++) {
AudioStatus[i].handle = -1;
AudioStatus[i].threadhandle = -1;
AudioStatus[i].volumeright = PSP_VOLUME_MAX;
AudioStatus[i].volumeleft = PSP_VOLUME_MAX;
AudioStatus[i].callback = 0;
AudioStatus[i].pdata = 0;
}
for (i=0; i<PSP_NUM_AUDIO_CHANNELS; i++) {
if ((AudioStatus[i].handle = sceAudioChReserve(-1,PSP_NUM_AUDIO_SAMPLES,0))<0)
failed=1;
}
if (failed) {
for (i=0; i<PSP_NUM_AUDIO_CHANNELS; i++) {
if (AudioStatus[i].handle != -1)
sceAudioChRelease(AudioStatus[i].handle);
AudioStatus[i].handle = -1;
}
return -1;
}
audio_ready = 1;
strcpy(str,"audiot0");
for (i=0; i<PSP_NUM_AUDIO_CHANNELS; i++) {
str[6]='0'+i;
AudioStatus[i].threadhandle = sceKernelCreateThread(str,(void*)&AudioChannelThread,0x12,0x10000,0,NULL);
if (AudioStatus[i].threadhandle < 0) {
AudioStatus[i].threadhandle = -1;
failed=1;
break;
}
ret=sceKernelStartThread(AudioStatus[i].threadhandle,sizeof(i),&i);
if (ret!=0) {
failed=1;
break;
}
}
if (failed) {
audio_terminate=1;
for (i=0; i<PSP_NUM_AUDIO_CHANNELS; i++) {
if (AudioStatus[i].threadhandle != -1) {
//sceKernelWaitThreadEnd(AudioStatus[i].threadhandle,NULL);
sceKernelDeleteThread(AudioStatus[i].threadhandle);
}
AudioStatus[i].threadhandle = -1;
}
audio_ready=0;
return -1;
}
return 0;
}
void CDAudio_Shutdown(void)
{
mustExit = true;
sceKernelSignalSema(Audio_Mutex, 1);
sceKernelWaitThreadEnd(thread, NULL, NULL);
sceKernelDeleteSema(Audio_Mutex);
sceKernelDeleteSema(Talk_Mutex);
sceKernelDeleteThread(thread);
}
int MP3ME_Stop(){
MP3ME_isPlaying = 0;
MP3ME_threadActive = 0;
while (!MP3ME_threadExited)
sceKernelDelayThread(100000);
sceKernelDeleteThread(MP3ME_thid);
MP3ME_thid = -1;
return 0;
}
/* digi_psp_exit:
* Shuts down the sound driver.
*/
static void digi_psp_exit(int input)
{
if (input)
return;
psp_audio_on = FALSE;
sceKernelDeleteThread(audio_thread_UID);
sceAudioChRelease(hw_channel);
_mixer_exit();
}
void testCreate(const char *title, const char *name, SceKernelThreadEntry entry, int prio, int stack, SceUInt attr, SceKernelThreadOptParam *opt) {
SceUID result = sceKernelCreateThread(name, entry, prio, stack, attr, opt);
if (result > 0) {
checkpoint(NULL);
schedf("%s: ", title);
schedfThreadStatus(result);
sceKernelDeleteThread(result);
} else {
checkpoint("%s: Failed (%08X)", title, result);
}
}
void OSPC_StopPlay(){
if (OSPC_thread<0) return;
OSPC_exit=1;
sceKernelWaitThreadEnd( OSPC_thread, NULL );
sceKernelDeleteThread( OSPC_thread );
OSPC_thread=-1;
sceAudioChRelease( OSPC_sound_fd );
OSPC_Stop();
OSPC_Close();
if (OSPC_id) free(OSPC_id);
}
void
psp_audio_end()
{
psp_audio_term = 1;
if (psp_audio_thid != -1) {
sceKernelDeleteThread( psp_audio_thid );
psp_audio_thid = -1;
}
if (psp_cdaudio_thid != -1) {
sceKernelDeleteThread( psp_cdaudio_thid );
psp_cdaudio_thid = -1;
}
if (psp_audio_chid != -1) {
sceAudioChRelease( psp_audio_chid );
psp_audio_chid = -1;
}
if (psp_cdaudio_chid != -1) {
sceAudioChRelease( psp_cdaudio_chid );
psp_cdaudio_chid = -1;
}
}
SceInt32 CPMFPlayer::ShutdownAudio()
{
sceAudioChRelease(Audio.m_AudioChannel); //Human-Behind
sceKernelDeleteThread(Audio.m_ThreadID);
sceKernelDeleteSema(Audio.m_SemaphoreStart);
sceKernelDeleteSema(Audio.m_SemaphoreLock);
for(int i = 0; i < Audio.m_iNumBuffers; i++)
free(Audio.m_pAudioBuffer[i]);
return 0;
}
void OSPC_PlayBuffer(char *buff,int len,int release,int vol)
{
int i,j,pollcpt;
char str[256];
SPC_ID666 *id;
char *emulator[3]={"Unknown","Zsnes","Snes9x"};
uint8 *scr;
OSPC_Init();
if (i=OSPC_LoadBuffer(buff,len))
{
sprintf(str,"Error at SPC loading, code : %d",i);
msgBoxLines(str,60);
//gp32_pause();
//GpAppExit();
return;
}
OSPC_id=OSPC_GetID666(spc_data);
OSPC_sound_fd = sceAudioChReserve( -1, 1024, 0 );
OSPC_exit=0;
OSPC_volume=vol;
OSPC_thread = sceKernelCreateThread( "OSPC Thread", (SceKernelThreadEntry)OSPC_PlayThread, 0x8, 256*1024, 0, 0 );
if (OSPC_thread<0) {
msgBoxLines("Cannot create OSPC playback thread",60);
} else {
//init start time
sceKernelLibcGettimeofday( &OSPC_start_time, 0 );
sceKernelStartThread( OSPC_thread, 0, 0 );
if (release) return;
for (;;) {
pgWaitV();
if (get_pad()) break;
}
OSPC_exit=1;
sceKernelWaitThreadEnd( OSPC_thread, NULL );
sceKernelDeleteThread( OSPC_thread );
OSPC_thread=-1;
}
sceAudioChRelease( OSPC_sound_fd );
OSPC_Stop();
OSPC_Close();
if (OSPC_id) free(OSPC_id);
}
static void psp_audio_free(void *data)
{
SceUInt timeout = 100000;
psp1_audio_t* psp = (psp1_audio_t*)data;
if(!psp)
return;
psp->running = false;
sceKernelWaitThreadEnd(psp->thread, &timeout);
sceKernelDeleteThread(psp->thread);
free(psp->buffer);
free(psp->zeroBuffer);
free(psp);
}
void mp3_thread_stop(void)
{
if (mp3_thread >= 0)
{
mp3_active = 0;
mp3_stop();
sceKernelWakeupThread(mp3_thread);
sceKernelWaitThreadEnd(mp3_thread, NULL);
sceKernelDeleteThread(mp3_thread);
mp3_thread = -1;
sceAudioChRelease(mp3_handle);
mp3_handle = -1;
}
}
static void psp_audio_free(void *data)
{
SceUInt timeout = 100000;
psp_audio_t* psp = (psp_audio_t*)data;
if(!psp)
return;
psp->running = false;
#if defined(VITA)
sceKernelWaitThreadEnd(psp->thread, NULL, &timeout);
#else
sceKernelWaitThreadEnd(psp->thread, &timeout);
#endif
sceKernelDeleteThread(psp->thread);
free(psp->buffer);
free(psp->zeroBuffer);
free(psp);
}
void audio_Term(void)
{
int i;
audio_ready = 0;
audio_terminate = 1;
for (i=0; i<CHANNELS; i++) {
if (audio_thread_handle[i] != -1) {
sceKernelWaitThreadEnd(audio_thread_handle[i], NULL);
sceKernelDeleteThread(audio_thread_handle[i]);
}
audio_thread_handle[i] = -1;
}
for (i=0; i<CHANNELS; i++) {
if (audio_handles[i] != -1) {
sceAudioChRelease(audio_handles[i]);
audio_handles[i] = -1;
}
}
}
void pspAudioEnd()
{
int i;
audio_ready=0;
audio_terminate=1;
for (i=0; i<PSP_NUM_AUDIO_CHANNELS; i++) {
if (AudioStatus[i].threadhandle != -1) {
//sceKernelWaitThreadEnd(AudioStatus[i].threadhandle,NULL);
sceKernelDeleteThread(AudioStatus[i].threadhandle);
}
AudioStatus[i].threadhandle = -1;
}
for (i=0; i<PSP_NUM_AUDIO_CHANNELS; i++) {
if (AudioStatus[i].handle != -1) {
sceAudioChRelease(AudioStatus[i].handle);
AudioStatus[i].handle = -1;
}
}
}
static void psp_audio_free(void *data)
{
SceUInt timeout = 100000;
psp_audio_t* psp = (psp_audio_t*)data;
if(!psp)
return;
psp->running = false;
#if defined(VITA)
sceKernelWaitThreadEnd(psp->thread, NULL, &timeout);
sceKernelDeleteLwMutex((struct SceKernelLwMutexWork*)&psp->lock);
sceKernelDeleteLwMutex((struct SceKernelLwMutexWork*)&psp->cond_lock);
sceKernelDeleteLwCond(&psp->cond);
#else
sceKernelWaitThreadEnd(psp->thread, &timeout);
#endif
free(psp->buffer);
sceKernelDeleteThread(psp->thread);
free(psp->zeroBuffer);
free(psp);
}
/**
* Setup Matching Threads for Context
* @param context Matching Context
* @param event_th_prio Event Caller Thread Priority
* @param event_th_stack Event Caller Thread Stack Size
* @param input_th_prio IO Handler Thread Priority
* @param input_th_stack IO Handler Thread Stack Size
* @return 0 on success or... -1
*/
int _setupMatchingThreads(SceNetAdhocMatchingContext * context, int event_th_prio, int event_th_stack, int input_th_prio, int input_th_stack)
{
// Fix Input Thread Stack Size
input_th_stack = 50 * 1024;
// Thread Name Buffer
char threadname[128];
// Create Event Thread Name
sprintf(threadname, "matching_ev%d", context->id);
// Create Event Thread
context->event_thid = sceKernelCreateThread(threadname, _matchingEventThread, event_th_prio, event_th_stack, 0, NULL);
// Created Event Thread
if(context->event_thid > 0)
{
// Started Event Thread
if(sceKernelStartThread(context->event_thid, sizeof(context), &context) == 0)
{
// Create IO Thread Name
sprintf(threadname, "matching_io%d", context->id);
// Create IO Thread
context->input_thid = sceKernelCreateThread(threadname, _matchingInputThread, input_th_prio, input_th_stack, 0, NULL);
// Created IO Thread
if(context->input_thid > 0)
{
// Started Input Thread
if(sceKernelStartThread(context->input_thid, sizeof(context), &context) == 0)
{
// Setup Success
return 0;
}
// Delete IO Thread
sceKernelDeleteThread(context->input_thid);
// Delete IO Thread Reference
context->input_thid = 0;
}
// Clean Event Thread Shutdown
context->event_thid = -1;
// Wait for Shutdown
while(context->event_thid != 0) sceKernelDelayThread(10000);
// Return Generic Error
return -1;
}
// Delete Event Thread
sceKernelDeleteThread(context->event_thid);
// Delete Event Thread Reference
context->event_thid = 0;
}
// Return Generic Error
return -1;
}
/***
* Initializes the audio buffers and a callback thread for each channel.
*/
int setup_audio()
{
int i, j, failed;
stop_audio = 0;
for (i = 0; i < AUDIO_CHANNELS; i++)
{
audio_status[i].Handle = -1;
audio_status[i].ThreadHandle = -1;
audio_status[i].LeftVolume = PSP_AUDIO_MAX_VOLUME;
audio_status[i].RightVolume = PSP_AUDIO_MAX_VOLUME;
audio_status[i].Callback = NULL;
audio_status[i].Userdata = NULL;
for (j = 0; j < 2; j++)
{
audio_buffer[i][j] = NULL;
audio_buffer_samples[i][j] = 0;
}
}
/* Initialize buffers */
for (i = 0; i < AUDIO_CHANNELS; i++)
{
for (j = 0; j < 2; j++)
{
if (!(audio_buffer[i][j] = (short*)malloc(AUDIO_SAMPLE_COUNT * sizeof(PspStereoSample))))
{
printf("Couldn't initialize audio buffer for channel %i, bailing.", i);
free_buffers();
sceKernelExitProcess(0);
return 0;
}
audio_buffer_samples[i][j] = AUDIO_SAMPLE_COUNT;
}
}
/* Initialize channels */
for (i = 0, failed = 0; i < AUDIO_CHANNELS; i++)
{
audio_status[i].Handle = sceAudioOutOpenPort(SCE_AUDIO_OUT_PORT_TYPE_VOICE, AUDIO_SAMPLE_COUNT, AUDIO_OUTPUT_RATE, SCE_AUDIO_OUT_MODE_STEREO);
if (audio_status[i].Handle < 0)
{
failed = 1;
break;
}
}
if (failed)
{
for (i = 0; i < AUDIO_CHANNELS; i++)
{
if (audio_status[i].Handle != -1)
{
sceAudioOutReleasePort(audio_status[i].Handle);
audio_status[i].Handle = -1;
}
}
printf("Couldn't open audio port for the device, bailing.");
free_buffers();
sceKernelExitProcess(0);
return 0;
}
char label[16];
strcpy(label, "audiotX");
for (i = 0; i < AUDIO_CHANNELS; i++)
{
label[6] = '0' + i;
audio_status[i].ThreadHandle =
sceKernelCreateThread(label, (void*)&audio_channel_thread, 0x10000100, 0x10000,
0, 0, NULL);
if (audio_status[i].ThreadHandle < 0)
{
audio_status[i].ThreadHandle = -1;
failed = 1;
break;
}
if (sceKernelStartThread(audio_status[i].ThreadHandle, sizeof(i), &i) != 0)
{
failed = 1;
break;
}
}
if (failed)
{
stop_audio = 1;
for (i = 0; i < AUDIO_CHANNELS; i++)
{
if (audio_status[i].ThreadHandle != -1)
{
sceKernelDeleteThread(audio_status[i].ThreadHandle);
}
audio_status[i].ThreadHandle = -1;
}
printf("Couldn't initialize audio callback thread. Bailing.");
sceKernelExitProcess(0);
return 0;
}
// initialize the buffer our libretro audio callback will fill with data as it's available
retro_audio_callback_buffer = (int16_t*)malloc(sizeof(int16_t) * AUDIO_SAMPLE_COUNT * 4);
if (!retro_audio_callback_buffer)
{
printf("Couldn't initialize retro_audio_callback_buffer. Bailing.");
sceKernelExitProcess(0);
}
curr_buffer_frames = 0;
// setup our callbacks
set_audio_channel_callback(0, audio_callback, 0);
// initialize the audio buffer mutex
audio_mutex = sceKernelCreateMutex("AudioMutex", 0, 1, 0);
return AUDIO_SAMPLE_COUNT;
}
int module_stop()
{
return sceKernelDeleteThread(id);
}
void runReferTests() {
SceKernelThreadInfo2 info;
int i;
SceUID delayThread = sceKernelCreateThread("delay", &delayFunc, sceKernelGetThreadCurrentPriority(), 0x1000, PSP_THREAD_ATTR_VFPU, NULL);
SceUID deletedThread = sceKernelCreateThread("deleted", &delayFunc, sceKernelGetThreadCurrentPriority(), 0x1000, 0, NULL);
sceKernelDeleteThread(deletedThread);
info.size = sizeof(info);
checkpointNext("Thread IDs:");
checkpoint(" NULL: %08x", sceKernelReferThreadStatus(0, &info));
checkpoint(" Current: %08x", sceKernelReferThreadStatus(sceKernelGetThreadId(), &info));
checkpoint(" Deleted: %08x", sceKernelReferThreadStatus(deletedThread, &info));
checkpoint(" Invalid: %08x", sceKernelReferThreadStatus(0xDEADBEEF, &info));
// Crashes.
//checkpointNext("sceKernelReferThreadStatus info ptr:");
//checkpoint(" NULL info: %08x", sceKernelReferThreadStatus(0, NULL));
checkpointNext("Sizes:");
int sizes[] = {-1, 0, 1, 2, 3, 4, 5, 8, 16, 32, 64, 80, 82, 108, 128, 1024};
for (i = 0; i < ARRAY_SIZE(sizes); ++i) {
memset(&info, 0xff, sizeof(info));
info.size = sizes[i];
int result = sceKernelReferThreadStatus(0, &info);
checkpoint(" %d: %08x => %d (exit: %x)", sizes[i], result, info.size, info.exitStatus);
}
info.size = sizeof(info);
sceKernelStartThread(delayThread, 0, NULL);
sceKernelReferThreadStatus(delayThread, &info);
checkpointNext("Values:");
schedfThreadInfo(&info, &delayFunc);
SceUID slumberThread = sceKernelCreateThread("slumber", &slumberFunc, sceKernelGetThreadCurrentPriority() - 1, 0x1000, 0, NULL);
checkpoint(" slumber before start:");
sceKernelReferThreadStatus(slumberThread, &info);
schedfThreadInfo(&info, &slumberFunc);
sceKernelStartThread(slumberThread, 0, NULL);
checkpoint(" started slumber");
checkpoint(" slumber after start:");
sceKernelReferThreadStatus(slumberThread, &info);
schedfThreadInfo(&info, &slumberFunc);
sceKernelTerminateThread(slumberThread);
checkpoint(" terminated slumber");
checkpoint(" slumber after terminate:");
sceKernelReferThreadStatus(slumberThread, &info);
schedfThreadInfo(&info, &slumberFunc);
sceKernelStartThread(slumberThread, 0, NULL);
checkpoint(" started slumber");
checkpoint(" slumber after start:");
sceKernelReferThreadStatus(slumberThread, &info);
schedfThreadInfo(&info, &slumberFunc);
checkpoint(" woke slumber: %08x", sceKernelWakeupThread(slumberThread));
checkpoint(" slumber after wake:");
sceKernelReferThreadStatus(slumberThread, &info);
schedfThreadInfo(&info, &slumberFunc);
sceKernelTerminateDeleteThread(slumberThread);
checkpoint(" terminated and deleted slumber");
// TODO: Test more cases.
flushschedf();
}
