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);
}
Psp2Audio::~Psp2Audio() {
// Just to be sure to clean up before exiting
SE_Stop();
BGM_Stop();
// Closing BGM streaming thread
termStream = true;
sceKernelWaitThreadEnd(BGM_Thread, NULL, NULL);
if (BGM != NULL){
free(BGM->audiobuf);
audio_decoder.reset();
free(BGM);
}
// Starting exit procedure for sfx threads
mustExit = true;
sceKernelSignalSema(SFX_Mutex, 1);
for (int i=0;i<AUDIO_CHANNELS;i++){
sceKernelWaitThreadEnd(sfx_threads[i], NULL, NULL);
}
sfx_exited = 0;
// Deleting mutexs
sceKernelDeleteSema(BGM_Mutex);
sceKernelDeleteSema(SFX_Mutex);
sceKernelDeleteSema(SFX_Mutex_ID);
}
void checkSema(int doDispatch) {
SceUID sema = sceKernelCreateSema("sema", 0, 0, 1, NULL);
dispatchCheckpoint("sceKernelCreateSema: %08x", sema >= 0 ? 1 : sema);
dispatchCheckpoint("sceKernelSignalSema: %08x", sceKernelSignalSema(sema, 1));
dispatchCheckpoint("sceKernelWaitSema: %08x", sceKernelWaitSema(sema, 1, NULL));
dispatchCheckpoint("sceKernelWaitSema too much: %08x", sceKernelWaitSema(sema, 9, NULL));
dispatchCheckpoint("sceKernelDeleteSema: %08x", sceKernelDeleteSema(sema));
sema = sceKernelCreateSema("test", 0, 1, 2, NULL);
dispatchCheckpoint("sceKernelCreateSema: %08x", sema >= 0 ? 1 : sema);
startLockThreadSema(sema);
int state;
if (doDispatch) {
++ignoreResched;
state = sceKernelSuspendDispatchThread();
dispatchCheckpoint("sceKernelSuspendDispatchThread: %08x", state);
}
SceUInt timeout = 300;
dispatchCheckpoint("sceKernelWaitSema: %08x", sceKernelWaitSema(sema, 1, &timeout));
dispatchCheckpoint("sceKernelSignalSema: %08x", sceKernelSignalSema(sema, 1));
if (doDispatch) {
dispatchCheckpoint("sceKernelResumeDispatchThread: %08x", sceKernelResumeDispatchThread(state));
--ignoreResched;
}
endLockThreadSema(sema);
dispatchCheckpoint("sceKernelPollSema: %08x", sceKernelPollSema(sema, 1));
dispatchCheckpoint("sceKernelDeleteSema: %08x", sceKernelDeleteSema(sema));
}
int main(int argc, char **argv) {
int result;
int check_not_update_value = 7;
SceKernelSemaInfo info;
sema = sceKernelCreateSema("sema1", 0, 0, 2, NULL);
sceKernelReferSemaStatus(sema, &info);
PRINT_SEMAPHORE(sema, info);
threads[0] = sceKernelCreateThread("Thread-0", (void *)&threadFunction, 0x12, 0x10000, 0, NULL);
threads[1] = sceKernelCreateThread("Thread-1", (void *)&threadFunction, 0x12, 0x10000, 0, NULL);
threads[2] = sceKernelCreateThread("Thread-2", (void *)&threadFunction, 0x12, 0x10000, 0, NULL);
threads[3] = sceKernelCreateThread("Thread-3", (void *)&threadFunction, 0x12, 0x10000, 0, NULL);
threads[4] = sceKernelCreateThread("Thread-4", (void *)&threadFunction2, 0x12, 0x10000, 0, NULL);
schedf("VALUE-INVARIANT:%d\n", check_not_update_value);
sceKernelStartThread(threads[0], 1, (void*)&test[1]);
sceKernelStartThread(threads[1], 2, NULL);
sceKernelStartThread(threads[2], 0, (void*)&test[0]);
sceKernelStartThread(threads[3], sizeof(int), (void*)&test[4]);
sceKernelStartThread(threads[4], sizeof(int), &check_not_update_value);
sceKernelDelayThread(10 * 1000);
schedf("---\n");
sceKernelReferSemaStatus(sema, &info);
PRINT_SEMAPHORE(sema, info);
schedf("---\n");
sceKernelSignalSema(sema, 1);
sceKernelDelayThread(10 * 1000);
schedf("---\n");
sceKernelReferSemaStatus(sema, &info);
PRINT_SEMAPHORE(sema, info);
schedf("---\n");
sceKernelSignalSema(sema, 1);
sceKernelDelayThread(10 * 1000);
schedf("---\n");
sceKernelReferSemaStatus(sema, &info);
PRINT_SEMAPHORE(sema, info);
schedf("---\n");
result = sceKernelDeleteSema(sema);
schedf("%08X\n", result);
result = sceKernelDeleteSema(sema);
schedf("%08X\n", result);
schedf("VALUE-INVARIANT:%d\n", check_not_update_value);
flushschedf();
return 0;
}
void CDAudio_Shutdown(void)
{
mustExit = true;
sceKernelSignalSema(Audio_Mutex, 1);
sceKernelWaitThreadEnd(thread, NULL, NULL);
sceKernelDeleteSema(Audio_Mutex);
sceKernelDeleteSema(Talk_Mutex);
sceKernelDeleteThread(thread);
}
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;
}
Psp2Ui::~Psp2Ui() {
sceKernelWaitSema(GPU_Cleanup_Mutex, 1, NULL);
for (int i = 0; i < SHADERS_NUM; i++){
vita2d_free_shader(shaders[i]);
}
vita2d_free_texture(main_texture);
main_texture = NULL;
sceKernelSignalSema(GPU_Cleanup_Mutex, 1);
sceKernelWaitThreadEnd(GPU_Thread, NULL, NULL);
vita2d_free_texture(next_texture);
vita2d_free_texture(gpu_texture);
sceKernelDeleteSema(GPU_Mutex);
sceKernelDeleteSema(GPU_Cleanup_Mutex);
vita2d_fini();
}
// Exit callback
int exit_callback(int arg1, int arg2, void *common) {
int x;
StopApp();
for (x=0; x < MAX_BALLS; x++) { if (_activeBalls[x] != 0) free(_activeBalls[x]); } // Free memory used by active balls
if (_pauseSem) sceKernelDeleteSema(_pauseSem); // Destroy the pause semaphoresceKernelExitGame();
return 0;
}
int vpbp_init(void)
{
if (g_sema >= 0) {
sceKernelDeleteSema(g_sema);
}
g_sema = sceKernelCreateSema("VPBPSema", 0, 1, 1, NULL);
if (g_caches != NULL) {
oe_free(g_caches);
g_caches_cnt = 0;
}
g_caches_cnt = CACHE_MAX_SIZE;
g_caches = oe_malloc(sizeof(g_caches[0]) * g_caches_cnt);
if (g_caches == NULL) {
g_caches_cnt = 0;
printk("%s: g_cache cannot allocate\n", __func__);
return -27;
}
memset(g_caches, 0, sizeof(g_caches[0]) * g_caches_cnt);
return 0;
}
int sock_thread( SceSize args, void *argp )
{
unsigned char buffer[block_size], running = 1;
SocketOpts * opts = ( SocketOpts * )( *( unsigned int * )argp );
opts->buf = ( int * )buffer;
opts->sema = sceKernelCreateSema( "sock_sema", 0, 0, 1, NULL );
while( running )
{
sceKernelSleepThread();
switch ( opts->operation )
{
case S_SEND:
opts->res = sceNetInetSend( opts->server, opts->buf, opts->length, 0 );
log( "sent %d res %08x\n", opts->length, opts->res );
break;
case S_RECV:
opts->res = sceNetInetRecv( opts->server, opts->buf, opts->length, 0 );
break;
case S_TERM:
running = 0;
break;
}
sceKernelSignalSema( opts->sema, 1 );
}
sceKernelDeleteSema( opts->sema );
opts->sema = -1;
opts->thid = -1;
opts->buf = NULL;
return sceKernelExitDeleteThread( 0 );
}
int main(int argc, char **argv) {
SceUID sema = sceKernelCreateSema("wait1", 0, 1, 1, NULL);
WAIT_TEST_SIMPLE("Signaled", sema, 1);
WAIT_TEST_SIMPLE("Greater than max", sema, 100);
WAIT_TEST_SIMPLE("Negative", sema, -1);
sceKernelSignalSema(sema, 1);
WAIT_TEST_SIMPLE_TIMEOUT("Signaled", sema, 1, 500);
WAIT_TEST_SIMPLE_TIMEOUT("Never signaled", sema, 1, 500);
WAIT_TEST_SIMPLE_TIMEOUT("Greater than max", sema, 100, 500);
WAIT_TEST_SIMPLE_TIMEOUT("Zero", sema, 0, 500);
WAIT_TEST_SIMPLE_TIMEOUT("Negative", sema, -1, 500);
WAIT_TEST_SIMPLE_TIMEOUT("Zero timeout", sema, 1, 0);
// Signaled off thread.
printf("Wait timeout: ");
schedulingPlacement = 1;
SCHED_LOG(A, 1);
SceUInt timeout = 5000;
SceUID thread = sceKernelCreateThread("waitTest", (void *)&waitTestFunc, 0x12, 0x10000, 0, NULL);
sceKernelStartThread(thread, sizeof(int), &sema);
SCHED_LOG(B, 1);
int result = sceKernelWaitSema(sema, 1, &timeout);
SCHED_LOG(E, 1);
schedf(" (thread=%08X, main=%08X, remaining=%d)\n", schedulingResult, result, timeout / 1000);
flushschedf();
sceKernelDeleteSema(sema);
SceUID deleteThread = CREATE_SIMPLE_THREAD(deleteMeFunc);
sema = sceKernelCreateSema("wait1", 0, 0, 1, NULL);
sceKernelStartThread(deleteThread, sizeof(int), &sema);
sceKernelDelayThread(500);
sceKernelDeleteSema(sema);
flushschedf();
WAIT_TEST_SIMPLE("NULL", 0, 1);
WAIT_TEST_SIMPLE("Invalid", 0xDEADBEEF, 1);
WAIT_TEST_SIMPLE("Deleted", sema, 1);
BASIC_SCHED_TEST("NULL",
result = sceKernelWaitSema(0, 1, NULL);
);
/* Free the semaphore */
void SDL_DestroySemaphore(SDL_sem *sem)
{
if (sem != NULL) {
if (sem->semid > 0) {
sceKernelDeleteSema(sem->semid);
sem->semid = 0;
}
free(sem);
}
}
int main(int argc, char **argv) {
SceUID sema = sceKernelCreateSema("signal", 0, 0, 1, NULL);
PRINT_SEMAPHORE(sema);
SIGNAL_TEST("Basic +2", sema, 2);
SIGNAL_TEST("Basic +1", sema, 1);
SIGNAL_TEST("Negative - 1", sema, -1);
SIGNAL_TEST("Negative - 2", sema, -2);
SIGNAL_TEST("Zero", sema, 0);
sceKernelDeleteSema(sema);
sema = sceKernelCreateSema("signal", 0, -3, 3, NULL);
PRINT_SEMAPHORE(sema);
SIGNAL_TEST("Start negative", sema, 1);
sceKernelDeleteSema(sema);
SIGNAL_TEST("NULL", 0, 1);
SIGNAL_TEST("Invalid", 0xDEADBEEF, 1);
SIGNAL_TEST("Deleted", sema, 1);
TWO_STEP_SCHED_TEST("Signal other then same", 0, 0,
result = sceKernelSignalSema(sema2, 1);
,
extern "C" int main(int argc, char **argv) {
SceUID th1 = sceKernelCreateThread("thread1", &thread1, 0x21, 0x1000, 0, NULL);
SceUID th2 = sceKernelCreateThread("thread2", &thread2, 0x21, 0x1000, 0, NULL);
sema = sceKernelCreateSema("vpl", 0, 0, 10, NULL);
sceKernelSignalSema(sema, 1);
checkpoint("starting");
sceKernelStartThread(th1, 0, NULL);
sceKernelStartThread(th2, 0, NULL);
checkpoint("waiting");
sceKernelDelayThread(10000);
checkpoint("deleting");
sceKernelDeleteSema(sema);
checkpoint("done, waiting");
sceKernelDelayThread(10000);
return 0;
}
int main(int argc, char **argv) {
SceUID sema = sceKernelCreateSema("cancel", 0, 0, 1, NULL);
CANCEL_TEST("Normal", sema, 1);
CANCEL_TEST("Greater than max", sema, 3);
CANCEL_TEST("Zero", sema, 0);
CANCEL_TEST("Negative -3", sema, -3);
CANCEL_TEST("Negative -1", sema, -1);
CANCEL_TEST_WITH_WAIT("Normal", sema, 1);
CANCEL_TEST_WITH_WAIT("Greater than max", sema, 3);
CANCEL_TEST_WITH_WAIT("Zero", sema, 0);
CANCEL_TEST_WITH_WAIT("Negative -3", sema, -3);
CANCEL_TEST_WITH_WAIT("Negative -1", sema, -1);
sceKernelDeleteSema(sema);
TWO_STEP_SCHED_TEST("Cancel waited 0 then 1", 0, 1,
result = 0;
CANCEL_TEST_WITH_WAIT("To 0", sema1, 0);
,
/*----------------------------------------------------------------------
| NPT_PSPMutex::~NPT_PSPMutex
+---------------------------------------------------------------------*/
NPT_PSPMutex::~NPT_PSPMutex()
{
sceKernelDeleteSema(m_semaphore);
}
SceInt32 CPMFPlayer::InitAudio()
{
int i = 0, fail = 0;
Audio.m_AudioChannel = sceAudioChReserve(-1, 512, PSP_AUDIO_FORMAT_STEREO);
if(Audio.m_AudioChannel < 0)
{
sprintf(m_LastError, "sceAudioChReserve() failed: 0x%08X", (int)Audio.m_AudioChannel);
return -1;
}
sceAudioSetChannelDataLen(Audio.m_AudioChannel, m_MpegAtracOutSize / 4);
Audio.m_ThreadID = sceKernelCreateThread("audio_thread", T_Audio, 0x3D, 0x10000, PSP_THREAD_ATTR_USER, NULL);
if(Audio.m_ThreadID < 0)
{
sprintf(m_LastError, "sceKernelCreateThread() failed: 0x%08X", (int)Audio.m_ThreadID);
goto exit0;
}
Audio.m_SemaphoreStart = sceKernelCreateSema("audio_start_sema", 0, 0, 1, NULL);
if(Audio.m_SemaphoreStart < 0)
{
sprintf(m_LastError, "sceKernelCreateSema() failed: 0x%08X", (int)Audio.m_SemaphoreStart);
goto exit1;
}
Audio.m_SemaphoreLock = sceKernelCreateSema("audio_lock_sema", 0, 1, 1, NULL);
if(Audio.m_SemaphoreLock < 0 )
{
sprintf(m_LastError, "sceKernelCreateSema() failed: 0x%08X", (int)Audio.m_SemaphoreLock);
goto exit2;
}
Audio.m_iNumBuffers = 4;
Audio.m_iFullBuffers = 0;
Audio.m_iPlayBuffer = 1;
Audio.m_iDecodeBuffer = 0;
Audio.m_iAbort = 0;
Audio.m_LastError = m_LastError;
for(i = 0; i < Audio.m_iNumBuffers; i++)
{
Audio.m_pAudioBuffer[i] = NULL;
Audio.m_iBufferTimeStamp[i] = 0;
}
for(i = 0; i < Audio.m_iNumBuffers; i++)
{
Audio.m_pAudioBuffer[i] = memalign(64, m_MpegAtracOutSize);
if(Audio.m_pAudioBuffer[i] < 0) fail++;
}
if(fail > 0)
{
for(i = 0; i < Audio.m_iNumBuffers; i++)
{
if(Audio.m_pAudioBuffer[i] != NULL)
free(Audio.m_pAudioBuffer[i]);
}
sprintf(m_LastError, "malloc() failed!");
goto exit3;
}
return 0;
exit3:
sceKernelDeleteSema(Audio.m_SemaphoreLock);
exit2:
sceKernelDeleteSema(Audio.m_SemaphoreStart);
exit1:
sceKernelDeleteThread(Audio.m_ThreadID);
exit0:
sceAudioChRelease(Audio.m_AudioChannel);
return -1;
}
int deleteSema(sema){
return sceKernelDeleteSema(sema) ? 0x80000041:0;
}
~eSimpleMutex()
{
sceKernelDeleteSema(handle);
}
